environs: use new tool-finding funcs

environs/maas/environ.go

 package maas
 
 import (
         "encoding/base64"
         "errors"
         "fmt"
         "launchpad.net/gomaasapi"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/cloudinit"
         "launchpad.net/juju-core/environs/config"
+        "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/trivial"
-        "launchpad.net/juju-core/version"
         "net/url"
         "sync"
         "time"
 )
 
 const (
         mgoPort     = 37017
         apiPort     = 17070
         jujuDataDir = "/var/lib/juju"
         // We're using v1.0 of the MAAS API.
@@ skipping 33 matching lines @@
                 return nil, err
         }
         env.storageUnlocked = NewStorage(env)
         return env, nil
 }
 
 func (env *maasEnviron) Name() string {
         return env.name
 }
 
-// TODO: this code is cargo-culted from the openstack/ec2 providers.
-func (env *maasEnviron) findTools() (*state.Tools, error) {
-        flags := environs.HighestVersion | environs.CompatVersion
-        v := version.Current
-        v.Series = env.Config().DefaultSeries()
-        return environs.FindTools(env, v, flags)
-}
-
 // makeMachineConfig sets up a basic machine configuration for use with
 // userData().  You may still need to supply more information, but this takes
 // care of the fixed entries and the ones that are always needed.
