jujud: add primordial provisioning agent

cmd/jujud/provisioning.go

 package main
 
 import (
         "launchpad.net/gnuflag"
         "launchpad.net/juju/go/cmd"
         "launchpad.net/juju/go/log"
         "launchpad.net/juju/go/state"
-        "os"
+
+        // register providers
+        _ "launchpad.net/juju/go/environs/dummy"
+        _ "launchpad.net/juju/go/environs/ec2"
 )
 
 // ProvisioningAgent is a cmd.Command responsible for running a provisioning agent.
 type ProvisioningAgent struct {
         Conf AgentConf
 }
 
 // Info returns usage information for the command.
 func (a *ProvisioningAgent) Info() *cmd.Info {
         return &cmd.Info{"provisioning", "", "run a juju provisioning agent", ""}
 }
 
 // Init initializes the command for running.
 func (a *ProvisioningAgent) Init(f *gnuflag.FlagSet, args []string) error {
         a.Conf.addFlags(f)
         if err := f.Parse(true, args); err != nil {
                 return err
         }
         return a.Conf.checkArgs(f.Args())
 }
 
-func (a *ProvisioningAgent) MustOpenState() *state.State {
+// Run runs a provisioning agent.
+func (a *ProvisioningAgent) Run(_ *cmd.Context) error {
         state, err := state.Open(&a.Conf.StateInfo)
         if err != nil {
-                log.Printf("failed to connect to zookeeper: %v", err)
-                os.Exit(1)

[fwereade, 2012/05/18 09:08:25]

I'd prefer not to jump across layers like this... can't we just return the error
from Run? We'll exit 1 anyway soon enough...

+                return err
         }
-        return state
-}
 
-// Run runs a provisioning agent.
-func (a *ProvisioningAgent) Run(_ *cmd.Context) error {
-        state := a.MustOpenState()
+        env, err := NewProxyEnviron(state)
+        if err != nil {
+                return err
+        }
+        machines := NewMachines(env)
+        watcher := state.WatchMachines()
 
-        envwatcher := state.WatchEnvrionConfig()

[fwereade, 2012/05/18 09:08:25]

s/WatchEnvrionConfig/WatchEnvironConfig/

...and presumably in some other places too ;).

-        ps := NewProviderService(envwatcher, &a.Conf.StateInfo)
-
-        machines := state.WatchMachines()
         for {
-                changes, ok := <-machines.Changes()
-                if !ok {
-                        break
-                }
-                for _, added := range changes.Added {
-                        ps.AddMachine(added)
-                }
-                for _, deleted := range changes.Deleted {
-                        ps.RemoveMachine(deleted)
+                select {
+                case changes, ok := <-watcher.Changes():
+                        if !ok {
+                                log.Printf("Machines watcher has shutdown")
+                                break
+                        }
+                        for _, added := range changes.Added {
+                                log.Printf("provisioning: machine %d added", added.Id())
+                                machines.StartMachine(added.Id())
+                        }
+                        for _, deleted := range changes.Deleted {
+                                log.Printf("provisioning: machine %d deleted", deleted.Id())
+                                machines.StopMachine(deleted.Id())
+                        }
                 }
         }
-        return nil
+        return watcher.Stop()
 }