environs: add BootstrapConfig

environs/ec2/ec2.go

 package ec2
 
 import (
         "fmt"
         "io/ioutil"
         "launchpad.net/goamz/aws"
         "launchpad.net/goamz/ec2"
         "launchpad.net/goamz/s3"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/cloudinit"
@@ skipping 105 matching lines @@
         m := make(map[string]interface{})
         ecfg, err := providerInstance.newConfig(cfg)
         if err != nil {
                 return nil, err
         }
         m["access-key"] = ecfg.accessKey()
         m["secret-key"] = ecfg.secretKey()
         return m, nil
 }
 
-func (environProvider) publicAttrs(cfg *config.Config) (map[string]interface{}, error) {
-        m := make(map[string]interface{})
-        ecfg, err := providerInstance.newConfig(cfg)
-        if err != nil {
-                return nil, err
-        }
-        for k, v := range ecfg.UnknownAttrs() {
-                m[k] = v
-        }
-        secret, err := providerInstance.SecretAttrs(cfg)
-        if err != nil {
-                return nil, err
-        }
-        for k, _ := range secret {
-                delete(m, k)
-        }
-        return m, nil
-}
-
 func (environProvider) PublicAddress() (string, error) {
         return fetchMetadata("public-hostname")
 }
 
 func (environProvider) PrivateAddress() (string, error) {
         return fetchMetadata("local-hostname")
 }
 
 func (e *environ) Config() *config.Config {
         return e.ecfg().Config
@@ skipping 78 matching lines @@
         }
         if _, notFound := err.(*environs.NotFoundError); !notFound {
                 return fmt.Errorf("cannot query old bootstrap state: %v", err)
         }
         var tools *state.Tools
         if uploadTools {
                 tools, err = environs.PutTools(e.Storage(), nil)
                 if err != nil {
                         return fmt.Errorf("cannot upload tools: %v", err)
                 }
+        } else {
+                flags := environs.HighestVersion|environs.CompatVersion
+                tools, err = environs.FindTools(e, version.Current, flags)
+                if err != nil {
+                        return fmt.Errorf("cannot find tools: %v", err)
+                }
         }
-
-        config, err := providerInstance.publicAttrs(e.Config())
+        config, err := environs.BootstrapConfig(providerInstance, e.Config(), tools)
         if err != nil {
                 return fmt.Errorf("unable to determine inital configuration: %v", err)
         }
         inst, err := e.startInstance(0, nil, tools, true, config)
         if err != nil {
                 return fmt.Errorf("cannot start bootstrap instance: %v", err)
         }
         err = e.saveState(&bootstrapState{
                 ZookeeperInstances: []string{inst.Id()},
         })
@@ skipping 48 matching lines @@
 // AssignmentPolicy for EC2 is to deploy units only on machines without other
 // units already assigned, and to launch new machines as required.
 func (e *environ) AssignmentPolicy() state.AssignmentPolicy {
         return state.AssignUnused
 }
 
 func (e *environ) StartInstance(machineId int, info *state.Info, tools *state.Tools) (environs.Instance, error) {
         return e.startInstance(machineId, info, tools, false, nil)
 }
 
-func (e *environ) userData(machineId int, info *state.Info, tools *state.Tools, master bool, config map[string]interface{}) ([]byte, error) {
+func (e *environ) userData(machineId int, info *state.Info, tools *state.Tools, master bool, config *config.Config) ([]byte, error) {
         cfg := &cloudinit.MachineConfig{
                 Provisioner:        master,
                 StateServer:        master,
                 StateInfo:          info,
                 InstanceIdAccessor: "$(curl http://169.254.169.254/1.0/meta-data/instance-id)",
                 ProviderType:       "ec2",
                 Tools:              tools,
                 MachineId:          machineId,
                 AuthorizedKeys:     e.ecfg().AuthorizedKeys(),
                 Config:             config,
         }
         cloudcfg, err := cloudinit.New(cfg)
         if err != nil {
                 return nil, err
         }
         return cloudcfg.Render()
 }
 
 // startInstance is the internal version of StartInstance, used by Bootstrap
 // as well as via StartInstance itself. If master is true, a bootstrap
 // instance will be started.
-func (e *environ) startInstance(machineId int, info *state.Info, tools *state.Tools, master bool, config map[string]interface{}) (environs.Instance, error) {
+func (e *environ) startInstance(machineId int, info *state.Info, tools *state.Tools, master bool, config *config.Config) (environs.Instance, error) {
         if tools == nil {
                 var err error
-                tools, err = environs.FindTools(e, version.Current)
+                flags := environs.HighestVersion|environs.CompatVersion
+                tools, err = environs.FindTools(e, version.Current, flags)
                 if err != nil {
                         return nil, err
                 }
         }
         log.Printf("environs/ec2: starting machine %d in %q running tools version %q from %q", machineId, e.name, tools.Binary, tools.URL)
         spec, err := findInstanceSpec(&instanceConstraint{
                 series: tools.Series,
                 arch:   tools.Arch,
                 region: e.ecfg().region(),
         })
@@ skipping 483 matching lines @@
                 }
                 var data []byte
                 data, err = ioutil.ReadAll(resp.Body)
                 if err != nil {
                         continue
                 }
                 return strings.TrimSpace(string(data)), nil
         }
         return
 }