cmd/jujud: do not change password

environs/ec2/ec2.go

 // Copyright 2011, 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package ec2
 
 import (
         "fmt"
         "io/ioutil"
         "launchpad.net/goamz/aws"
         "launchpad.net/goamz/ec2"
         "launchpad.net/goamz/s3"
         "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/imagemetadata"
         "launchpad.net/juju-core/environs/instances"
         "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/errors"
+        "launchpad.net/juju-core/instance"
         "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/utils"
         "net/http"
         "strings"
         "sync"
         "time"
 )
 
 // A request may fail to due "eventual consistency" semantics, which
 // should resolve fairly quickly.  A request may also fail due to a slow
 // state transition (for instance an instance taking a while to release
@@ skipping 24 matching lines @@
         ecfgMutex             sync.Mutex
         ecfgUnlocked          *environConfig
         ec2Unlocked           *ec2.EC2
         s3Unlocked            *s3.S3
         storageUnlocked       *storage
         publicStorageUnlocked *storage // optional.
 }
 
 var _ environs.Environ = (*environ)(nil)
 
-type instance struct {
+type ec2Instance struct {
         e *environ
         *ec2.Instance
-}
-
-func (inst *instance) String() string {
+        arch     *string
+        instType *instances.InstanceType
+}
+
+func (inst *ec2Instance) String() string {
         return inst.InstanceId
 }
 
-var _ environs.Instance = (*instance)(nil)
-
-func (inst *instance) Id() state.InstanceId {
-        return state.InstanceId(inst.InstanceId)
-}
-
-func (inst *instance) DNSName() (string, error) {
+var _ instance.Instance = (*ec2Instance)(nil)
+
+func (inst *ec2Instance) Id() instance.Id {
+        return instance.Id(inst.InstanceId)
+}
+
+func (inst *ec2Instance) Metadata() *instance.Metadata {
+        metadata := &instance.Metadata{Arch: inst.arch}
+        if inst.instType != nil {
+                metadata.Mem = &inst.instType.Mem
+                metadata.CpuCores = &inst.instType.CpuCores
+                metadata.CpuPower = inst.instType.CpuPower
+        }
+        return metadata
+}
+
+func (inst *ec2Instance) DNSName() (string, error) {
         if inst.Instance.DNSName != "" {
                 return inst.Instance.DNSName, nil
         }
         // Fetch the instance information again, in case
         // the DNS information has become available.
-        insts, err := inst.e.Instances([]state.InstanceId{inst.Id()})
+        insts, err := inst.e.Instances([]instance.Id{inst.Id()})
         if err != nil {
                 return "", err
         }
-        freshInst := insts[0].(*instance).Instance
+        freshInst := insts[0].(*ec2Instance).Instance
         if freshInst.DNSName == "" {
-                return "", environs.ErrNoDNSName
+                return "", instance.ErrNoDNSName
         }
         inst.Instance.DNSName = freshInst.DNSName
         return freshInst.DNSName, nil
 }
 
-func (inst *instance) WaitDNSName() (string, error) {
+func (inst *ec2Instance) WaitDNSName() (string, error) {
         for a := longAttempt.Start(); a.Next(); {
                 name, err := inst.DNSName()
-                if err == nil || err != environs.ErrNoDNSName {
+                if err == nil || err != instance.ErrNoDNSName {
                         return name, err
                 }
         }
         return "", fmt.Errorf("timed out trying to get DNS address for %v", inst.Id())
 }
 
 func (p environProvider) BoilerplateConfig() string {
         return `
 ## https://juju.ubuntu.com/get-started/amazon/
 amazon:
@@ skipping 35 matching lines @@
 }
 
 func (environProvider) PublicAddress() (string, error) {
         return fetchMetadata("public-hostname")
 }
 
 func (environProvider) PrivateAddress() (string, error) {
         return fetchMetadata("local-hostname")
 }
 
-func (environProvider) InstanceId() (state.InstanceId, error) {
+func (environProvider) InstanceId() (instance.Id, error) {
         str, err := fetchMetadata("instance-id")
-        return state.InstanceId(str), err
+        return instance.Id(str), err
 }
 
 func (e *environ) Config() *config.Config {
         return e.ecfg().Config
 }
 
 func (e *environ) SetConfig(cfg *config.Config) error {
         ecfg, err := providerInstance.newConfig(cfg)
         if err != nil {
                 return err
@@ skipping 77 matching lines @@
                         break
                 }
         }
         if err == nil {
                 return fmt.Errorf("environment is already bootstrapped")
         }
         if !errors.IsNotFoundError(err) {
                 return fmt.Errorf("cannot query old bootstrap state: %v", err)
         }
 
+        err = environs.VerifyStorage(e.Storage())
+        if err != nil {
+                return err
+        }
+
         possibleTools, err := environs.FindBootstrapTools(e, cons)
         if err != nil {
                 return err
         }
         inst, err := e.startInstance(&startInstanceParams{
                 machineId:     "0",
                 machineNonce:  state.BootstrapNonce,
                 series:        e.Config().DefaultSeries(),
                 constraints:   cons,
                 possibleTools: possibleTools,
                 stateServer:   true,
         })
         if err != nil {
                 return fmt.Errorf("cannot start bootstrap instance: %v", err)
         }
         err = e.saveState(&bootstrapState{
-                StateInstances: []state.InstanceId{inst.Id()},
+                StateInstances: []instance.Id{inst.Id()},
         })
         if err != nil {
                 // ignore error on StopInstance because the previous error is
                 // more important.
-                e.StopInstances([]environs.Instance{inst})
+                e.StopInstances([]instance.Instance{inst})
                 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 use S3 to make sure that only one succeeds.
         // Perhaps consider using SimpleDB for state storage
         // which would enable that possibility.
         return nil
 }
 
@@ skipping 14 matching lines @@
         log.Infof("environs/ec2: waiting for DNS name(s) of state server instances %v", st.StateInstances)
         for a := longAttempt.Start(); len(stateAddrs) == 0 && a.Next(); {
                 insts, err := e.Instances(st.StateInstances)
                 if err != nil && err != environs.ErrPartialInstances {
                         return nil, nil, err
                 }
                 for _, inst := range insts {
                         if inst == nil {
                                 continue
                         }
-                        name := inst.(*instance).Instance.DNSName
+                        name := inst.(*ec2Instance).Instance.DNSName
                         if name != "" {
                                 statePortSuffix := fmt.Sprintf(":%d", config.StatePort())
                                 apiPortSuffix := fmt.Sprintf(":%d", config.APIPort())
                                 stateAddrs = append(stateAddrs, name+statePortSuffix)
                                 apiAddrs = append(apiAddrs, name+apiPortSuffix)
                         }
                 }
         }
         if len(stateAddrs) == 0 {
                 return nil, nil, fmt.Errorf("timed out waiting for mgo address from %v", st.StateInstances)
         }
         return &state.Info{
                         Addrs:  stateAddrs,
                         CACert: cert,
                 }, &api.Info{
                         Addrs:  apiAddrs,
                         CACert: cert,
                 }, nil
 }
 
 // getImageBaseURLs returns a list of URLs which are used to search for simplestreams image metadata.
 func (e *environ) getImageBaseURLs() ([]string, error) {
         // Use the default simplestreams base URL.
         return []string{imagemetadata.DefaultBaseURL}, nil
 }
 
-func (e *environ) StartInstance(machineId, machineNonce string, series string, cons constraints.Value, info *state.Info, apiInfo *api.Info) (environs.Instance, error) {
+func (e *environ) StartInstance(machineId, machineNonce string, series string, cons constraints.Value, info *state.Info, apiInfo *api.Info) (instance.Instance, error) {
         possibleTools, err := environs.FindInstanceTools(e, series, cons)
         if err != nil {
                 return nil, err
         }
         return e.startInstance(&startInstanceParams{
                 machineId:     machineId,
                 machineNonce:  machineNonce,
                 series:        series,
                 constraints:   cons,
                 info:          info,
@@ skipping 36 matching lines @@
         info          *state.Info
         apiInfo       *api.Info
         possibleTools tools.List
         stateServer   bool
 }
 
 const ebsStorage = "ebs"
 
 // startInstance is the internal version of StartInstance, used by Bootstrap
 // as well as via StartInstance itself.
-func (e *environ) startInstance(scfg *startInstanceParams) (environs.Instance, error) {
+func (e *environ) startInstance(scfg *startInstanceParams) (instance.Instance, error) {
         series := scfg.possibleTools.Series()
         if len(series) != 1 {
                 return nil, fmt.Errorf("expected single series, got %v", series)
         }
         if series[0] != scfg.series {
                 return nil, fmt.Errorf("tools mismatch: expected series %v, got %v", series, series[0])
         }
         arches := scfg.possibleTools.Arches()
         storage := ebsStorage
         baseURLs, err := e.getImageBaseURLs()
@@ skipping 24 matching lines @@
                 return nil, fmt.Errorf("cannot set up groups: %v", err)
         }
         var instances *ec2.RunInstancesResp
 
         for a := shortAttempt.Start(); a.Next(); {
                 instances, err = e.ec2().RunInstances(&ec2.RunInstances{
                         ImageId:        spec.Image.Id,
                         MinCount:       1,
                         MaxCount:       1,
                         UserData:       userData,
-                        InstanceType:   spec.InstanceTypeName,
+                        InstanceType:   spec.InstanceType.Name,
                         SecurityGroups: groups,
                 })
                 if err == nil || ec2ErrCode(err) != "InvalidGroup.NotFound" {
                         break
                 }
         }
         if err != nil {
                 return nil, fmt.Errorf("cannot run instances: %v", err)
         }
         if len(instances.Instances) != 1 {
                 return nil, fmt.Errorf("expected 1 started instance, got %d", len(instances.Instances))
         }
-        inst := &instance{e, &instances.Instances[0]}
+        inst := &ec2Instance{
+                e:        e,
+                Instance: &instances.Instances[0],
+                arch:     &spec.Image.Arch,
+                instType: &spec.InstanceType,
+        }
         log.Infof("environs/ec2: started instance %q", inst.Id())
         return inst, nil
 }
 
-func (e *environ) StopInstances(insts []environs.Instance) error {
-        ids := make([]state.InstanceId, len(insts))
+func (e *environ) StopInstances(insts []instance.Instance) error {
+        ids := make([]instance.Id, len(insts))
         for i, inst := range insts {
-                ids[i] = inst.(*instance).Id()
+                ids[i] = inst.(*ec2Instance).Id()
         }
         return e.terminateInstances(ids)
 }
 
 // gatherInstances tries to get information on each instance
 // id whose corresponding insts slot is nil.
 // It returns environs.ErrPartialInstances if the insts
 // slice has not been completely filled.
-func (e *environ) gatherInstances(ids []state.InstanceId, insts []environs.Instance) error {
+func (e *environ) gatherInstances(ids []instance.Id, insts []instance.Instance) error {
         var need []string
         for i, inst := range insts {
                 if inst == nil {
                         need = append(need, string(ids[i]))
                 }
         }
         if len(need) == 0 {
                 return nil
         }
         filter := ec2.NewFilter()
         filter.Add("instance-state-name", "pending", "running")
         filter.Add("group-name", e.jujuGroupName())
         filter.Add("instance-id", need...)
         resp, err := e.ec2().Instances(nil, filter)
         if err != nil {
                 return err
         }
         n := 0
         // For each requested id, add it to the returned instances
         // if we find it in the response.
         for i, id := range ids {
                 if insts[i] != nil {
                         continue
                 }
                 for j := range resp.Reservations {
                         r := &resp.Reservations[j]
                         for k := range r.Instances {
                                 if r.Instances[k].InstanceId == string(id) {
                                         inst := r.Instances[k]
-                                        insts[i] = &instance{e, &inst}
+                                        // TODO(wallyworld): lookup the details to fill in the instance type data
+                                        insts[i] = &ec2Instance{e: e, Instance: &inst}
                                         n++
                                 }
                         }
                 }
         }
         if n < len(ids) {
                 return environs.ErrPartialInstances
         }
         return nil
 }
 
-func (e *environ) Instances(ids []state.InstanceId) ([]environs.Instance, error) {
+func (e *environ) Instances(ids []instance.Id) ([]instance.Instance, error) {
         if len(ids) == 0 {
                 return nil, nil
         }
-        insts := make([]environs.Instance, len(ids))
+        insts := make([]instance.Instance, len(ids))
         // Make a series of requests to cope with eventual consistency.
         // Each request will attempt to add more instances to the requested
         // set.
         var err error
         for a := shortAttempt.Start(); a.Next(); {
                 err = e.gatherInstances(ids, insts)
                 if err == nil || err != environs.ErrPartialInstances {
                         break
                 }
         }
         if err == environs.ErrPartialInstances {
                 for _, inst := range insts {
                         if inst != nil {
                                 return insts, environs.ErrPartialInstances
                         }
                 }
                 return nil, environs.ErrNoInstances
         }
         if err != nil {
                 return nil, err
         }
         return insts, nil
 }
 
-func (e *environ) AllInstances() ([]environs.Instance, error) {
+func (e *environ) AllInstances() ([]instance.Instance, error) {
         filter := ec2.NewFilter()
         filter.Add("instance-state-name", "pending", "running")
         filter.Add("group-name", e.jujuGroupName())
         resp, err := e.ec2().Instances(nil, filter)
         if err != nil {
                 return nil, err
         }
-        var insts []environs.Instance
+        var insts []instance.Instance
         for _, r := range resp.Reservations {
                 for i := range r.Instances {
                         inst := r.Instances[i]
-                        insts = append(insts, &instance{e, &inst})
+                        // TODO(wallyworld): lookup the details to fill in the instance type data
+                        insts = append(insts, &ec2Instance{e: e, Instance: &inst})
                 }
         }
         return insts, nil
 }
 
-func (e *environ) Destroy(ensureInsts []environs.Instance) error {
+func (e *environ) Destroy(ensureInsts []instance.Instance) error {
         log.Infof("environs/ec2: destroying environment %q", e.name)
         insts, err := e.AllInstances()
         if err != nil {
                 return fmt.Errorf("cannot get instances: %v", err)
         }
-        found := make(map[state.InstanceId]bool)
-        var ids []state.InstanceId
+        found := make(map[instance.Id]bool)
+        var ids []instance.Id
         for _, inst := range insts {
                 ids = append(ids, inst.Id())
                 found[inst.Id()] = true
         }
 
         // Add any instances we've been told about but haven't yet shown
         // up in the instance list.
         for _, inst := range ensureInsts {
-                id := state.InstanceId(inst.(*instance).InstanceId)
+                id := instance.Id(inst.(*ec2Instance).InstanceId)
                 if !found[id] {
                         ids = append(ids, id)
                         found[id] = true
                 }
         }
         err = e.terminateInstances(ids)
         if err != nil {
                 return err
         }
 
         // To properly observe e.storageUnlocked we need to get its value while
         // holding e.ecfgMutex. e.Storage() does this for us, then we convert
         // back to the (*storage) to access the private deleteAll() method.
         st := e.Storage().(*storage)
         return st.deleteAll()
 }
 
-func portsToIPPerms(ports []params.Port) []ec2.IPPerm {
+func portsToIPPerms(ports []instance.Port) []ec2.IPPerm {
         ipPerms := make([]ec2.IPPerm, len(ports))
         for i, p := range ports {
                 ipPerms[i] = ec2.IPPerm{
                         Protocol:  p.Protocol,
                         FromPort:  p.Number,
                         ToPort:    p.Number,
                         SourceIPs: []string{"0.0.0.0/0"},
                 }
         }
         return ipPerms
 }
 
-func (e *environ) openPortsInGroup(name string, ports []params.Port) error {
+func (e *environ) openPortsInGroup(name string, ports []instance.Port) error {
         if len(ports) == 0 {
                 return nil
         }
         // Give permissions for anyone to access the given ports.
         ipPerms := portsToIPPerms(ports)
         g := ec2.SecurityGroup{Name: name}
         _, err := e.ec2().AuthorizeSecurityGroup(g, ipPerms)
         if err != nil && ec2ErrCode(err) == "InvalidPermission.Duplicate" {
                 if len(ports) == 1 {
                         return nil
                 }
                 // If there's more than one port and we get a duplicate error,
                 // then we go through authorizing each port individually,
                 // otherwise the ports that were *not* duplicates will have
                 // been ignored
                 for i := range ipPerms {
                         _, err := e.ec2().AuthorizeSecurityGroup(g, ipPerms[i:i+1])
                         if err != nil && ec2ErrCode(err) != "InvalidPermission.Duplicate" {
                                 return fmt.Errorf("cannot open port %v: %v", ipPerms[i], err)
                         }
                 }
                 return nil
         }
         if err != nil {
                 return fmt.Errorf("cannot open ports: %v", err)
         }
         return nil
 }
 
-func (e *environ) closePortsInGroup(name string, ports []params.Port) error {
+func (e *environ) closePortsInGroup(name string, ports []instance.Port) error {
         if len(ports) == 0 {
                 return nil
         }
         // Revoke permissions for anyone to access the given ports.
         // Note that ec2 allows the revocation of permissions that aren't
         // granted, so this is naturally idempotent.
         g := ec2.SecurityGroup{Name: name}
         _, err := e.ec2().RevokeSecurityGroup(g, portsToIPPerms(ports))
         if err != nil {
                 return fmt.Errorf("cannot close ports: %v", err)
         }
         return nil
 }
 
-func (e *environ) portsInGroup(name string) (ports []params.Port, err error) {
+func (e *environ) portsInGroup(name string) (ports []instance.Port, err error) {
         g := ec2.SecurityGroup{Name: name}
         resp, err := e.ec2().SecurityGroups([]ec2.SecurityGroup{g}, nil)
         if err != nil {
                 return nil, err
         }
         if len(resp.Groups) != 1 {
                 return nil, fmt.Errorf("expected one security group, got %d", len(resp.Groups))
         }
         for _, p := range resp.Groups[0].IPPerms {
                 if len(p.SourceIPs) != 1 {
                         log.Warningf("environs/ec2: unexpected IP permission found: %v", p)
                         continue
                 }
                 for i := p.FromPort; i <= p.ToPort; i++ {
-                        ports = append(ports, params.Port{
+                        ports = append(ports, instance.Port{
                                 Protocol: p.Protocol,
                                 Number:   i,
                         })
                 }
         }
         state.SortPorts(ports)
         return ports, nil
 }
 
-func (e *environ) OpenPorts(ports []params.Port) error {
+func (e *environ) OpenPorts(ports []instance.Port) error {
         if e.Config().FirewallMode() != config.FwGlobal {
                 return fmt.Errorf("invalid firewall mode for opening ports on environment: %q",
                         e.Config().FirewallMode())
         }
         if err := e.openPortsInGroup(e.globalGroupName(), ports); err != nil {
                 return err
         }
         log.Infof("environs/ec2: opened ports in global group: %v", ports)
         return nil
 }
 
-func (e *environ) ClosePorts(ports []params.Port) error {
+func (e *environ) ClosePorts(ports []instance.Port) error {
         if e.Config().FirewallMode() != config.FwGlobal {
                 return fmt.Errorf("invalid firewall mode for closing ports on environment: %q",
                         e.Config().FirewallMode())
         }
         if err := e.closePortsInGroup(e.globalGroupName(), ports); err != nil {
                 return err
         }
         log.Infof("environs/ec2: closed ports in global group: %v", ports)
         return nil
 }
 
-func (e *environ) Ports() ([]params.Port, error) {
+func (e *environ) Ports() ([]instance.Port, error) {
         if e.Config().FirewallMode() != config.FwGlobal {
                 return nil, fmt.Errorf("invalid firewall mode for retrieving ports from environment: %q",
                         e.Config().FirewallMode())
         }
         return e.portsInGroup(e.globalGroupName())
 }
 
 func (*environ) Provider() environs.EnvironProvider {
         return &providerInstance
 }
 
-func (e *environ) terminateInstances(ids []state.InstanceId) error {
+func (e *environ) terminateInstances(ids []instance.Id) error {
         if len(ids) == 0 {
                 return nil
         }
         var err error
         ec2inst := e.ec2()
         strs := make([]string, len(ids))
         for i, id := range ids {
                 strs[i] = string(id)
         }
         for a := shortAttempt.Start(); a.Next(); {
@@ skipping 26 matching lines @@
 }
 
 func (e *environ) machineGroupName(machineId string) string {
         return fmt.Sprintf("%s-%s", e.jujuGroupName(), machineId)
 }
 
 func (e *environ) jujuGroupName() string {
         return "juju-" + e.name
 }
 
-func (inst *instance) OpenPorts(machineId string, ports []params.Port) error {
+func (inst *ec2Instance) OpenPorts(machineId string, ports []instance.Port) error {
         if inst.e.Config().FirewallMode() != config.FwInstance {
                 return fmt.Errorf("invalid firewall mode for opening ports on instance: %q",
                         inst.e.Config().FirewallMode())
         }
         name := inst.e.machineGroupName(machineId)
         if err := inst.e.openPortsInGroup(name, ports); err != nil {
                 return err
         }
         log.Infof("environs/ec2: opened ports in security group %s: %v", name, ports)
         return nil
 }
 
-func (inst *instance) ClosePorts(machineId string, ports []params.Port) error {
+func (inst *ec2Instance) ClosePorts(machineId string, ports []instance.Port) error {
         if inst.e.Config().FirewallMode() != config.FwInstance {
                 return fmt.Errorf("invalid firewall mode for closing ports on instance: %q",
                         inst.e.Config().FirewallMode())
         }
         name := inst.e.machineGroupName(machineId)
         if err := inst.e.closePortsInGroup(name, ports); err != nil {
                 return err
         }
         log.Infof("environs/ec2: closed ports in security group %s: %v", name, ports)
         return nil
 }
 
-func (inst *instance) Ports(machineId string) ([]params.Port, error) {
+func (inst *ec2Instance) Ports(machineId string) ([]instance.Port, error) {
         if inst.e.Config().FirewallMode() != config.FwInstance {
                 return nil, fmt.Errorf("invalid firewall mode for retrieving ports from instance: %q",
                         inst.e.Config().FirewallMode())
         }
         name := inst.e.machineGroupName(machineId)
         return inst.e.portsInGroup(name)
 }
 
 // setUpGroups creates the security groups for the new machine, and
 // returns them.
@@ skipping 208 matching lines @@
                 }
                 var data []byte
                 data, err = ioutil.ReadAll(resp.Body)
                 if err != nil {
                         continue
                 }
                 return strings.TrimSpace(string(data)), nil
         }
         return
 }