func (s *serviceSuite) TestInstallAndStartOkay(c *gc.C) {
s.PatchAttempts(5)
err := service.InstallAndStart(s.Service)
c.Assert(err, jc.ErrorIsNil)
s.Service.CheckCallNames(c, "Install", "Start")
}
func (s *serviceSuite) TestInstallAndStartFail(c *gc.C) {
s.PatchAttempts(3)
s.Service.SetErrors(nil, s.Failure, s.Failure, s.Failure)
err := service.InstallAndStart(s.Service)
s.CheckFailure(c, err)
s.Service.CheckCallNames(c, "Install", "Start", "Start", "Start")
}
func (s *serviceSuite) TestInstallAndStartRetry(c *gc.C) {
s.PatchAttempts(5)
s.Service.SetErrors(nil, s.Failure, s.Failure)
err := service.InstallAndStart(s.Service)
c.Assert(err, jc.ErrorIsNil)
s.Service.CheckCallNames(c, "Install", "Start", "Start", "Start")
}
// EnsureServer ensures that the MongoDB server is installed,
// configured, and ready to run.
//
// This method will remove old versions of the mongo init service as necessary
// before installing the new version.
func EnsureServer(args EnsureServerParams) error {
logger.Infof(
"Ensuring mongo server is running; data directory %s; port %d",
args.DataDir, args.StatePort,
)
dbDir := filepath.Join(args.DataDir, "db")
if err := os.MkdirAll(dbDir, 0700); err != nil {
return fmt.Errorf("cannot create mongo database directory: %v", err)
}
oplogSizeMB := args.OplogSize
if oplogSizeMB == 0 {
var err error
if oplogSizeMB, err = defaultOplogSize(dbDir); err != nil {
return err
}
}
operatingsystem := series.HostSeries()
if err := installMongod(operatingsystem, args.SetNumaControlPolicy); err != nil {
// This isn't treated as fatal because the Juju MongoDB
// package is likely to be already installed anyway. There
// could just be a temporary issue with apt-get/yum/whatever
// and we don't want this to stop jujud from starting.
// (LP #1441904)
logger.Errorf("cannot install/upgrade mongod (will proceed anyway): %v", err)
}
mongoPath, err := Path()
if err != nil {
return err
}
logVersion(mongoPath)
if err := UpdateSSLKey(args.DataDir, args.Cert, args.PrivateKey); err != nil {
return err
}
err = utils.AtomicWriteFile(sharedSecretPath(args.DataDir), []byte(args.SharedSecret), 0600)
if err != nil {
return fmt.Errorf("cannot write mongod shared secret: %v", err)
}
// Disable the default mongodb installed by the mongodb-server package.
// Only do this if the file doesn't exist already, so users can run
// their own mongodb server if they wish to.
if _, err := os.Stat(mongoConfigPath); os.IsNotExist(err) {
err = utils.AtomicWriteFile(
mongoConfigPath,
[]byte("ENABLE_MONGODB=no"),
0644,
)
if err != nil {
return err
}
}
svcConf := newConf(args.DataDir, dbDir, mongoPath, args.StatePort, oplogSizeMB, args.SetNumaControlPolicy)
svc, err := newService(ServiceName, svcConf)
if err != nil {
return err
}
installed, err := svc.Installed()
if err != nil {
return errors.Trace(err)
}
if installed {
exists, err := svc.Exists()
if err != nil {
return errors.Trace(err)
}
if exists {
logger.Debugf("mongo exists as expected")
running, err := svc.Running()
if err != nil {
return errors.Trace(err)
}
if !running {
return svc.Start()
}
return nil
}
}
if err := svc.Stop(); err != nil {
return errors.Annotatef(err, "failed to stop mongo")
}
if err := makeJournalDirs(dbDir); err != nil {
return fmt.Errorf("error creating journal directories: %v", err)
}
if err := preallocOplog(dbDir, oplogSizeMB); err != nil {
return fmt.Errorf("error creating oplog files: %v", err)
}
if err := service.InstallAndStart(svc); err != nil {
return errors.Trace(err)
}
return nil
}
func (ctx *SimpleContext) DeployUnit(unitName, initialPassword string) (err error) {
// Check sanity.
renderer, err := shell.NewRenderer("")
if err != nil {
return errors.Trace(err)
}
svc, err := ctx.service(unitName, renderer)
if err != nil {
return errors.Trace(err)
}
installed, err := svc.Installed()
if err != nil {
return errors.Trace(err)
}
if installed {
return fmt.Errorf("unit %q is already deployed", unitName)
}
// Link the current tools for use by the new agent.
tag := names.NewUnitTag(unitName)
dataDir := ctx.agentConfig.DataDir()
logDir := ctx.agentConfig.LogDir()
current := version.Binary{
Number: version.Current,
Arch: arch.HostArch(),
Series: series.HostSeries(),
}
toolsDir := tools.ToolsDir(dataDir, tag.String())
defer removeOnErr(&err, toolsDir)
_, err = tools.ChangeAgentTools(dataDir, tag.String(), current)
if err != nil {
return errors.Trace(err)
}
result, err := ctx.api.ConnectionInfo()
if err != nil {
return errors.Trace(err)
}
logger.Debugf("state addresses: %q", result.StateAddresses)
logger.Debugf("API addresses: %q", result.APIAddresses)
containerType := ctx.agentConfig.Value(agent.ContainerType)
namespace := ctx.agentConfig.Value(agent.Namespace)
conf, err := agent.NewAgentConfig(
agent.AgentConfigParams{
Paths: agent.Paths{
DataDir: dataDir,
LogDir: logDir,
MetricsSpoolDir: agent.DefaultPaths.MetricsSpoolDir,
},
UpgradedToVersion: version.Current,
Tag: tag,
Password: initialPassword,
Nonce: "unused",
Model: ctx.agentConfig.Model(),
// TODO: remove the state addresses here and test when api only.
StateAddresses: result.StateAddresses,
APIAddresses: result.APIAddresses,
CACert: ctx.agentConfig.CACert(),
Values: map[string]string{
agent.ContainerType: containerType,
agent.Namespace: namespace,
},
})
if err != nil {
return errors.Trace(err)
}
if err := conf.Write(); err != nil {
return err
}
defer removeOnErr(&err, conf.Dir())
// Install an init service that runs the unit agent.
if err := service.InstallAndStart(svc); err != nil {
return errors.Trace(err)
}
return nil
}