Merge lp:~thumper/juju-core/local-provider-bootstrap into lp:~go-bot/juju-core/trunk

[Tim Penhey]

Add the initial bootstrap implementation.

This isn't all that is needed to bootstrap, but it is the start.
In particular, this adds the mongo upstart service. This branch
also adds a very simple instance implementation for the local
instances.

https://codereview.appspot.com/11325043/

Add the initial bootstrap implementation.

This isn't all that is needed to bootstrap, but it is the start.
In particular, this adds the mongo upstart service. This branch
also adds a very simple instance implementation for the local
instances.

I honestly spent about a day trying to get the bootstrap local
juju test working, but there were just too many moving parts.
Bootstrapping the local environment means installing an upstart
service and waiting for it to start, then connecting to the
just started service.

https://codereview.appspot.com/11325043/

[Tim Penhey (thumper)]

Reviewers: mp+174913_code.launchpad.net,

Message:
Please take a look.

Description:
Add the initial bootstrap implementation.

This isn't all that is needed to bootstrap, but it is the start.
In particular, this adds the mongo upstart service. This branch
also adds a very simple instance implementation for the local
instances.

I honestly spent about a day trying to get the bootstrap local
juju test working, but there were just too many moving parts.
Bootstrapping the local environment means installing an upstart
service and waiting for it to start, then connecting to the
just started service.

https://code.launchpad.net/~thumper/juju-core/local-provider-bootstrap/+merge/174913

Requires:
https://code.launchpad.net/~thumper/juju-core/local-default-root-dir/+merge/174908

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/11325043/

Affected files:
   A [revision details]
   M environs/local/environ.go
   M environs/local/environ_test.go
   M environs/local/environprovider.go
   M environs/local/export_test.go
   A environs/local/instance.go

[Jeroen T. Vermeulen (jtv)]

For your tests, you may now want to call
PatchAttemptStrategies(&shortAttempt) to make sure that you don't waste
too much time sleeping in tests. The function is
launchpad.net/juju-core/environs/testing.

https://codereview.appspot.com/11325043/

[Martin Packman (gz)]

