environs: remove VarDir global

worker/machiner/machiner.go

 package machiner
 
 import (
         "launchpad.net/juju-core/container"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/watcher"
         "launchpad.net/tomb"
 )
 
-// NewMachiner starts a machine agent running.
+// NewMachiner starts a machine agent running that
+// deploys agents in the given directory.
 // The Machiner dies when it encounters an error.
-func NewMachiner(machine *state.Machine) *Machiner {
-        m := &Machiner{}
+func NewMachiner(machine *state.Machine, varDir string) *Machiner {
+        cont := &container.Simple{VarDir: varDir}
+        return newMachiner(machine, cont)
+}
+
+func newMachiner(machine *state.Machine, cont container.Container) *Machiner {
+        m := &Machiner{container: cont}
         go m.loop(machine)
         return m
 }
 
 // Machiner represents a running machine agent.
 type Machiner struct {
-        tomb tomb.Tomb
+        tomb      tomb.Tomb
+        container container.Container

[fwereade, 2012/09/10 06:58:30]

Wait, what? A machiner can only deploy to one container? Isn't this crack? I
suggest sticking with container.Simple for now rather than baking in what feels
like a really flaky assumption...

[rog, 2012/09/10 19:53:10]

When LXC is added, we'll probably have "localContainer" and "lxcContainer" here.
how about i rename container to localContainer in anticipation of that?

[niemeyer, 2012/09/11 18:35:21]

This is true, but the decision is made considering settings, which means that
the API won't look like this (won't receive it through constructor), so I agree
with William that this seems premature. It's also a bit unrelated to the CL
topic.

[rog, 2012/09/12 16:46:17]

reverted after discussion on line.

 }
 
 func (m *Machiner) loop(machine *state.Machine) {
         defer m.tomb.Done()
         w := machine.WatchUnits()
         defer watcher.Stop(w, &m.tomb)
 
         // TODO read initial units, check if they're running
         // and restart them if not. Also track units so
         // that we don't deploy units that are already running.
         for {
                 select {
                 case <-m.tomb.Dying():
                         return
                 case change, ok := <-w.Changes():
                         if !ok {
                                 m.tomb.Kill(watcher.MustErr(w))
                                 return
                         }
                         for _, u := range change.Removed {
                                 if u.IsPrincipal() {
-                                        if err := container.Simple.Destroy(u); err != nil {
+                                        if err := m.container.Destroy(u); err != nil {
                                                 log.Printf("cannot destroy unit %s: %v", u.Name(), err)
                                         }
                                 }
                         }
                         for _, u := range change.Added {
                                 if u.IsPrincipal() {
-                                        if err := container.Simple.Deploy(u); err != nil {
+                                        if err := m.container.Deploy(u); err != nil {
                                                 // TODO put unit into a queue to retry the deploy.
                                                 log.Printf("cannot deploy unit %s: %v", u.Name(), err)
                                         }
                                 }
                         }
                 }
         }
 }
 
 // Wait waits until the Machiner has died, and returns the error encountered.
 func (m *Machiner) Wait() error {
         return m.tomb.Wait()
 }
 
 // Stop terminates the Machiner and returns any error that it encountered.
 func (m *Machiner) Stop() error {
         m.tomb.Kill(nil)
         return m.tomb.Wait()
 }