…mmon.

cmd/jujud/agent/machine.go

@@ -49,7 +49,6 @@ import (
 	"github.com/juju/juju/provider"
 	"github.com/juju/juju/replicaset"
 	"github.com/juju/juju/service"
-	"github.com/juju/juju/service/common"
 	"github.com/juju/juju/state"
 	"github.com/juju/juju/state/multiwatcher"
 	statestorage "github.com/juju/juju/state/storage"
@@ -691,7 +690,10 @@ func (a *MachineAgent) postUpgradeAPIWorker(
 		case multiwatcher.JobHostUnits:
 			runner.StartWorker("deployer", func() (worker.Worker, error) {
 				apiDeployer := st.Deployer()
-				context := newDeployContext(apiDeployer, agentConfig)
+				context, err := newDeployContext(apiDeployer, agentConfig)
+				if err != nil {
+					return nil, errors.Trace(err)
+				}
 				return deployer.NewDeployer(apiDeployer, context), nil
 			})
 		case multiwatcher.JobManageEnviron:
@@ -1279,33 +1281,45 @@ func (a *MachineAgent) createJujuRun(dataDir string) error {
 }
 
 func (a *MachineAgent) uninstallAgent(agentConfig agent.Config) error {
-	var errors []error
+	var errs []error
+
+	services, err := service.DiscoverServices(agentConfig.DataDir())
+	if err != nil {
+		return errors.Trace(err)
+	}
+
+	// Remove the machine agent's jujud service.
 	agentServiceName := agentConfig.Value(agent.AgentServiceName)
 	if agentServiceName == "" {
 		// For backwards compatibility, handle lack of AgentServiceName.
 		agentServiceName = os.Getenv("UPSTART_JOB")
 	}
 	if agentServiceName != "" {
-		if err := service.NewService(agentServiceName, common.Conf{}).Remove(); err != nil {
-			errors = append(errors, fmt.Errorf("cannot remove service %q: %v", agentServiceName, err))
+		if err := services.Remove(agentServiceName); err != nil {
+			errs = append(errs, fmt.Errorf("cannot remove service %q: %v", agentServiceName, err))
 		}
 	}
+
 	// Remove the juju-run symlink.
 	if err := os.Remove(JujuRun); err != nil && !os.IsNotExist(err) {
-		errors = append(errors, err)
+		errs = append(errs, err)
 	}
 
+	// Remove the mongo service.
 	namespace := agentConfig.Value(agent.Namespace)
-	if err := mongo.RemoveService(namespace); err != nil {
-		errors = append(errors, fmt.Errorf("cannot stop/remove mongo service with namespace %q: %v", namespace, err))
+	mongoService := mongo.ServiceName(namespace)
+	if err := services.Remove(mongoService); err != nil {
+		errs = append(errs, fmt.Errorf("cannot stop/remove mongo service with namespace %q: %v", namespace, err))
 	}
+
 	if err := os.RemoveAll(agentConfig.DataDir()); err != nil {
-		errors = append(errors, err)
+		errs = append(errs, err)
 	}
-	if len(errors) == 0 {
+
+	if len(errs) == 0 {
 		return nil
 	}
-	return fmt.Errorf("uninstall failed: %v", errors)
+	return fmt.Errorf("uninstall failed: %v", errs)
 }
 
 // singularAPIConn implements singular.Conn on
@@ -1347,6 +1361,6 @@ func metricAPI(st *api.State) metricsmanager.MetricsManagerClient {
 // running the tests and (2) get access to the *State used internally, so that
 // tests can be run without waiting for the 5s watcher refresh time to which we would
 // otherwise be restricted.
-var newDeployContext = func(st *apideployer.State, agentConfig agent.Config) deployer.Context {
+var newDeployContext = func(st *apideployer.State, agentConfig agent.Config) (deployer.Context, error) {
 	return deployer.NewSimpleContext(agentConfig, st)
 }

cmd/jujud/agent/machine_test.go

@@ -82,7 +82,7 @@ func TestPackage(t *testing.T) {
 	// Change the default init dir in worker/deployer,
 	// so the deployer doesn't try to remove upstart
 	// jobs from tests.
-	restore := gitjujutesting.PatchValue(&deployer.InitDir, mkdtemp("juju-worker-deployer"))
+	restore := gitjujutesting.PatchValue(&upstart.ConfDir, mkdtemp("juju-worker-deployer"))
 	defer restore()
 
 	// TODO(waigani) 2014-03-19 bug 1294458
@@ -129,7 +129,7 @@ func (s *commonMachineSuite) SetUpTest(c *gc.C) {
 	fakeCmd(filepath.Join(testpath, "start"))
 	fakeCmd(filepath.Join(testpath, "stop"))
 
-	s.AgentSuite.PatchValue(&upstart.InitDir, c.MkDir())
+	s.AgentSuite.PatchValue(&upstart.ConfDir, c.MkDir())
 
 	s.singularRecord = &singularRunnerRecord{startedWorkers: make(set.Strings)}
 	s.AgentSuite.PatchValue(&newSingularRunner, s.singularRecord.newSingularRunner)
@@ -408,11 +408,11 @@ func patchDeployContext(c *gc.C, st *state.State) (*fakeContext, func()) {
 		deployed: make(set.Strings),
 	}
 	orig := newDeployContext
-	newDeployContext = func(dst *apideployer.State, agentConfig agent.Config) deployer.Context {
+	newDeployContext = func(dst *apideployer.State, agentConfig agent.Config) (deployer.Context, error) {
 		ctx.st = st
 		ctx.agentConfig = agentConfig
 		close(ctx.inited)
-		return ctx
+		return ctx, nil
 	}
 	return ctx, func() { newDeployContext = orig }
 }

cmd/jujud/main_test.go

@@ -22,8 +22,8 @@ import (
 
 	agentcmd "github.com/juju/juju/cmd/jujud/agent"
 	"github.com/juju/juju/environs"
+	"github.com/juju/juju/service/upstart"
 	coretesting "github.com/juju/juju/testing"
-	"github.com/juju/juju/worker/deployer"
 	"github.com/juju/juju/worker/uniter/runner/jujuc"
 )
 
@@ -54,7 +54,7 @@ func TestPackage(t *stdtesting.T) {
 	// Change the default init dir in worker/deployer,
 	// so the deployer doesn't try to remove upstart
 	// jobs from tests.
-	restore := testing.PatchValue(&deployer.InitDir, mkdtemp("juju-worker-deployer"))
+	restore := testing.PatchValue(&upstart.ConfDir, mkdtemp("juju-worker-deployer"))
 	defer restore()
 
 	// TODO(waigani) 2014-03-19 bug 1294458

cmd/jujud/util/util.go

@@ -173,12 +173,14 @@ func NewEnsureServerParams(agentConfig agent.Config) (mongo.EnsureServerParams,
 	}
 
 	params := mongo.EnsureServerParams{
-		APIPort:        si.APIPort,
-		StatePort:      si.StatePort,
-		Cert:           si.Cert,
-		PrivateKey:     si.PrivateKey,
-		CAPrivateKey:   si.CAPrivateKey,
-		SharedSecret:   si.SharedSecret,
+		APIPort:   si.APIPort,
+		StatePort: si.StatePort,
+		SSLInfo: mongo.SSLInfo{
+			Cert:         si.Cert,
+			PrivateKey:   si.PrivateKey,
+			CAPrivateKey: si.CAPrivateKey,
+			SharedSecret: si.SharedSecret,
+		},
 		SystemIdentity: si.SystemIdentity,
 
 		DataDir:              agentConfig.DataDir(),

mongo/admin.go

@@ -11,10 +11,10 @@ import (
 	"strconv"
 	"syscall"
 
+	"github.com/juju/errors"
 	"gopkg.in/mgo.v2"
 
-	"github.com/juju/juju/service/common"
-	"github.com/juju/juju/service/upstart"
+	"github.com/juju/juju/service"
 )
 
 // AdminUser is the name of the user that is initially created in mongo.
@@ -39,6 +39,15 @@ type EnsureAdminUserParams struct {
 	Password string
 }
 
+type services interface {
+	Start(name string) error
+	Stop(name string) error
+}
+
+var newServices = func(dataDir string) (services, error) {
+	return service.DiscoverServices(dataDir)
+}
+
 // EnsureAdminUser ensures that the specified user and password
 // are added to the admin database.
 //
@@ -78,10 +87,13 @@ func EnsureAdminUser(p EnsureAdminUserParams) (added bool, err error) {
 
 	// Login failed, so we need to add the user.
 	// Stop mongo, so we can start it in --noauth mode.
-	mongoServiceName := ServiceName(p.Namespace)
-	mongoService := upstart.NewService(mongoServiceName, common.Conf{})
-	if err := upstartServiceStop(mongoService); err != nil {
-		return false, fmt.Errorf("failed to stop %v: %v", mongoServiceName, err)
+	services, err := newServices(p.DataDir)
+	if err != nil {
+		return false, errors.Trace(err)
+	}
+	svcName := ServiceName(p.Namespace)
+	if err := services.Stop(svcName); err != nil {
+		return false, errors.Annotatef(err, "failed to stop %v", svcName)
 	}
 
 	// Start mongod in --noauth mode.
@@ -107,7 +119,7 @@ func EnsureAdminUser(p EnsureAdminUserParams) (added bool, err error) {
 	}
 	logger.Infof("added %q to admin database", p.User)
 
-	// Restart mongo using upstart.
+	// Restart mongo using the init system.
 	if err := processSignal(cmd.Process, syscall.SIGTERM); err != nil {
 		return false, fmt.Errorf("cannot kill mongod: %v", err)
 	}
@@ -116,8 +128,8 @@ func EnsureAdminUser(p EnsureAdminUserParams) (added bool, err error) {
 			return false, fmt.Errorf("mongod did not cleanly terminate: %v", err)
 		}
 	}
-	if err := upstartServiceStart(mongoService); err != nil {
-		return false, err
+	if err := services.Start(svcName); err != nil {
+		return false, errors.Annotatef(err, "failed to restart %v", svcName)
 	}
 	return true, nil
 }

mongo/admin_test.go

@@ -16,33 +16,37 @@ import (
 	"gopkg.in/mgo.v2/bson"
 
 	"github.com/juju/juju/mongo"
-	"github.com/juju/juju/service/upstart"
 	coretesting "github.com/juju/juju/testing"
 )
 
+type fakeServices struct {
+	starts int
+	stops  int
+}
+
+func (fs *fakeServices) Start(name string) error {
+	fs.starts++
+	return nil
+}
+
+func (fs *fakeServices) Stop(name string) error {
+	fs.stops++
+	return nil
+}
+
 type adminSuite struct {
 	coretesting.BaseSuite
-	serviceStarts int
-	serviceStops  int
+
+	services *fakeServices
 }
 
 var _ = gc.Suite(&adminSuite{})
 
 func (s *adminSuite) SetUpTest(c *gc.C) {
 	s.BaseSuite.SetUpTest(c)
-	s.serviceStarts = 0
-	s.serviceStops = 0
-	s.PatchValue(mongo.UpstartConfInstall, func(conf *upstart.Service) error {
-		return nil
-	})
-	s.PatchValue(mongo.UpstartServiceStart, func(svc *upstart.Service) error {
-		s.serviceStarts++
-		return nil
-	})
-	s.PatchValue(mongo.UpstartServiceStop, func(svc *upstart.Service) error {
-		s.serviceStops++
-		return nil
-	})
+
+	s.services = &fakeServices{}
+	s.PatchValue(mongo.NewServices, mongo.NewServicesClosure(s.services))
 }
 
 func (s *adminSuite) TestEnsureAdminUser(c *gc.C) {
@@ -69,8 +73,8 @@ func (s *adminSuite) TestEnsureAdminUser(c *gc.C) {
 	// EnsureAdminUser should have stopped the mongo service,
 	// started a new mongod with --noauth, and then finally
 	// started the service back up.
-	c.Assert(s.serviceStarts, gc.Equals, 1)
-	c.Assert(s.serviceStops, gc.Equals, 1)
+	c.Assert(s.services.starts, gc.Equals, 1)
+	c.Assert(s.services.stops, gc.Equals, 1)
 	_, portString, err := net.SplitHostPort(dialInfo.Addrs[0])
 	c.Assert(err, jc.ErrorIsNil)
 	gitjujutesting.AssertEchoArgs(c, "mongod",
@@ -93,8 +97,8 @@ func (s *adminSuite) TestEnsureAdminUser(c *gc.C) {
 	c.Assert(added, jc.IsFalse)
 
 	// There should have been no additional start/stop.
-	c.Assert(s.serviceStarts, gc.Equals, 1)
-	c.Assert(s.serviceStops, gc.Equals, 1)
+	c.Assert(s.services.starts, gc.Equals, 1)
+	c.Assert(s.services.stops, gc.Equals, 1)
 }
 
 func (s *adminSuite) TestEnsureAdminUserError(c *gc.C) {

mongo/apt.go

@@ -0,0 +1,73 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package mongo
+
+import (
+	"bytes"
+	"os/exec"
+
+	"github.com/juju/errors"
+	"github.com/juju/utils/apt"
+
+	"github.com/juju/juju/version"
+)
+
+func aptGetInstallMongod(numaCtl bool) error {
+	// Only Quantal requires the PPA.
+	if version.Current.Series == "quantal" {
+		if err := addAptRepository("ppa:juju/stable"); err != nil {
+			return err
+		}
+	}
+	mongoPkg := packageForSeries(version.Current.Series)
+
+	aptPkgs := []string{mongoPkg}
+	if numaCtl {
+		aptPkgs = []string{mongoPkg, numaCtlPkg}
+		logger.Infof("installing %s and %s", mongoPkg, numaCtlPkg)
+	} else {
+		logger.Infof("installing %s", mongoPkg)
+	}
+	cmds := apt.GetPreparePackages(aptPkgs, version.Current.Series)
+	for _, cmd := range cmds {
+		if err := apt.GetInstall(cmd...); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func addAptRepository(name string) error {
+	// add-apt-repository requires python-software-properties
+	cmds := apt.GetPreparePackages(
+		[]string{"python-software-properties"},
+		version.Current.Series,
+	)
+	logger.Infof("installing python-software-properties")
+	for _, cmd := range cmds {
+		if err := apt.GetInstall(cmd...); err != nil {
+			return err
+		}
+	}
+
+	logger.Infof("adding apt repository %q", name)
+	cmd := exec.Command("add-apt-repository", "-y", name)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return errors.Annotatef(err, "cannot add apt repository (output %s)", bytes.TrimSpace(out))
+	}
+	return nil
+}
+
+// packageForSeries returns the name of the mongo package for the series
+// of the machine that it is going to be running on.
+func packageForSeries(series string) string {
+	switch series {
+	case "precise", "quantal", "raring", "saucy":
+		return "mongodb-server"
+	default:
+		// trusty and onwards
+		return "juju-mongodb"
+	}
+}

mongo/export_test.go

@@ -12,13 +12,9 @@ var (
 	SharedSecretPath = sharedSecretPath
 	SSLKeyPath       = sslKeyPath
 
-	UpstartConfInstall          = &upstartConfInstall
-	UpstartService              = upstartService
-	UpstartServiceExists        = &upstartServiceExists
-	UpstartServiceRunning       = &upstartServiceRunning
-	UpstartServiceStopAndRemove = &upstartServiceStopAndRemove
-	UpstartServiceStop          = &upstartServiceStop
-	UpstartServiceStart         = &upstartServiceStart
+	NewServices    = &newServices
+	NewService     = &newService
+	InstallService = &installService
 
 	HostWordSize   = &hostWordSize
 	RuntimeGOOS    = &runtimeGOOS
@@ -32,3 +28,9 @@ var (
 	PreallocFileSizes = preallocFileSizes
 	PreallocFiles     = preallocFiles
 )
+
+func NewServicesClosure(s services) func(string) (services, error) {
+	return func(string) (services, error) {
+		return s, nil
+	}
+}