Merge lp:~thumper/juju-core/machine-worker into lp:~go-bot/juju-core/trunk

[Tim Penhey]

Add a worker to keep disk files up to date

Added the machine environment worker which watches
the environment config and will write changes to the
disk as needed.

A new end point was added on the client and server side
that is just called "Environment", which provides the common
environment watcher.

The only gotcha in this is that if the worker is running on
machine 0 for a local provider, it shouldn't attempt to modify
system files. There are tests for this.

The two files on disk that are currently being kept up
to date with this are:
 /home/ubuntu/.juju-proxy
 /etc/apt/apt.conf.d/42-juju-proxy-settings

https://codereview.appspot.com/57600043/

Add a worker to keep disk files up to date

Added the machine environment worker which watches
the environment config and will write changes to the
disk as needed.

A new end point was added on the client and server side
that is just called "Environment", which provies the common
environment watcher.

The only gotcha in this is that if the worker is running on
machine 0 for a local provider, it shouldn't attempt to modify
system files. There are tests for this.

The two files on disk that are currently being kept up
to date with this are:
 /home/ubuntu/.juju-proxy
 /etc/apt/apt.conf.d/42-juju-proxy-settings

https://codereview.appspot.com/57600043/

[Tim Penhey (thumper)]

Reviewers: mp+203460_code.launchpad.net,

Message:
Please take a look.

Description:
Add a worker to keep disk files up to date

Added the machine environment worker which watches
the environment config and will write changes to the
disk as needed.

A new end point was added on the client and server side
that is just called "Environment", which provies the common
environment watcher.

The only gotcha in this is that if the worker is running on
machine 0 for a local provider, it shouldn't attempt to modify
system files. There are tests for this.

The two files on disk that are currently being kept up
to date with this are:
  /home/ubuntu/.juju-proxy
  /etc/apt/apt.conf.d/42-juju-proxy-settings

https://code.launchpad.net/~thumper/juju-core/machine-worker/+merge/203460

Requires:
https://code.launchpad.net/~thumper/juju-core/fix-uniter-proxy-env-vars/+merge/203459

(do not edit description out of merge proposal)

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

Affected files (+580, -1 lines):
   A [revision details]
   M cmd/jujud/machine.go
   M environs/cloudinit/cloudinit.go
   A state/api/environment/environment.go
   A state/api/environment/environment_test.go
   A state/api/environment/package_test.go
   M state/api/state.go
   A state/apiserver/environment/environment.go
   A state/apiserver/environment/environment_test.go
   A state/apiserver/environment/package_test.go
   M state/apiserver/root.go
   M utils/apt.go
   A worker/machineenvironmentworker/machineenvironmentworker.go
   A worker/machineenvironmentworker/machineenvironmentworker_test.go
   A worker/machineenvironmentworker/package_test.go

[Ian Booth (wallyworld)]

Looks pretty good but we need a juju/machine_test to test that the jujud
has started the worker properly. There's a few examples in machine_test
to look at.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go
File worker/machineenvironmentworker/machineenvironmentworker.go
(right):

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode30
worker/machineenvironmentworker/machineenvironmentworker.go:30:
ProxyDirectory = "/home/ubuntu"
Not sure if other workers use ~ubuntu and/or /home/ubuntu, but if they
do , would be good to make this a const or method call.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode50
worker/machineenvironmentworker/machineenvironmentworker.go:50: first
         bool