-func (env *maasEnviron) makeMachineConfig(machineID, machineNonce string, stateInfo *state.Info, apiInfo *api.Info, tools *state.Tools) *cloudinit.MachineConfig {
+func (env *maasEnviron) makeMachineConfig(machineID, machineNonce string, stateInfo *state.Info, apiInfo *api.Info) *cloudinit.MachineConfig {
         return &cloudinit.MachineConfig{
                 // Fixed entries.
                 MongoPort: mgoPort,
                 APIPort:   apiPort,
                 DataDir:   jujuDataDir,
 
-                // Entries based purely on what's in the environment.
-                AuthorizedKeys: env.ecfg().AuthorizedKeys(),
-
                 // Parameter entries.
                 MachineId:    machineID,
                 MachineNonce: machineNonce,
                 StateInfo:    stateInfo,
                 APIInfo:      apiInfo,
-                Tools:        tools,
         }
 }
 
 // startBootstrapNode starts the juju bootstrap node for this environment.
-func (env *maasEnviron) startBootstrapNode(tools *state.Tools, cert, key []byte, password string) (environs.Instance, error) {
-        config, err := environs.BootstrapConfig(env.Provider(), env.Config(), tools)
-        if err != nil {
-                return nil, fmt.Errorf("unable to determine initial configuration: %v", err)
-        }
-        caCert, hasCert := env.Config().CACert()
-        if !hasCert {
-                return nil, fmt.Errorf("no CA certificate in environment configuration")
-        }
-        stateInfo := state.Info{
-                Password: trivial.PasswordHash(password),
-                CACert:   caCert,
-        }
-        apiInfo := api.Info{
-                Password: trivial.PasswordHash(password),
-                CACert:   caCert,
-        }
-
+func (env *maasEnviron) startBootstrapNode(cons constraints.Value) (environs.Instance, error) {
         // The bootstrap instance gets machine id "0".  This is not related to
         // instance ids or MAAS system ids.  Juju assigns the machine ID.
         const machineID = "0"
+        mcfg := env.makeMachineConfig(machineID, state.BootstrapNonce, nil, nil)
+        mcfg.StateServer = true
 
-        mcfg := env.makeMachineConfig(machineID, state.BootstrapNonce, &stateInfo, &apiInfo, tools)
-        mcfg.StateServer = true
-        mcfg.StateServerCert = cert
-        mcfg.StateServerKey = key
-        mcfg.Config = config
-
-        inst, err := env.obtainNode(machineID, &stateInfo, &apiInfo, tools, mcfg)
+        log.Debugf("environs/maas: bootstrapping environment %q", env.Name())
+        possibleTools, err := environs.FindBootstrapTools(env, cons)
+        if err != nil {
+                return nil, err
+        }
+        inst, err := env.obtainNode(machineID, cons, possibleTools, mcfg)
         if err != nil {
                 return nil, fmt.Errorf("cannot start bootstrap instance: %v", err)
         }
         return inst, nil
 }
 
 // Bootstrap is specified in the Environ interface.
-func (env *maasEnviron) Bootstrap(cons constraints.Value, stateServerCert, stateServerKey []byte) error {
-        constraints := cons.String()
-        if constraints != "" {
-                log.Warningf("ignoring constraints '%s' (not implemented)", constraints)
-        }
-
-        // This was all cargo-culted from the EC2 provider.
-        password := env.Config().AdminSecret()
-        if password == "" {
-                return fmt.Errorf("admin-secret is required for bootstrap")
-        }
-        log.Debugf("environs/maas: bootstrapping environment %q.", env.Name())
-        tools, err := env.findTools()
-        if err != nil {
-                return err
-        }
-        inst, err := env.startBootstrapNode(tools, stateServerCert, stateServerKey, password)
+func (env *maasEnviron) Bootstrap(cons constraints.Value) error {
+        // TODO(fwereade): this should check for an existing environment before
+        // starting a new one -- even given raciness, it's better than nothing.
+        inst, err := env.startBootstrapNode(cons)
         if err != nil {
                 return err
         }
         err = env.saveState(&bootstrapState{StateInstances: []state.InstanceId{inst.Id()}})
         if err != nil {
-                env.releaseInstance(inst)
+                if err := env.releaseInstance(inst); err != nil {
+                        log.Errorf("cannot release failed bootstrap instance: %v", err)

[dimitern, 2013/04/15 17:27:23]

environs/maas: ...

[fwereade, 2013/04/16 07:39:13]

Done.

+                }
                 return fmt.Errorf("cannot save state: %v", err)
         }
 
         // TODO make safe in the case of racing Bootstraps
         // If two Bootstraps are called concurrently, there's
         // no way to make sure that only one succeeds.
-
         return nil
 }
 
 // StateInfo is specified in the Environ interface.
 func (env *maasEnviron) StateInfo() (*state.Info, *api.Info, error) {
         // This code is cargo-culted from the openstack/ec2 providers.
         // It's a bit unclear what the "longAttempt" loop is actually for
         // but this should probably be refactored outside of the provider
         // code.
         st, err := env.loadState()
@@ skipping 82 matching lines @@
         authClient, err := gomaasapi.NewAuthenticatedClient(ecfg.MAASServer(), ecfg.MAASOAuth(), apiVersion)
         if err != nil {
                 return err
         }
         env.maasClientUnlocked = gomaasapi.NewMAAS(*authClient)
 
         return nil
 }
 
 // getMAASClient returns a MAAS client object to use for a request, in a
-// lock-protected fashioon.
+// lock-protected fashion.
 func (env *maasEnviron) getMAASClient() *gomaasapi.MAASObject {
         env.ecfgMutex.Lock()
         defer env.ecfgMutex.Unlock()
 
         return env.maasClientUnlocked
 }
 
 // acquireNode allocates a node from the MAAS.
-func (environ *maasEnviron) acquireNode() (gomaasapi.MAASObject, error) {
+func (environ *maasEnviron) acquireNode(cons constraints.Value, possibleTools tools.List) (gomaasapi.MAASObject, *state.Tools, error) {
+        log.Warningf("environs/maas: ignoring constraints %q", cons)
         retry := trivial.AttemptStrategy{
                 Total: 5 * time.Second,
                 Delay: 200 * time.Millisecond,
         }
         var result gomaasapi.JSONObject
         var err error
         for a := retry.Start(); a.Next(); {
                 client := environ.getMAASClient().GetSubObject("nodes/")
                 result, err = client.CallPost("acquire", nil)
                 if err == nil {
                         break
                 }
         }
         if err != nil {
-                return gomaasapi.MAASObject{}, err
+                return gomaasapi.MAASObject{}, nil, err
         }
         node, err := result.GetMAASObject()
         if err != nil {
                 msg := fmt.Errorf("unexpected result from 'acquire' on MAAS API: %v", err)
-                return gomaasapi.MAASObject{}, msg
+                return gomaasapi.MAASObject{}, nil, msg
         }
-        return node, nil
+        tools := possibleTools[0]
+        log.Warningf("environs/maas: picked arbitrary tools %q", tools)
+        return node, tools, nil
 }
 
 // startNode installs and boots a node.
-func (environ *maasEnviron) startNode(node gomaasapi.MAASObject, tools *state.Tools, userdata []byte) error {
+func (environ *maasEnviron) startNode(node gomaasapi.MAASObject, series string, userdata []byte) error {
         retry := trivial.AttemptStrategy{
                 Total: 5 * time.Second,
                 Delay: 200 * time.Millisecond,
         }
         userDataParam := base64.StdEncoding.EncodeToString(userdata)
         params := url.Values{
-                "distro_series": {tools.Series},
+                "distro_series": {series},
                 "user_data":     {userDataParam},
         }
         // Initialize err to a non-nil value as a sentinel for the following
         // loop.
         err := fmt.Errorf("(no error)")
         for a := retry.Start(); a.Next() && err != nil; {
                 _, err = node.CallPost("start", params)
         }
         return err
 }
 
 // obtainNode allocates and starts a MAAS node.  It is used both for the
 // implementation of StartInstance, and to initialize the bootstrap node.
-func (environ *maasEnviron) obtainNode(machineId string, stateInfo *state.Info, apiInfo *api.Info, tools *state.Tools, mcfg *cloudinit.MachineConfig) (*maasInstance, error) {
+func (environ *maasEnviron) obtainNode(machineId string, cons constraints.Value, possibleTools tools.List, mcfg *cloudinit.MachineConfig) (_ *maasInstance, err error) {
+        series := possibleTools.Series()
+        if len(series) != 1 {

[rog, 2013/04/15 13:24:10]

please no panic

[fwereade, 2013/04/16 07:39:13]

Same waffling applies. Done.

+                log.Errorf("expected one series; got %v", series)

[dimitern, 2013/04/15 17:27:23]

environs/maas: ...

+                panic("series should have been chosen by now")
+        }
+        var instance *maasInstance
+        if node, tools, err := environ.acquireNode(cons, possibleTools); err != nil {
+                return nil, fmt.Errorf("cannot run instances: %v", err)
+        } else {
+                instance = &maasInstance{&node, environ}
+                mcfg.Tools = tools
+        }
+        defer func() {
+                if err != nil {
+                        if err := environ.releaseInstance(instance); err != nil {

[dimitern, 2013/04/15 17:27:23]

you're losing the original error here, isn't that a problem?

[fwereade, 2013/04/16 07:39:13]

Am I? http://play.golang.org/

+                                log.Errorf("error releasing failed instance: %v", err)

[dimitern, 2013/04/15 17:27:23]

environs/maas: ...

[fwereade, 2013/04/16 07:39:13]

Done.

+                        }
+                }
+        }()
 
-        log.Debugf("environs/maas: starting machine %s in $q running tools version %q from %q", machineId, environ.name, tools.Binary, tools.URL)
-
-        node, err := environ.acquireNode()
-        if err != nil {
-                return nil, fmt.Errorf("cannot run instances: %v", err)
-        }
-
-        hostname, err := node.GetField("hostname")
+        hostname, err := instance.DNSName()
         if err != nil {
                 return nil, err
         }
-        instance := maasInstance{&node, environ}
         info := machineInfo{string(instance.Id()), hostname}
         runCmd, err := info.cloudinitRunCmd()
         if err != nil {
                 return nil, err
         }
+        if err := environs.FinishMachineConfig(mcfg, environ.Config(), cons); err != nil {
+                return nil, err
+        }
         userdata, err := userData(mcfg, runCmd)
         if err != nil {
                 msg := fmt.Errorf("could not compose userdata for bootstrap node: %v", err)
                 return nil, msg
         }
-        err = environ.startNode(node, tools, userdata)
-        if err != nil {
-                environ.releaseInstance(&instance)
-                return nil, fmt.Errorf("cannot start instance: %v", err)
+        if err := environ.startNode(*instance.maasObject, series[0], userdata); err != nil {
+                return nil, err
         }
         log.Debugf("environs/maas: started instance %q", instance.Id())
-        return &instance, nil
+        return instance, nil
 }
 
 // StartInstance is specified in the Environ interface.
 func (environ *maasEnviron) StartInstance(machineID, machineNonce string, series string, cons constraints.Value, stateInfo *state.Info, apiInfo *api.Info) (environs.Instance, error) {
-        // TODO: Support series and constraints.  They were added to the
-        // interface after we implemented.
-        flags := environs.HighestVersion | environs.CompatVersion
-        var err error
-        tools, err := environs.FindTools(environ, version.Current, flags)
+        possibleTools, err := environs.FindInstanceTools(environ, series, cons)
         if err != nil {
                 return nil, err
         }
-
-        mcfg := environ.makeMachineConfig(machineID, machineNonce, stateInfo, apiInfo, tools)
-        return environ.obtainNode(machineID, stateInfo, apiInfo, tools, mcfg)
+        mcfg := environ.makeMachineConfig(machineID, machineNonce, stateInfo, apiInfo)
+        return environ.obtainNode(machineID, cons, possibleTools, mcfg)
 }
 
 // StopInstances is specified in the Environ interface.
 func (environ *maasEnviron) StopInstances(instances []environs.Instance) error {
         // Shortcut to exit quickly if 'instances' is an empty slice or nil.
         if len(instances) == 0 {
                 return nil
         }
         // Tell MAAS to release each of the instances.  If there are errors,
         // return only the first one (but release all instances regardless).
@@ skipping 128 matching lines @@
 }
 
 func (*maasEnviron) Ports() ([]params.Port, error) {
         log.Debugf("environs/maas: unimplemented Ports() called")
         return []params.Port{}, nil
 }
 
 func (*maasEnviron) Provider() environs.EnvironProvider {
         return &providerInstance
 }