LGTM

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go
File environs/local/environ.go (right):

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode30
environs/local/environ.go:30: var lxcBridgeName = "lxcbr0"
const, as it's not being overriden in tests anywhere?

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode108
environs/local/environ.go:108: // up yet, so we retry to verify if that
is happening.
Is this comment at all truthful in the context of the local provider?
What eventual consistency do we have to deal with for the local file
store implementation?

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode233
environs/local/environ.go:233: func (env *localEnviron) Instances(ids
[]instance.Id) ([]instance.Instance, error) {
This probably wants a TODO about checking that the id is a machine that
actually exists?

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode277
environs/local/environ.go:277: if err :=
os.RemoveAll(env.config.rootDir()); err != nil {
Is this enough to cleanup current lxc containers?

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go
File environs/local/instance.go (right):

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go#newcode40
environs/local/instance.go:40: return "", instance.ErrNoDNSName
Can't this just be `return environs.WaitDNSName(inst)` now?

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go#newcode45
environs/local/instance.go:45: return fmt.Errorf("not implemented")
I'd be tempted to just log here, OpenPort never did anything on the
local provider.

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go#newcode50
environs/local/instance.go:50: return fmt.Errorf("not implemented")
Likewise, just log for ClosePort.

https://codereview.appspot.com/11325043/

[William Reade (fwereade)]

LGTM, but I'm a bit worried about the firewalling. What actually happens
when we run the firewaller? I guess probably nothing *until* someone
tries to expose a service... but I think we'll need a better experience
there before too long.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go
File environs/local/environ.go (right):

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode35
environs/local/environ.go:35: var upstartScriptLocation = "/etc/init"
I'm a little suspicious that this is showing up again... I suspect it's
in a few places already. I think it's usually called InitDir, IIRC;
please do a quick search and see if there's any obvious deduplication to
be done.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode233
environs/local/environ.go:233: func (env *localEnviron) Instances(ids
[]instance.Id) ([]instance.Instance, error) {
On 2013/07/16 09:13:03, gz wrote:
> This probably wants a TODO about checking that the id is a machine
that actually
> exists?

Yeah, I'm definitely raising eyebrows here. Can this bit be cleanly
separated into a new CL? What's it actually used for here?

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode277
environs/local/environ.go:277: if err :=
os.RemoveAll(env.config.rootDir()); err != nil {
On 2013/07/16 09:13:03, gz wrote:
> Is this enough to cleanup current lxc containers?

Don't think so. But I presume that this CL contains the absolute minimum
of instancey bits necessary to get bootstrap working? If so I'm ok with
this and the above.

https://codereview.appspot.com/11325043/diff/1/environs/local/environprovider.go
File environs/local/environprovider.go (right):

https://codereview.appspot.com/11325043/diff/1/environs/local/environprovider.go#newcode122
environs/local/environprovider.go:122: // return "", fmt.Errorf("not
implemented")
d

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go
File environs/local/instance.go (right):

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go#newcode40
environs/local/instance.go:40: return "", instance.ErrNoDNSName
On 2013/07/16 09:13:03, gz wrote:
> Can't this just be `return environs.WaitDNSName(inst)` now?

+1

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go#newcode45
environs/local/instance.go:45: return fmt.Errorf("not implemented")
On 2013/07/16 09:13:03, gz wrote:
> I'd be tempted to just log here, OpenPort never did anything on the
local
> provider.

+1

https://codereview.appspot.com/11325043/diff/1/environs/local/instance.go#newcode50
environs/local/instance.go:50: return fmt.Errorf("not implemented")
On 2013/07/16 09:13:03, gz wrote:
> Likewise, just log for ClosePort.

+1

https://codereview.appspot.com/11325043/

[Tim Penhey (thumper)]

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go
File environs/local/environ.go (right):

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode30
environs/local/environ.go:30: var lxcBridgeName = "lxcbr0"
On 2013/07/16 09:13:03, gz wrote:
> const, as it's not being overriden in tests anywhere?

Sure. I had planned at some stage to allow this to be part of the
configuration.
If or when we do this, we can remove this I guess. Changed to const.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode35
environs/local/environ.go:35: var upstartScriptLocation = "/etc/init"
On 2013/07/16 11:01:25, fwereade wrote:
> I'm a little suspicious that this is showing up again... I suspect
it's in a few
> places already. I think it's usually called InitDir, IIRC; please do a
quick
> search and see if there's any obvious deduplication to be done.

This is more so it can be overridden in the tests, otherwise the code
would try
to write to /etc/init in the tests, which is bad (and problematic).

There doesn't seem to be any particular deduplication that can be done
right now.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode108
environs/local/environ.go:108: // up yet, so we retry to verify if that
is happening.
On 2013/07/16 09:13:03, gz wrote:
> Is this comment at all truthful in the context of the local provider?
What
> eventual consistency do we have to deal with for the local file store
> implementation?

It is at least theoretically possible if the user is either scripting
things or very quick on the fingers. I'll update the comment slightly.

Actually, I'm just going to error out. They can always try again.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode233
environs/local/environ.go:233: func (env *localEnviron) Instances(ids
[]instance.Id) ([]instance.Instance, error) {
On 2013/07/16 11:01:25, fwereade wrote:
> On 2013/07/16 09:13:03, gz wrote:
> > This probably wants a TODO about checking that the id is a machine
that
> actually
> > exists?

> Yeah, I'm definitely raising eyebrows here. Can this bit be cleanly
separated
> into a new CL? What's it actually used for here?

I actually considered checking to see if the ids exist, but then
thought, why?
This is only ever called with instance ids that we already know exist,
so why check again?
If we are wrong (which we aren't), it will fail later.

It is used in the bootstrap process somewhere. I just implemented what
was called.

This reminds me that I need to implement a stacktrace logging helper.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode277
environs/local/environ.go:277: if err :=
os.RemoveAll(env.config.rootDir()); err != nil {
On 2013/07/16 09:13:03, gz wrote:
> Is this enough to cleanup current lxc containers?

No, but we aren't creating any either.

https://codereview.appspot.com/11325043/diff/1/environs/local/environ.go#newcode277
environs/local/environ.go:277: if err :=
os.RemoveAll(env.config.rootDir()); err != nil {
On 2013/07/16 11:01:25, fwereade wrote:
> On 2013/07/16 09:13:03, gz wrote:
> > Is this enough to...

[Go Bot (go-bot)]

The attempt to merge lp:~thumper/juju-core/local-provider-bootstrap into lp:juju-core failed. Below is the output from the failed tests.

# launchpad.net/juju-core/environs/local
environs/local/environ.go:75: undefined: getSudoCallerIds
environs/local/instance.go:40: undefined: environs
environs/local/instance.go:40: not enough arguments to return

=== modified file 'environs/local/environ.go'
--- environs/local/environ.go	2013-07-12 01:53:18 +0000
+++ environs/local/environ.go	2013-07-17 00:28:26 +0000
@@ -5,10 +5,14 @@
 
 import (
 	"fmt"
+	"io/ioutil"
 	"net"
 	"os"
+	"path/filepath"
 	"sync"
+	"time"
 
+	"launchpad.net/juju-core/agent"
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
@@ -16,8 +20,30 @@
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api"
+	"launchpad.net/juju-core/upstart"
+	"launchpad.net/juju-core/utils"
 )
 
+// lxcBridgeName is the name of the network interface that the local provider
+// uses to determine the ip address to use for machine-0 such that the
+// containers being created are able to communicate with it simply.
+const lxcBridgeName = "lxcbr0"
+
+// upstartScriptLocation is parameterised purely for testing purposes as we
+// don't really want to be installing and starting scripts as root for
+// testing.
+var upstartScriptLocation = "/etc/init"
+
+// A request may fail to due "eventual consistency" semantics, which
+// should resolve fairly quickly.  A request may also fail due to a slow
+// state transition (for instance an instance taking a while to release
+// a security group after termination).  The former failure mode is
+// dealt with by shortAttempt, the latter by longAttempt.
+var shortAttempt = utils.AttemptStrategy{
+	Total: 1 * time.Second,
+	Delay: 50 * time.Millisecond,
+}
+
 // localEnviron implements Environ.
 var _ environs.Environ = (*localEnviron)(nil)
 
@@ -34,14 +60,99 @@
 	return env.name
 }
 
+func (env *localEnviron) mongoServiceName() string {
+	return "juju-db-" + env.config.namespace()
+}
+
+// ensureCertOwner checks to make sure that the cert files created
+// by the bootstrap command are owned by the user and not root.
+func (env *localEnviron) ensureCertOwner() error {
+	files := []string{
+		config.JujuHomePath(env.name + "-cert.pem"),
+		config.JujuHomePath(env.name + "-private-key.pem"),
+	}
+
+	uid, gid, err := sudoCallerIds()
+	if err != nil {
+		return err
+	}
+	if uid != 0 || gid != 0 {
+		for _, filename := range files {
+			if err := os.Chown(filename, uid, gid); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 // Bootstrap is specified in the Environ interface.
 func (env *localEnviron) Bootstrap(cons constraints.Value) error {
-	return fmt.Errorf("not implemented")
+	logger.Infof("bootstrapping environment %q", env.name)
+	if !env.config.runningAsRoot {
+		return fmt.Errorf("bootstrapping a local environment must be done as root")
+	}
+	if err := env.config.createDirs(); err != nil {
+		logger.Errorf("failed to create necessary directories: %v", err)
+		return err
+	}
+
+	if err := env.ensureCertOwner(); err != nil {
+		logger.Errorf("failed to reassign ownership of the certs to the user: %v", err)
+		return err
+	}
+	// TODO(thumper): check that the constraints don't include "container=lxc" for now.
+
+	var noRetry = utils.AttemptStrategy{}
+	if err := environs.VerifyBootstrapInit(env, noRetry); err != nil {
+		return err
+	}
+
+	cert, key, err := env.setupLocalMongoService()
+	if err != nil {
+		return err
+	}
+
+	// Work out the ip address of the lxc bridge, and use that for the mongo config.
+	bridgeAddress, err := env.findBridgeAddress()
+	if err != nil {
+		return err
+	}
+	logger.Debugf("found %q as address for %q", bridgeAddress, lxcBridgeName)
+
+	// Before we write the agent config file, we need to make sure the
+	// instance is saved in the StateInfo.
+	bootstrapId := instance.Id("localhost")
+	if err := environs.SaveState(env.Storage(), &environs.BootstrapState{[]instance.Id{bootstrapId}}); err != nil {
+		logger.Errorf("failed to save state instances: %v", err)
+		return err
+	}
+
+	// Need to write out the agent file for machine-0 before initializing
+	// state, as as part of that process, it will reset the password in the
+	// agent file.
+	if err := env.writeBootstrapAgentConfFile(cert, key); err != nil {
+		return err
+	}
+
+	// Have to initialize the state configuration with localhost so we get
+	// "special" permissions.
+	stateConnection, err := env.initialStateConfiguration("localhost", cons)
+	if err != nil {
+		return err
+	}
+	defer stateConnection.Close()
+
+	// TODO(thumper): upload tools into the storage
+
+	// TODO(thumper): start the machine agent for machine-0
+
+	return nil
 }
 
 // StateInfo is specified in the Environ interface.
 func (env *localEnviron) StateInfo() (*state.Info, *api.Info, error) {
-	return nil, nil, fmt.Errorf("not implemented")
+	return environs.StateInfo(env)
 }
 
 // Config is specified in the Environ interface.
@@ -118,12 +229,24 @@
 
 // Instances is specified in the Environ interface.
 func (env *localEnviron) Instances(ids []instance.Id) ([]instance.Instance, error) {
-	return nil, fmt.Errorf("not implemented")
+	// NOTE: do we actually care about checking the existance of the instances?
+	// I posit that here we don't really care, and that we are only called with
+	// instance ids that we know exist.
+	if len(ids) == 0 {
+		return nil, nil
+	}
+	insts := make([]instance.Instance, len(ids))
+	for i, id := range ids {
+		insts[i] = &localInstance{id, env}
+	}
+	return insts, nil
 }
 
 // AllInstances is specified in the Environ interface.
-func (env *localEnviron) AllInstances() ([]instance.Instance, error) {
-	return nil, fmt.Errorf("not implemented")
+func (env *localEnviron) AllInstances() (instances []instance.Instance, err error) {
+	// TODO(thumper): get all the instances from the container manager
+	instances = append(instances, &localInstance{"localhost", env})
+	return instances, nil
 }
 
 // Storage is specified in the Environ interface.
@@ -138,7 +261,26 @@
 
 // Destroy is specified in the Environ interface.
 func (env *localEnviron) Destroy(insts []instance.Instance) error {
-	return fmt.Errorf("not implemented")
+	if !env.config.runningAsRoot {
+		return fmt.Errorf("destroying a local environment must be done as root")
+	}
+
+	logger.Infof("removing service %s", env.mongoServiceName())
+	mongo := upstart.NewService(env.mongoServiceName())
+	mongo.InitDir = upstartScriptLocation
+	if err := mongo.Remove(); err != nil {
+		logger.Errorf("could not remove mongo service: %v", err)
+		return err
+	}
+
+	// Remove the rootdir.
+	logger.Infof("removing state dir %s", env.config.rootDir())
+	if err := os.RemoveAll(env.config.rootDir()); err != nil {
+		logger.Errorf("could not remove local state dir: %v", err)
+		return err
+	}
+
+	return nil
 }
 
 // OpenPorts is specified in the Environ interface.
@@ -160,3 +302,118 @@
 func (env *localEnviron) Provider() environs.EnvironProvider {
 	return &provider
 }
+
+// setupLocalMongoService returns the cert and key if there was no error.
+func (env *localEnviron) setupLocalMongoService() ([]byte, []byte, error) {
+	journalDir := filepath.Join(env.config.mongoDir(), "journal")
+	logger.Debugf("create mongo journal dir: %v", journalDir)
+	if err := os.MkdirAll(journalDir, 0755); err != nil {
+		logger.Errorf("failed to make mongo journal dir %s: %v", journalDir, err)
+		return nil, nil, err
+	}
+
+	logger.Debugf("generate server cert")
+	cert, key, err := env.config.GenerateStateServerCertAndKey()
+	if err != nil {
+		logger.Errorf("failed to generate server cert: %v", err)
+		return nil, nil, err
+	}
+	if err := ioutil.WriteFile(
+		env.config.configFile("server.pem"),
+		append(cert, key...),
+		0600); err != nil {
+		logger.Errorf("failed to write server.pem: %v", err)
+		return nil, nil, err
+	}
+
+	mongo := upstart.MongoUpstartService(
+		env.mongoServiceName(),
+		env.config.rootDir(),
+		env.config.mongoDir(),
+		env.config.StatePort())
+	mongo.InitDir = upstartScriptLocation
+	logger.Infof("installing service %s to %s", env.mongoServiceName(), mongo.InitDir)
+	if err := mongo.Install(); err != nil {
+		logger.Errorf("could not install mongo service: %v", err)
+		return nil, nil, err
+	}
+	return cert, key, nil
+}
+
+func (env *localEnviron) findBridgeAddress() (string, error) {
+	bridge, err := net.InterfaceByName(lxcBridgeName)
+	if err != nil {
+		logger.Errorf("cannot find network interface %q: %v", lxcBridgeName, err)
+		return "", err
+	}
+	addrs, err := bridge.Addrs()
+	if err != nil {
+		logger.Errorf("cannot get addresses for network interface %q: %v", lxcBridgeName, err)
+		return "", err
+	}
+	return utils.GetIPv4Address(addrs)
+}
+
+func (env *localEnviron) writeBootstrapAgentConfFile(cert, key []byte) error {
+	info, apiInfo, err := env.StateInfo()
+	if err != nil {
+		logger.Errorf("failed to get state info to write bootstrap agent file: %v", err)
+		return err
+	}
+	tag := state.MachineTag("0")
+	info.Tag = tag
+	apiInfo.Tag = tag
+	conf := &agent.Conf{
+		DataDir:         env.config.rootDir(),
+		StateInfo:       info,
+		APIInfo:         apiInfo,
+		StateServerCert: cert,
+		StateServerKey:  key,
+		StatePort:       env.config.StatePort(),
+		APIPort:         env.config.StatePort(),
+		MachineNonce:    state.BootstrapNonce,
+	}
+	if err := conf.Write(); err != nil {
+		logger.Errorf("failed to write bootstrap agent file: %v", err)
+		return err
+	}
+	return nil
+}
+
+func (env *localEnviron) initialStateConfiguration(addr string, cons constraints.Value) (*state.State, error) {
+	// We don't check the existance of the CACert here as if it wasn't set, we
+	// wouldn't get this far.
+	cfg := env.config.Config
+	caCert, _ := cfg.CACert()
+	addr = fmt.Sprintf("%s:%d", addr, cfg.StatePort())
+	info := &state.Info{
+		Addrs:  []string{addr},
+		CACert: caCert,
+	}
+	timeout := state.DialOpts{10 * time.Second}
+	bootstrap, err := environs.BootstrapConfig(cfg)
+	if err != nil {
+		return nil, err
+	}
+	st, err := state.Initialize(info, bootstrap, timeout)
+	if err != nil {
+		logger.Errorf("failed to initialize state: %v", err)
+		return nil, err
+	}
+	logger.Debugf("state initialized")
+
+	passwordHash := utils.PasswordHash(cfg.AdminSecret())
+	if err := environs.BootstrapUsers(st, cfg, passwordHash); err != nil {
+		st.Close()
+		return nil, err
+	}
+	jobs := []state.MachineJob{state.JobManageEnviron, state.JobManageState}
+
+	if err := environs.ConfigureBootstrapMachine(st, cfg, cons, env.config.rootDir(), jobs); err != nil {
+		st.Close()
+		return nil, err
+	}
+
+	// Return an open state reference.
+	return st, nil
+}

=== modified file 'environs/local/environ_test.go'
--- environs/local/environ_test.go	2013-07-16 22:01:19 +0000
+++ environs/local/environ_test.go	2013-07-17 00:28:26 +0000
@@ -4,6 +4,10 @@
 package local_test
 
 import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
 	gc "launchpad.net/gocheck"
 
 	"launchpad.net/juju-core/environs/jujutest"
@@ -40,19 +44,53 @@
 type localJujuTestSuite struct {
 	baseProviderSuite
 	jujutest.Tests
+	restoreRootCheck   func()
+	oldUpstartLocation string
+	oldPath            string
+	testPath           string
+	dbServiceName      string
 }
 
 func (s *localJujuTestSuite) SetUpTest(c *gc.C) {
 	s.baseProviderSuite.SetUpTest(c)
+	// Construct the directories first.
+	err := local.CreateDirs(c, minimalConfig(c))
+	c.Assert(err, gc.IsNil)
+	s.oldUpstartLocation = local.SetUpstartScriptLocation(c.MkDir())
+	s.oldPath = os.Getenv("PATH")
+	s.testPath = c.MkDir()
+	os.Setenv("PATH", s.testPath+":"+s.oldPath)
+
+	// Add in an admin secret
+	s.Tests.TestConfig.Config["admin-secret"] = "sekrit"
+	s.restoreRootCheck = local.SetRootCheckFunction(func() bool { return true })
 	s.Tests.SetUpTest(c)
+	s.dbServiceName = "juju-db-" + local.ConfigNamespace(s.Env.Config())
 }
 
 func (s *localJujuTestSuite) TearDownTest(c *gc.C) {
-	// TODO(thumper): add the TearDownTest for s.Tests when destroy is implemented
-	// s.Tests.TearDownTest(c)
+	s.Tests.TearDownTest(c)
+	os.Setenv("PATH", s.oldPath)
+	s.restoreRootCheck()
+	local.SetUpstartScriptLocation(s.oldUpstartLocation)
 	s.baseProviderSuite.TearDownTest(c)
 }
 
+func (s *localJujuTestSuite) MakeTool(c *gc.C, name, script string) {
+	path := filepath.Join(s.testPath, name)
+	script = "#!/bin/bash\n" + script
+	err := ioutil.WriteFile(path, []byte(script), 0755)
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *localJujuTestSuite) StoppedStatus(c *gc.C) {
+	s.MakeTool(c, "status", `echo "some-service stop/waiting"`)
+}
+
+func (s *localJujuTestSuite) RunningStatus(c *gc.C) {
+	s.MakeTool(c, "status", `echo "some-service start/running, process 123"`)
+}
+
 var _ = gc.Suite(&localJujuTestSuite{
 	Tests: jujutest.Tests{
 		TestConfig: jujutest.TestConfig{minimalConfigValues()},
@@ -60,7 +98,7 @@
 })
 
 func (s *localJujuTestSuite) TestBootstrap(c *gc.C) {
-	c.Skip("Bootstrap not implemented yet.")
+	c.Skip("Cannot test bootstrap at this stage.")
 }
 
 func (s *localJujuTestSuite) TestStartStop(c *gc.C) {

=== modified file 'environs/local/environprovider.go'
--- environs/local/environprovider.go	2013-07-16 03:23:32 +0000
+++ environs/local/environprovider.go	2013-07-17 00:28:26 +0000
@@ -12,6 +12,7 @@
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/utils"
+	"launchpad.net/juju-core/version"
 )
 
 var logger = loggo.GetLogger("juju.environs.local")
@@ -27,10 +28,18 @@
 }
 
 // Open implements environs.EnvironProvider.Open.
-func (environProvider) Open(cfg *config.Config) (environs.Environ, error) {
+func (environProvider) Open(cfg *config.Config) (env environs.Environ, err error) {
 	logger.Infof("opening environment %q", cfg.Name())
+	if _, ok := cfg.AgentVersion(); !ok {
+		cfg, err = cfg.Apply(map[string]interface{}{
+			"agent-version": version.CurrentNumber().String(),
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
 	environ := &localEnviron{name: cfg.Name()}
-	err := environ.SetConfig(cfg)
+	err = environ.SetConfig(cfg)
 	if err != nil {
 		logger.Errorf("failure setting config: %v", err)
 		return nil, err
@@ -108,7 +117,8 @@
 
 // InstanceId implements environs.EnvironProvider.InstanceId.
 func (environProvider) InstanceId() (instance.Id, error) {
-	return "", fmt.Errorf("not implemented")
+	// This hack only works until we get containers started.
+	return instance.Id("localhost"), nil
 }
 
 func (environProvider) newConfig(cfg *config.Config) (*environConfig, error) {

=== modified file 'environs/local/export_test.go'
--- environs/local/export_test.go	2013-07-16 21:56:22 +0000
+++ environs/local/export_test.go	2013-07-17 00:28:26 +0000
@@ -18,6 +18,13 @@
 	return func() { checkIfRoot = old }
 }
 
+// SetUpstartScriptLocation allows tests to override the directory where the
+// provider writes the upstart scripts.
+func SetUpstartScriptLocation(location string) (old string) {
+	old, upstartScriptLocation = upstartScriptLocation, location
+	return
+}
+
 // ConfigNamespace returns the result of the namespace call on the
 // localConfig.
 func ConfigNamespace(cfg *config.Config) string {

=== added file 'environs/local/instance.go'
--- environs/local/instance.go	1970-01-01 00:00:00 +0000
+++ environs/local/instance.go	2013-07-17 00:28:26 +0000
@@ -0,0 +1,64 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package local
+
+import (
+	"fmt"
+
+	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/instance"
+)
+
+type localInstance struct {
+	id  instance.Id
+	env *localEnviron
+}
+
+var _ instance.Instance = (*localInstance)(nil)
+
+// Id implements instance.Instance.Id.
+func (inst *localInstance) Id() instance.Id {
+	return inst.id
+}
+
+// DNSName implements instance.Instance.DNSName.
+func (inst *localInstance) DNSName() (string, error) {
+	if string(inst.id) == "localhost" {
+		// get the bridge address from the environment
+		addr, err := inst.env.findBridgeAddress()
+		if err != nil {
+			logger.Errorf("failed to get bridge address: %v", err)
+			return "", instance.ErrNoDNSName
+		}
+		return addr, nil
+	}
+	return "", instance.ErrNoDNSName
+}
+
+// WaitDNSName implements instance.Instance.WaitDNSName.
+func (inst *localInstance) WaitDNSName() (string, error) {
+	return environs.WaitDNSName(inst)
+}
+
+// OpenPorts implements instance.Instance.OpenPorts.
+func (inst *localInstance) OpenPorts(machineId string, ports []instance.Port) error {
+	logger.Infof("OpenPorts called for %s:%v", machineId, ports)
+	return nil
+}
+
+// ClosePorts implements instance.Instance.ClosePorts.
+func (inst *localInstance) ClosePorts(machineId string, ports []instance.Port) error {
+	logger.Infof("ClosePorts called for %s:%v", machineId, ports)
+	return nil
+}
+
+// Ports implements instance.Instance.Ports.
+func (inst *localInstance) Ports(machineId string) ([]instance.Port, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+// Add a string representation of the id.
+func (inst *localInstance) String() string {
+	return fmt.Sprintf("inst:%v", inst.id)
+}