Do other workers use first? Don't they just suck up the initial event
and deal with it? It seems a little complicated to use it here. If we do
need to use it, perhaps a comment saying why we need it here.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode77
worker/machineenvironmentworker/machineenvironmentworker.go:77: // an
ubuntu user, it will. This shouldn't be a problem.
I read the above a few times and am still not sure I've parsed it
correctly. I think "should" might need to be "shouldn't"??

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode85
worker/machineenvironmentworker/machineenvironmentworker.go:85: // same
way that the file is writting in the cloud-init process, so
s/writting/written ?

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode122
worker/machineenvironmentworker/machineenvironmentworker.go:122:
aptSettings := env.AptProxySettings()
not sure if we want the 2 lots of logic in this method in separate sub
methods so onChange is dead easy to ready

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode137
worker/machineenvironmentworker/machineenvironmentworker.go:137: func (w
*MachineEnvironmentWorker) SetUp() (watcher.NotifyWatcher, error) {
Typically we add a doc string saying what interface SetUp() comes from

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode149
worker/machineenvironmentworker/machineenvironmentworker.go:149: func (w
*MachineEnvironmentWorker) Handle() error {
ditto

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode153
worker/machineenvironmentworker/machineenvironmentworker.go:153: func (w
*MachineEnvironmentWorker) TearDown() error {
ditto

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker_test.go
File worker/machineenvironmentworker/machineenvironmentworker_test.go
(right):

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker_test.go#newcode41
worker/ma...

[Tim Penhey (thumper)]

Please take a look.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go
File worker/machineenvironmentworker/machineenvironmentworker.go
(right):

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode30
worker/machineenvironmentworker/machineenvironmentworker.go:30:
ProxyDirectory = "/home/ubuntu"
On 2014/01/28 04:44:50, wallyworld wrote:
> Not sure if other workers use ~ubuntu and/or /home/ubuntu, but if they
do ,
> would be good to make this a const or method call.

The whole point it is a variable is so we can mock it out during
testing.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode50
worker/machineenvironmentworker/machineenvironmentworker.go:50: first
         bool
On 2014/01/28 04:44:50, wallyworld wrote:
> Do other workers use first? Don't they just suck up the initial event
and deal
> with it? It seems a little complicated to use it here. If we do need
to use it,
> perhaps a comment saying why we need it here.

I'll add a comment. It is only used for testing in order to call the
Started function (which is by default a no-op). The Started function is
mocked out in the tests so I can demonstrate that not only do the
changes happen when it starts up, but that they happen once it is in the
main loop.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode77
worker/machineenvironmentworker/machineenvironmentworker.go:77: // an
ubuntu user, it will. This shouldn't be a problem.
On 2014/01/28 04:44:50, wallyworld wrote:
> I read the above a few times and am still not sure I've parsed it
correctly. I
> think "should" might need to be "shouldn't"??

Yes, you are right. Changed.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode85
worker/machineenvironmentworker/machineenvironmentworker.go:85: // same
way that the file is writting in the cloud-init process, so
On 2014/01/28 04:44:50, wallyworld wrote:
> s/writting/written ?

Done.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode122
worker/machineenvironmentworker/machineenvironmentworker.go:122:
aptSettings := env.AptProxySettings()
On 2014/01/28 04:44:50, wallyworld wrote:
> not sure if we want the 2 lots of logic in this method in separate sub
methods
> so onChange is dead easy to ready

Yeah I was tossing up on this one as I was writing it.

I'll split it up.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#newcode137
worker/machineenvironmentworker/machineenvironmentworker.go:137: func (w
*MachineEnvironmentWorker) SetUp() (watcher.NotifyWatcher, error) {
On 2014/01/28 04:44:50, wallyworld wrote:
> Typically we add a doc string saying what interface SetUp() comes from

cleaner, logger and machiner all didn't. I looked at your one for the
boilerplate.

https://codereview.appspot.com/57600043/diff/1/worker/machineenvironmentworker/machineenvironmentworker.go#...

[Ian Booth (wallyworld)]

LGTM, thanks for the extra code comments, especially for first. Makes it
much clearer for the casual reader.

https://codereview.appspot.com/57600043/diff/20001/cmd/jujud/machine_test.go
File cmd/jujud/machine_test.go (right):

https://codereview.appspot.com/57600043/diff/20001/cmd/jujud/machine_test.go#newcode80
cmd/jujud/machine_test.go:80: s.PatchValue(&utils.AptConfFile,
filepath.Join(s.proxyDir, "juju-apt-proxy"))
Small nitpick, feel free to ignore - these set up steps are only for one
specific test and not for the tests in general. My preference would be
just to have them in the one test that needs them.

https://codereview.appspot.com/57600043/

=== modified file 'cmd/jujud/machine.go'
--- cmd/jujud/machine.go	2014-01-28 04:58:43 +0000
+++ cmd/jujud/machine.go	2014-01-29 04:59:50 +0000
@@ -37,6 +37,7 @@
 	"launchpad.net/juju-core/worker/instancepoller"
 	"launchpad.net/juju-core/worker/localstorage"
 	workerlogger "launchpad.net/juju-core/worker/logger"
+	"launchpad.net/juju-core/worker/machineenvironmentworker"
 	"launchpad.net/juju-core/worker/machiner"
 	"launchpad.net/juju-core/worker/minunitsworker"
 	"launchpad.net/juju-core/worker/provisioner"
@@ -183,6 +184,9 @@
 	runner.StartWorker("logger", func() (worker.Worker, error) {
 		return workerlogger.NewLogger(st.Logger(), agentConfig), nil
 	})
+	runner.StartWorker("machineenvironmentworker", func() (worker.Worker, error) {
+		return machineenvironmentworker.NewMachineEnvironmentWorker(st.Environment(), agentConfig), nil
+	})
 
 	// If not a local provider bootstrap machine, start the worker to manage SSH keys.
 	providerType := agentConfig.Value(agent.ProviderType)

=== modified file 'cmd/jujud/machine_test.go'
--- cmd/jujud/machine_test.go	2014-01-24 14:52:58 +0000
+++ cmd/jujud/machine_test.go	2014-01-29 04:59:50 +0000
@@ -16,10 +16,12 @@
 	"launchpad.net/juju-core/charm"
 	"launchpad.net/juju-core/cmd"
 	lxctesting "launchpad.net/juju-core/container/lxc/testing"
+	"launchpad.net/juju-core/environs/config"
 	envtesting "launchpad.net/juju-core/environs/testing"
 	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/instance"
 	"launchpad.net/juju-core/juju"
+	"launchpad.net/juju-core/juju/osenv"
 	"launchpad.net/juju-core/names"
 	"launchpad.net/juju-core/provider/dummy"
 	"launchpad.net/juju-core/state"
@@ -30,15 +32,18 @@
 	statetesting "launchpad.net/juju-core/state/testing"
 	"launchpad.net/juju-core/state/watcher"
 	coretesting "launchpad.net/juju-core/testing"
+	"launchpad.net/juju-core/testing"
 	jc "launchpad.net/juju-core/testing/checkers"
 	"launchpad.net/juju-core/testing/testbase"
 	"launchpad.net/juju-core/tools"
+	"launchpad.net/juju-core/utils"
 	"launchpad.net/juju-core/utils/ssh"
 	sshtesting "launchpad.net/juju-core/utils/ssh/testing"
 	"launchpad.net/juju-core/version"
 	"launchpad.net/juju-core/worker/authenticationworker"
 	"launchpad.net/juju-core/worker/deployer"
 	"launchpad.net/juju-core/worker/instancepoller"
+	"launchpad.net/juju-core/worker/machineenvironmentworker"
 )
 
 type MachineSuite struct {
@@ -674,6 +679,45 @@
 	})
 }
 
+func (s *MachineSuite) TestMachineEnvirnWorker(c *gc.C) {
+	proxyDir := c.MkDir()
+	s.PatchValue(&machineenvironmentworker.ProxyDirectory, proxyDir)
+	s.PatchValue(&utils.AptConfFile, filepath.Join(proxyDir, "juju-apt-proxy"))
+
+	s.primeAgent(c, state.JobHostUnits)
+	// Make sure there are some proxy settings to write.
+	oldConfig, err := s.State.EnvironConfig()
+	c.Assert(err, gc.IsNil)
+
+	proxySettings := osenv.ProxySettings{
+		Http:  "http proxy",
+		Https: "https proxy",
+		Ftp:   "ftp proxy",
+	}
+
+	envConfig, err := oldConfig.Apply(config.ProxyConfigMap(proxySettings))
+	c.Assert(err, gc.IsNil)
+
+	err = s.State.SetEnvironConfig(envConfig, oldConfig)
+	c.Assert(err, gc.IsNil)
+
+	s.assertJobWithAPI(c, state.JobHostUnits, func(conf agent.Config, st *api.State) {
+		for {
+			select {
+			case <-time.After(testing.LongWait):
+				c.Fatalf("timeout while waiting for proxy settings to change")
+			case <-time.After(10 * time.Millisecond):
+				_, err := os.Stat(utils.AptConfFile)
+				if os.IsNotExist(err) {
+					continue
+				}
+				c.Assert(err, gc.IsNil)
+				return
+			}
+		}
+	})
+}
+
 func (s *MachineSuite) TestMachineAgentUninstall(c *gc.C) {
 	m, ac, _ := s.primeAgent(c, state.JobHostUnits)
 	err := m.EnsureDead()

=== modified file 'environs/cloudinit/cloudinit.go'
--- environs/cloudinit/cloudinit.go	2014-01-26 23:28:43 +0000
+++ environs/cloudinit/cloudinit.go	2014-01-29 04:59:50 +0000
@@ -250,7 +250,7 @@
 
 		// Write out the apt proxy settings
 		if (cfg.AptProxySettings != osenv.ProxySettings{}) {
-			filename := "/etc/apt/apt.conf.d/42-juju-proxy-settings"
+			filename := utils.AptConfFile
 			c.AddBootCmd(fmt.Sprintf(
 				`[ -f %s ] || (printf '%%s\n' %s > %s)`,
 				filename,

=== added directory 'state/api/environment'
=== added file 'state/api/environment/environment.go'
--- state/api/environment/environment.go	1970-01-01 00:00:00 +0000
+++ state/api/environment/environment.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,23 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package environment
+
+import (
+	"launchpad.net/juju-core/state/api/base"
+	"launchpad.net/juju-core/state/api/common"
+)
+
+const apiName = "Environment"
+
+// Facade provides access to a machine environment worker's view of the world.
+type Facade struct {
+	*common.EnvironWatcher
+}
+
+// NewFacade returns a new api client facade instance.
+func NewFacade(caller base.Caller) *Facade {
+	return &Facade{
+		EnvironWatcher: common.NewEnvironWatcher(apiName, caller),
+	}
+}

=== added file 'state/api/environment/environment_test.go'
--- state/api/environment/environment_test.go	1970-01-01 00:00:00 +0000
+++ state/api/environment/environment_test.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,30 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package environment_test
+
+import (
+	gc "launchpad.net/gocheck"
+
+	jujutesting "launchpad.net/juju-core/juju/testing"
+	commontesting "launchpad.net/juju-core/state/api/common/testing"
+)
+
+type environmentSuite struct {
+	jujutesting.JujuConnSuite
+	*commontesting.EnvironWatcherTest
+}
+
+var _ = gc.Suite(&environmentSuite{})
+
+func (s *environmentSuite) SetUpTest(c *gc.C) {
+	s.JujuConnSuite.SetUpTest(c)
+
+	stateAPI, _ := s.OpenAPIAsNewMachine(c)
+
+	environmentAPI := stateAPI.Environment()
+	c.Assert(environmentAPI, gc.NotNil)
+
+	s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(
+		environmentAPI, s.State, s.BackingState, commontesting.NoSecrets)
+}

=== added file 'state/api/environment/package_test.go'
--- state/api/environment/package_test.go	1970-01-01 00:00:00 +0000
+++ state/api/environment/package_test.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,14 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package environment_test
+
+import (
+	stdtesting "testing"
+
+	"launchpad.net/juju-core/testing"
+)
+
+func TestAll(t *stdtesting.T) {
+	testing.MgoTestPackage(t)
+}

=== modified file 'state/api/state.go'
--- state/api/state.go	2014-01-22 11:21:21 +0000
+++ state/api/state.go	2014-01-29 04:59:50 +0000
@@ -7,6 +7,7 @@
 	"launchpad.net/juju-core/state/api/agent"
 	"launchpad.net/juju-core/state/api/charmrevisionupdater"
 	"launchpad.net/juju-core/state/api/deployer"
+	"launchpad.net/juju-core/state/api/environment"
 	"launchpad.net/juju-core/state/api/firewaller"
 	"launchpad.net/juju-core/state/api/keyupdater"
 	"launchpad.net/juju-core/state/api/logger"
@@ -79,6 +80,11 @@
 	return deployer.NewState(st)
 }
 
+// Environment returns access to the Environment API
+func (st *State) Environment() *environment.Facade {
+	return environment.NewFacade(st)
+}
+
 // Logger returns access to the Logger API
 func (st *State) Logger() *logger.State {
 	return logger.NewState(st)

=== added directory 'state/apiserver/environment'
=== added file 'state/apiserver/environment/environment.go'
--- state/apiserver/environment/environment.go	1970-01-01 00:00:00 +0000
+++ state/apiserver/environment/environment.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,25 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package environment
+
+import (
+	"launchpad.net/juju-core/state"
+	"launchpad.net/juju-core/state/apiserver/common"
+)
+
+// EnvironmentAPI implements the API used by the machine environment worker.
+type EnvironmentAPI struct {
+	*common.EnvironWatcher
+}
+
+// NewEnvironmentAPI creates a new instance of the Environment API.
+func NewEnvironmentAPI(st *state.State, resources *common.Resources, authorizer common.Authorizer) (*EnvironmentAPI, error) {
+	// Can always watch for environ changes.
+	getCanWatch := common.AuthAlways(true)
+	// Does not get the secrets.
+	getCanReadSecrets := common.AuthAlways(false)
+	return &EnvironmentAPI{
+		EnvironWatcher: common.NewEnvironWatcher(st, resources, getCanWatch, getCanReadSecrets),
+	}, nil
+}

=== added file 'state/apiserver/environment/environment_test.go'
--- state/apiserver/environment/environment_test.go	1970-01-01 00:00:00 +0000
+++ state/apiserver/environment/environment_test.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,53 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package environment_test
+
+import (
+	gc "launchpad.net/gocheck"
+
+	"launchpad.net/juju-core/juju/testing"
+	"launchpad.net/juju-core/state"
+	"launchpad.net/juju-core/state/apiserver/common"
+	commontesting "launchpad.net/juju-core/state/apiserver/common/testing"
+	"launchpad.net/juju-core/state/apiserver/environment"
+	apiservertesting "launchpad.net/juju-core/state/apiserver/testing"
+)
+
+type environmentSuite struct {
+	testing.JujuConnSuite
+	*commontesting.EnvironWatcherTest
+
+	authorizer apiservertesting.FakeAuthorizer
+	resources  *common.Resources
+
+	machine0 *state.Machine
+	api      *environment.EnvironmentAPI
+}
+
+var _ = gc.Suite(&environmentSuite{})
+
+func (s *environmentSuite) SetUpTest(c *gc.C) {
+	s.JujuConnSuite.SetUpTest(c)
+
+	var err error
+	s.machine0, err = s.State.AddMachine("quantal", state.JobHostUnits, state.JobManageState, state.JobManageEnviron)
+	c.Assert(err, gc.IsNil)
+
+	s.authorizer = apiservertesting.FakeAuthorizer{
+		Tag:          s.machine0.Tag(),
+		LoggedIn:     true,
+		MachineAgent: true,
+		Entity:       s.machine0,
+	}
+	s.resources = common.NewResources()
+
+	s.api, err = environment.NewEnvironmentAPI(
+		s.State,
+		s.resources,
+		s.authorizer,
+	)
+	c.Assert(err, gc.IsNil)
+	s.EnvironWatcherTest = commontesting.NewEnvironWatcherTest(
+		s.api, s.State, s.resources, commontesting.NoSecrets)
+}

=== added file 'state/apiserver/environment/package_test.go'
--- state/apiserver/environment/package_test.go	1970-01-01 00:00:00 +0000
+++ state/apiserver/environment/package_test.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,14 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package environment_test
+
+import (
+	stdtesting "testing"
+
+	"launchpad.net/juju-core/testing"
+)
+
+func TestAll(t *stdtesting.T) {
+	testing.MgoTestPackage(t)
+}

=== modified file 'state/apiserver/root.go'
--- state/apiserver/root.go	2014-01-23 08:58:16 +0000
+++ state/apiserver/root.go	2014-01-29 04:59:50 +0000
@@ -16,6 +16,7 @@
 	"launchpad.net/juju-core/state/apiserver/client"
 	"launchpad.net/juju-core/state/apiserver/common"
 	"launchpad.net/juju-core/state/apiserver/deployer"
+	"launchpad.net/juju-core/state/apiserver/environment"
 	"launchpad.net/juju-core/state/apiserver/firewaller"
 	"launchpad.net/juju-core/state/apiserver/keymanager"
 	"launchpad.net/juju-core/state/apiserver/keyupdater"
@@ -169,6 +170,17 @@
 	return deployer.NewDeployerAPI(r.srv.state, r.resources, r)
 }
 
+// Environment returns an object that provides access to the Environment API
+// facade. The id argument is reserved for future use and currently needs to
+// be empty.
+func (r *srvRoot) Environment(id string) (*environment.EnvironmentAPI, error) {
+	if id != "" {
+		// Safeguard id for possible future use.
+		return nil, common.ErrBadId
+	}
+	return environment.NewEnvironmentAPI(r.srv.state, r.resources, r)
+}
+
 // Logger returns an object that provides access to the Logger API facade.
 // The id argument is reserved for future use and must be empty.
 func (r *srvRoot) Logger(id string) (*loggerapi.LoggerAPI, error) {

=== modified file 'utils/apt.go'
--- utils/apt.go	2014-01-28 04:58:43 +0000
+++ utils/apt.go	2014-01-29 04:59:50 +0000
@@ -19,6 +19,10 @@
 var (
 	aptLogger  = loggo.GetLogger("juju.utils.apt")
 	aptProxyRE = regexp.MustCompile(`(?im)^\s*Acquire::(?P<protocol>[a-z]+)::Proxy\s+"(?P<proxy>[^"]+)";\s*$`)
+
+	// AptConfFile is the full file path for the proxy settings that are
+	// written by cloud-init and the machine environ worker.
+	AptConfFile = "/etc/apt/apt.conf.d/42-juju-proxy-settings"
 )
 
 // Some helpful functions for running apt in a sane way

=== added directory 'worker/machineenvironmentworker'
=== added file 'worker/machineenvironmentworker/machineenvironmentworker.go'
--- worker/machineenvironmentworker/machineenvironmentworker.go	1970-01-01 00:00:00 +0000
+++ worker/machineenvironmentworker/machineenvironmentworker.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,173 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package machineenvironmentworker
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path"
+
+	"github.com/loggo/loggo"
+
+	"launchpad.net/juju-core/agent"
+	"launchpad.net/juju-core/juju/osenv"
+	"launchpad.net/juju-core/names"
+	"launchpad.net/juju-core/provider"
+	"launchpad.net/juju-core/state/api/environment"
+	"launchpad.net/juju-core/state/api/watcher"
+	"launchpad.net/juju-core/utils"
+	"launchpad.net/juju-core/utils/exec"
+	"launchpad.net/juju-core/worker"
+)
+
+var (
+	logger = loggo.GetLogger("juju.worker.machineenvironment")
+
+	// ProxyDirectory is the directory containing the proxy file that contains
+	// the environment settings for the proxies based on the environment
+	// config values.
+	ProxyDirectory = "/home/ubuntu"
+
+	// ProxyFile is the name of the file to be stored in the ProxyDirectory.
+	ProxyFile = ".juju-proxy"
+
+	// Started is a function that is called when the worker has started.
+	Started = func() {}
+)
+
+// MachineEnvironmentWorker is responsible for monitoring the juju environment
+// configuration and making changes on the physical (or virtual) machine as
+// necessary to match the environment changes.  Examples of these types of
+// changes are apt proxy configuration and the juju proxies stored in the juju
+// proxy file.
+type MachineEnvironmentWorker struct {
+	api      *environment.Facade
+	aptProxy osenv.ProxySettings
+	proxy    osenv.ProxySettings
+
+	writeSystemFiles bool
+	// The whole point of the first value is to make sure that the the files
+	// are written out the first time through, even if they are the same as
+	// "last" time, as the initial value for last time is the zeroed struct.
+	// There is the possibility that the files exist on disk with old
+	// settings, and the environment has been updated to now not have them. We
+	// need to make sure that the disk reflects the environment, so the first
+	// time through, even if the proxies are empty, we write the files to
+	// disk.
+	first bool
+}
+
+var _ worker.NotifyWatchHandler = (*MachineEnvironmentWorker)(nil)
+
+// NewMachineEnvironmentWorker returns a worker.Worker that uses the notify
+// watcher returned from the setup.
+func NewMachineEnvironmentWorker(api *environment.Facade, agentConfig agent.Config) worker.Worker {
+	// We don't write out system files for the local provider on machine zero
+	// as that is the host machine.
+	writeSystemFiles := !(agentConfig.Tag() == names.MachineTag("0") &&
+		agentConfig.Value(agent.JujuProviderType) == provider.Local)
+	envWorker := &MachineEnvironmentWorker{
+		api:              api,
+		writeSystemFiles: writeSystemFiles,
+		first:            true,
+	}
+	return worker.NewNotifyWorker(envWorker)
+}
+
+func (w *MachineEnvironmentWorker) writeEnvironmentFile() error {
+	// Writing the environment file is handled by executing the script for two
+	// primary reasons:
+	//
+	// 1: In order to have the local provider specify the environment settings
+	// for the machine agent running on the host, this worker needs to run,
+	// but it shouldn't be touching any files on the disk.  If however there is
+	// an ubuntu user, it will. This shouldn't be a problem.
+	//
+	// 2: On cloud-instance ubuntu images, the ubuntu user is uid 1000, but in
+	// the situation where the ubuntu user has been created as a part of the
+	// manual provisioning process, the user will exist, and will not have the
+	// same uid/gid as the default cloud image.
+	//
+	// It is easier to shell out to check both these things, and is also the
+	// same way that the file is written in the cloud-init process, so
+	// consistency FTW.
+	filePath := path.Join(ProxyDirectory, ProxyFile)
+	result, err := exec.RunCommands(exec.RunParams{
+		Commands: fmt.Sprintf(
+			`[ -e %s ] && (printf '%%s\n' %s > %s && chown ubuntu:ubuntu %s)`,
+			ProxyDirectory,
+			utils.ShQuote(w.proxy.AsScriptEnvironment()),
+			filePath, filePath),
+		WorkingDir: ProxyDirectory,
+	})
+	if err != nil {
+		return err
+	}
+	if result.Code != 0 {
+		logger.Errorf("failed writing new proxy values: \n%s\n%s", result.Stdout, result.Stderr)
+	}
+	return nil
+}
+
+func (w *MachineEnvironmentWorker) handleProxyValues(proxySettings osenv.ProxySettings) {
+	if proxySettings != w.proxy || w.first {
+		logger.Debugf("new proxy settings %#v", proxySettings)
+		w.proxy = proxySettings
+		w.proxy.SetEnvironmentValues()
+		if w.writeSystemFiles {
+			if err := w.writeEnvironmentFile(); err != nil {
+				// It isn't really fatal, but we should record it.
+				logger.Errorf("error writing proxy environment file: %v", err)
+			}
+		}
+	}
+}
+
+func (w *MachineEnvironmentWorker) handleAptProxyValues(aptSettings osenv.ProxySettings) {
+	if w.writeSystemFiles && (aptSettings != w.aptProxy || w.first) {
+		logger.Debugf("new apt proxy settings %#v", aptSettings)
+		w.aptProxy = aptSettings
+		// Always finish with a new line.
+		content := utils.AptProxyContent(w.aptProxy) + "\n"
+		err := ioutil.WriteFile(utils.AptConfFile, []byte(content), 0644)
+		if err != nil {
+			// It isn't really fatal, but we should record it.
+			logger.Errorf("error writing apt proxy config file: %v", err)
+		}
+	}
+}
+
+func (w *MachineEnvironmentWorker) onChange() error {
+	env, err := w.api.EnvironConfig()
+	if err != nil {
+		return err
+	}
+	w.handleProxyValues(env.ProxySettings())
+	w.handleAptProxyValues(env.AptProxySettings())
+	return nil
+}
+
+// SetUp is defined on the worker.NotifyWatchHandler interface.
+func (w *MachineEnvironmentWorker) SetUp() (watcher.NotifyWatcher, error) {
+	// We need to set this up initially as the NotifyWorker sucks up the first
+	// event.
+	err := w.onChange()
+	if err != nil {
+		return nil, err
+	}
+	w.first = false
+	Started()
+	return w.api.WatchForEnvironConfigChanges()
+}
+
+// Handle is defined on the worker.NotifyWatchHandler interface.
+func (w *MachineEnvironmentWorker) Handle() error {
+	return w.onChange()
+}
+
+// TearDown is defined on the worker.NotifyWatchHandler interface.
+func (w *MachineEnvironmentWorker) TearDown() error {
+	// Nothing to cleanup, only state is the watcher
+	return nil
+}

=== added file 'worker/machineenvironmentworker/machineenvironmentworker_test.go'
--- worker/machineenvironmentworker/machineenvironmentworker_test.go	1970-01-01 00:00:00 +0000
+++ worker/machineenvironmentworker/machineenvironmentworker_test.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,222 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package machineenvironmentworker_test
+
+import (
+	"io/ioutil"
+	"os"
+	"path"
+	"time"
+
+	gc "launchpad.net/gocheck"
+
+	"launchpad.net/juju-core/agent"
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/juju/osenv"
+	jujutesting "launchpad.net/juju-core/juju/testing"
+	"launchpad.net/juju-core/names"
+	"launchpad.net/juju-core/provider"
+	"launchpad.net/juju-core/state"
+	"launchpad.net/juju-core/state/api"
+	"launchpad.net/juju-core/state/api/environment"
+	"launchpad.net/juju-core/testing"
+	jc "launchpad.net/juju-core/testing/checkers"
+	"launchpad.net/juju-core/utils"
+	"launchpad.net/juju-core/worker"
+	"launchpad.net/juju-core/worker/machineenvironmentworker"
+)
+
+type MachineEnvironmentWatcherSuite struct {
+	jujutesting.JujuConnSuite
+
+	apiRoot        *api.State
+	environmentAPI *environment.Facade
+	machine        *state.Machine
+
+	proxyFile string
+	started   bool
+}
+
+var _ = gc.Suite(&MachineEnvironmentWatcherSuite{})
+
+func (s *MachineEnvironmentWatcherSuite) setStarted() {
+	s.started = true
+}
+
+func (s *MachineEnvironmentWatcherSuite) SetUpTest(c *gc.C) {
+	s.JujuConnSuite.SetUpTest(c)
+	s.apiRoot, s.machine = s.OpenAPIAsNewMachine(c)
+	// Create the machiner API facade.
+	s.environmentAPI = s.apiRoot.Environment()
+	c.Assert(s.environmentAPI, gc.NotNil)
+
+	proxyDir := c.MkDir()
+	s.PatchValue(&machineenvironmentworker.ProxyDirectory, proxyDir)
+	s.started = false
+	s.PatchValue(&machineenvironmentworker.Started, s.setStarted)
+	s.PatchValue(&utils.AptConfFile, path.Join(proxyDir, "juju-apt-proxy"))
+	s.proxyFile = path.Join(proxyDir, machineenvironmentworker.ProxyFile)
+}
+
+func (s *MachineEnvironmentWatcherSuite) waitForPostSetup(c *gc.C) {
+	for {
+		select {
+		case <-time.After(testing.LongWait):
+			c.Fatalf("timeout while waiting for setup")
+		case <-time.After(10 * time.Millisecond):
+			if s.started {
+				return
+			}
+		}
+	}
+}
+
+func (s *MachineEnvironmentWatcherSuite) waitProxySettings(c *gc.C, expected osenv.ProxySettings) {
+	for {
+		select {
+		case <-time.After(testing.LongWait):
+			c.Fatalf("timeout while waiting for proxy settings to change")
+		case <-time.After(10 * time.Millisecond):
+			obtained := osenv.DetectProxies()
+			if obtained != expected {
+				c.Logf("proxy settings are %#v, still waiting", obtained)
+				continue
+			}
+			return
+		}
+	}
+}
+
+func (s *MachineEnvironmentWatcherSuite) waitForFile(c *gc.C, filename, expected string) {
+	for {
+		select {
+		case <-time.After(testing.LongWait):
+			c.Fatalf("timeout while waiting for proxy settings to change")
+		case <-time.After(10 * time.Millisecond):
+			fileContent, err := ioutil.ReadFile(filename)
+			if os.IsNotExist(err) {
+				continue
+			}
+			c.Assert(err, gc.IsNil)
+			if string(fileContent) != expected {
+				c.Logf("file content not matching, still waiting")
+				continue
+			}
+			return
+		}
+	}
+}
+
+func (s *MachineEnvironmentWatcherSuite) makeWorker(c *gc.C, agentConfig agent.Config) worker.Worker {
+	return machineenvironmentworker.NewMachineEnvironmentWorker(s.environmentAPI, agentConfig)
+}
+
+func (s *MachineEnvironmentWatcherSuite) TestRunStop(c *gc.C) {
+	agentConfig := agentConfig("0", "ec2")
+	envWorker := s.makeWorker(c, agentConfig)
+	c.Assert(worker.Stop(envWorker), gc.IsNil)
+}
+
+func (s *MachineEnvironmentWatcherSuite) updateConfig(c *gc.C) (osenv.ProxySettings, osenv.ProxySettings) {
+	oldConfig, err := s.State.EnvironConfig()
+	c.Assert(err, gc.IsNil)
+
+	proxySettings := osenv.ProxySettings{
+		Http:  "http proxy",
+		Https: "https proxy",
+		Ftp:   "ftp proxy",
+	}
+
+	envConfig, err := oldConfig.Apply(config.ProxyConfigMap(proxySettings))
+	c.Assert(err, gc.IsNil)
+
+	// We explicitly set apt proxy settings as well to show that it is the apt
+	// settings that are used for the apt config, and not just the normal
+	// proxy settings which is what we would get if we don't explicitly set
+	// apt values.
+	aptProxySettings := osenv.ProxySettings{
+		Http:  "apt http proxy",
+		Https: "apt https proxy",
+		Ftp:   "apt ftp proxy",
+	}
+	envConfig, err = envConfig.Apply(config.AptProxyConfigMap(aptProxySettings))
+	c.Assert(err, gc.IsNil)
+
+	err = s.State.SetEnvironConfig(envConfig, oldConfig)
+	c.Assert(err, gc.IsNil)
+
+	return proxySettings, aptProxySettings
+}
+
+func (s *MachineEnvironmentWatcherSuite) TestInitialState(c *gc.C) {
+	proxySettings, aptProxySettings := s.updateConfig(c)
+
+	agentConfig := agentConfig("0", "ec2")
+	envWorker := s.makeWorker(c, agentConfig)
+	defer worker.Stop(envWorker)
+
+	s.waitProxySettings(c, proxySettings)
+	s.waitForFile(c, s.proxyFile, proxySettings.AsScriptEnvironment()+"\n")
+	s.waitForFile(c, utils.AptConfFile, utils.AptProxyContent(aptProxySettings)+"\n")
+}
+
+func (s *MachineEnvironmentWatcherSuite) TestRespondsToEvents(c *gc.C) {
+	agentConfig := agentConfig("0", "ec2")
+	envWorker := s.makeWorker(c, agentConfig)
+	defer worker.Stop(envWorker)
+	s.waitForPostSetup(c)
+
+	proxySettings, aptProxySettings := s.updateConfig(c)
+
+	s.waitProxySettings(c, proxySettings)
+	s.waitForFile(c, s.proxyFile, proxySettings.AsScriptEnvironment()+"\n")
+	s.waitForFile(c, utils.AptConfFile, utils.AptProxyContent(aptProxySettings)+"\n")
+}
+
+func (s *MachineEnvironmentWatcherSuite) TestInitialStateLocalMachine1(c *gc.C) {
+	proxySettings, aptProxySettings := s.updateConfig(c)
+
+	agentConfig := agentConfig("1", provider.Local)
+	envWorker := s.makeWorker(c, agentConfig)
+	defer worker.Stop(envWorker)
+
+	s.waitProxySettings(c, proxySettings)
+	s.waitForFile(c, s.proxyFile, proxySettings.AsScriptEnvironment()+"\n")
+	s.waitForFile(c, utils.AptConfFile, utils.AptProxyContent(aptProxySettings)+"\n")
+}
+
+func (s *MachineEnvironmentWatcherSuite) TestInitialStateLocalMachine0(c *gc.C) {
+	proxySettings, _ := s.updateConfig(c)
+
+	agentConfig := agentConfig("0", provider.Local)
+	envWorker := s.makeWorker(c, agentConfig)
+	defer worker.Stop(envWorker)
+	s.waitForPostSetup(c)
+
+	s.waitProxySettings(c, proxySettings)
+
+	c.Assert(utils.AptConfFile, jc.DoesNotExist)
+	c.Assert(s.proxyFile, jc.DoesNotExist)
+}
+
+type mockConfig struct {
+	agent.Config
+	tag      string
+	provider string
+}
+
+func (mock *mockConfig) Tag() string {
+	return mock.tag
+}
+
+func (mock *mockConfig) Value(key string) string {
+	if key == agent.JujuProviderType {
+		return mock.provider
+	}
+	return ""
+}
+
+func agentConfig(machineId, provider string) *mockConfig {
+	return &mockConfig{tag: names.MachineTag(machineId), provider: provider}
+}

=== added file 'worker/machineenvironmentworker/package_test.go'
--- worker/machineenvironmentworker/package_test.go	1970-01-01 00:00:00 +0000
+++ worker/machineenvironmentworker/package_test.go	2014-01-29 04:59:50 +0000
@@ -0,0 +1,14 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package machineenvironmentworker_test
+
+import (
+	stdtesting "testing"
+
+	"launchpad.net/juju-core/testing"
+)
+
+func TestAll(t *stdtesting.T) {
+	testing.MgoTestPackage(t)
+}