func open(
controllerModelTag names.ModelTag,
info *mongo.MongoInfo, opts mongo.DialOpts,
newPolicy NewPolicyFunc,
clock clock.Clock,
) (*State, error) {
logger.Infof("opening state, mongo addresses: %q; entity %v", info.Addrs, info.Tag)
logger.Debugf("dialing mongo")
session, err := mongo.DialWithInfo(info.Info, opts)
if err != nil {
return nil, maybeUnauthorized(err, "cannot connect to mongodb")
}
logger.Debugf("connection established")
err = mongodbLogin(session, info)
if err != nil {
session.Close()
return nil, errors.Trace(err)
}
logger.Debugf("mongodb login successful")
st, err := newState(controllerModelTag, controllerModelTag, session, info, newPolicy, clock)
if err != nil {
return nil, errors.Trace(err)
}
return st, nil
}
// dialAndLogin returns a mongo session logged in as a user with administrative
// privileges
func dialAndLogin(mongoInfo *mongo.MongoInfo, callArgs retry.CallArgs) (mgoSession, mgoDb, error) {
var session *mgo.Session
opts := mongo.DefaultDialOpts()
callArgs.Func = func() error {
// Try to connect, retry a few times until the db comes up.
var err error
session, err = mongo.DialWithInfo(mongoInfo.Info, opts)
if err == nil {
return nil
}
logger.Errorf("cannot open mongo connection: %v", err)
return err
}
if err := retry.Call(callArgs); err != nil {
return nil, nil, errors.Annotate(err, "error dialing mongo to resume HA")
}
admin := session.DB("admin")
if mongoInfo.Tag != nil {
if err := admin.Login(mongoInfo.Tag.String(), mongoInfo.Password); err != nil {
return nil, nil, errors.Annotatef(err, "cannot log in to admin database as %q", mongoInfo.Tag)
}
} else if mongoInfo.Password != "" {
if err := admin.Login(mongo.AdminUser, mongoInfo.Password); err != nil {
return nil, nil, errors.Annotate(err, "cannot log in to admin database")
}
}
return session, admin, nil
}
func open(tag names.EnvironTag, info *mongo.MongoInfo, opts mongo.DialOpts, policy Policy) (*State, error) {
logger.Infof("opening state, mongo addresses: %q; entity %v", info.Addrs, info.Tag)
logger.Debugf("dialing mongo")
session, err := mongo.DialWithInfo(info.Info, opts)
if err != nil {
return nil, maybeUnauthorized(err, "cannot connect to mongodb")
}
logger.Debugf("connection established")
// In rare circumstances, we may be upgrading from pre-1.23, and not have the
// environment UUID available. In that case we need to infer what it might be;
// we depend on the assumption that this is the only circumstance in which
// the the UUID might not be known.
if tag.Id() == "" {
logger.Warningf("creating state without environment tag; inferring bootstrap environment")
ssInfo, err := readRawStateServerInfo(session)
if err != nil {
return nil, errors.Trace(err)
}
tag = ssInfo.EnvironmentTag
}
st, err := newState(tag, session, info, policy)
if err != nil {
session.Close()
return nil, errors.Trace(err)
}
return st, nil
}
// initMongoAdminUser adds the admin user with the specified
// password to the admin database in Mongo.
func initMongoAdminUser(info mongo.Info, dialOpts mongo.DialOpts, password string) error {
session, err := mongo.DialWithInfo(info, dialOpts)
if err != nil {
return err
}
defer session.Close()
return mongo.SetAdminMongoPassword(session, mongo.AdminUser, password)
}
func open(info *mongo.MongoInfo, opts mongo.DialOpts, policy Policy) (*State, error) {
logger.Infof("opening state, mongo addresses: %q; entity %q", info.Addrs, info.Tag)
logger.Debugf("dialing mongo")
session, err := mongo.DialWithInfo(info.Info, opts)
if err != nil {
return nil, err
}
logger.Debugf("connection established")
st, err := newState(session, info, policy)
if err != nil {
session.Close()
return nil, err
}
return st, nil
}
func (s *mongoSuite) testStateWorkerDialSetsWriteMajority(c *gc.C, configureReplset bool) {
inst := gitjujutesting.MgoInstance{
Params: []string{"--replSet", "juju"},
}
err := inst.Start(coretesting.Certs)
c.Assert(err, jc.ErrorIsNil)
defer inst.Destroy()
var expectedWMode string
dialOpts := stateWorkerDialOpts
dialOpts.Timeout = coretesting.LongWait
if configureReplset {
info := inst.DialInfo()
info.Timeout = dialOpts.Timeout
args := peergrouper.InitiateMongoParams{
DialInfo: info,
MemberHostPort: inst.Addr(),
}
err = peergrouper.InitiateMongoServer(args)
c.Assert(err, jc.ErrorIsNil)
expectedWMode = "majority"
} else {
dialOpts.Direct = true
}
mongoInfo := mongo.Info{
Addrs: []string{inst.Addr()},
CACert: coretesting.CACert,
}
session, err := mongo.DialWithInfo(mongoInfo, dialOpts)
c.Assert(err, jc.ErrorIsNil)
defer session.Close()
safe := session.Safe()
c.Assert(safe, gc.NotNil)
c.Assert(safe.WMode, gc.Equals, expectedWMode)
c.Assert(safe.J, jc.IsTrue) // always enabled
}
