cmd/jujud: do not change password

environs/openstack/provider.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 // Stub provider for OpenStack, using goose will be implemented here
 
 package openstack
 
 import (
         "encoding/json"
         "errors"
         "fmt"
         "io/ioutil"
         "launchpad.net/goose/client"
         gooseerrors "launchpad.net/goose/errors"
         "launchpad.net/goose/identity"
         "launchpad.net/goose/nova"
         "launchpad.net/goose/swift"
         "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"
         coreerrors "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"
         "strconv"
         "strings"
         "sync"
         "time"
 )
 
 type environProvider struct{}
 
@@ skipping 111 matching lines @@
         } else if addr != "" {
                 return addr, nil
         }
         return p.PrivateAddress()
 }
 
 func (p environProvider) PrivateAddress() (string, error) {
         return fetchMetadata("local-ipv4")
 }
 
-func (p environProvider) InstanceId() (state.InstanceId, error) {
+func (p environProvider) InstanceId() (instance.Id, error) {
         str, err := fetchInstanceUUID()
         if err != nil {
                 str, err = fetchLegacyId()
         }
-        return state.InstanceId(str), err
+        return instance.Id(str), err
 }
 
 // metadataHost holds the address of the instance metadata service.
 // It is a variable so that tests can change it to refer to a local
 // server when needed.
 var metadataHost = "http://169.254.169.254"
 
 // fetchMetadata fetches a single atom of data from the openstack instance metadata service.
 // http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html
 // (the same specs is implemented in ec2, hence the reference)
@@ skipping 86 matching lines @@
         novaUnlocked          *nova.Client
         storageUnlocked       environs.Storage
         publicStorageUnlocked environs.StorageReader // optional.
         // An ordered list of paths in which to find the simplestreams index files used to
         // look up image ids.
         imageBaseURLs []string
 }
 
 var _ environs.Environ = (*environ)(nil)
 
-type instance struct {
-        e *environ
+type openstackInstance struct {
         *nova.ServerDetail
-        address string
-}
-
-func (inst *instance) String() string {
+        e        *environ
+        instType *instances.InstanceType
+        arch     *string
+        address  string
+}
+
+func (inst *openstackInstance) String() string {
         return inst.ServerDetail.Id
 }
 
-var _ environs.Instance = (*instance)(nil)
-
-func (inst *instance) Id() state.InstanceId {
-        return state.InstanceId(inst.ServerDetail.Id)
+var _ instance.Instance = (*openstackInstance)(nil)
+
+func (inst *openstackInstance) Id() instance.Id {
+        return instance.Id(inst.ServerDetail.Id)
+}
+
+func (inst *openstackInstance) 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
 }
 
 // instanceAddress processes a map of networks to lists of IP
 // addresses, as returned by Nova.GetServer(), extracting the proper
 // public (or private, if public is not available) IPv4 address, and
 // returning it, or an error.
 func instanceAddress(addresses map[string][]nova.IPAddress) (string, error) {
         var private, public, privateNet string
         for network, ips := range addresses {
                 for _, address := range ips {
@@ skipping 15 matching lines @@
                         public = prv[1].Address
                 }
         }
         // Juju assumes it always needs a public address and loops waiting for one.
         // In fact a private address is generally fine provided it can be sshed to.
         // (ported from py-juju/providers/openstack)
         if public == "" && private != "" {
                 public = private
         }
         if public == "" {
-                return "", environs.ErrNoDNSName
+                return "", instance.ErrNoDNSName
         }
         return public, nil
 }
 
-func (inst *instance) DNSName() (string, error) {
+func (inst *openstackInstance) DNSName() (string, error) {
         if inst.address != "" {
                 return inst.address, nil
         }
         // Fetch the instance information again, in case
         // the addresses have become available.
         server, err := inst.e.nova().GetServer(string(inst.Id()))
         if err != nil {
                 return "", err
         }
         inst.address, err = instanceAddress(server.Addresses)
         if err != nil {
                 return "", err
         }
         return inst.address, nil
 }
 
-func (inst *instance) WaitDNSName() (string, error) {
+func (inst *openstackInstance) WaitDNSName() (string, error) {
         for a := longAttempt.Start(); a.Next(); {
                 addr, err := inst.DNSName()
-                if err == nil || err != environs.ErrNoDNSName {
+                if err == nil || err != instance.ErrNoDNSName {
                         return addr, err
                 }
         }
         return "", fmt.Errorf("timed out trying to get DNS address for %v", inst.Id())
 }
 
 // TODO: following 30 lines nearly verbatim from environs/ec2
 
-func (inst *instance) OpenPorts(machineId string, ports []params.Port) error {
+func (inst *openstackInstance) 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/openstack: opened ports in security group %s: %v", name, ports)
         return nil
 }
 
-func (inst *instance) ClosePorts(machineId string, ports []params.Port) error {
+func (inst *openstackInstance) 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/openstack: closed ports in security group %s: %v", name, ports)
         return nil
 }
 
-func (inst *instance) Ports(machineId string) ([]params.Port, error) {
+func (inst *openstackInstance) 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)
 }
 
 func (e *environ) ecfg() *environConfig {
         e.ecfgMutex.Lock()
@@ skipping 84 matching lines @@
                 if err != nil {
                         break
                 }
         }
         if err == nil {
                 return fmt.Errorf("environment is already bootstrapped")
         }
         if !coreerrors.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,
                 withPublicIP:  e.ecfg().useFloatingIP(),
         })
         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 Swift to make sure that only one succeeds.
         // Perhaps consider using SimpleDB for state storage
         // which would enable that possibility.
 
         return nil
 }
@@ skipping 17 matching lines @@
                 insts, err := e.Instances(st.StateInstances)
                 if err != nil && err != environs.ErrPartialInstances {
                         log.Debugf("error getting state instance: %v", err.Error())
                         return nil, nil, err
                 }
                 log.Debugf("started processing instances: %#v", insts)
                 for _, inst := range insts {
                         if inst == nil {
                                 continue
                         }
-                        name, err := inst.(*instance).DNSName()
+                        name, err := inst.(*openstackInstance).DNSName()
                         if err != nil {
                                 continue
                         }
                         if name != "" {
                                 statePortSuffix := fmt.Sprintf(":%d", config.StatePort())
                                 apiPortSuffix := fmt.Sprintf(":%d", config.APIPort())
                                 stateAddrs = append(stateAddrs, name+statePortSuffix)
                                 apiAddrs = append(apiAddrs, name+apiPortSuffix)
                         }
                 }
@@ skipping 91 matching lines @@
         productStreamsURL, err := e.client.MakeServiceURL("product-streams", nil)
         if err == nil {
                 e.imageBaseURLs = append(e.imageBaseURLs, productStreamsURL)
         }
         // Add the default simplestreams base URL.
         e.imageBaseURLs = append(e.imageBaseURLs, imagemetadata.DefaultBaseURL)
 
         return e.imageBaseURLs, 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 89 matching lines @@
                 err = e.nova().AddServerFloatingIP(serverId, fip.IP)
                 if err == nil {
                         return nil
                 }
         }
         return err
 }
 
 // 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()
         spec, err := findInstanceSpec(e, &instances.InstanceConstraint{
                 Region:      e.ecfg().region(),
@@ skipping 28 matching lines @@
         }
         var groupNames = make([]nova.SecurityGroupName, len(groups))
         for i, g := range groups {
                 groupNames[i] = nova.SecurityGroupName{g.Name}
         }
 
         var server *nova.Entity
         for a := shortAttempt.Start(); a.Next(); {
                 server, err = e.nova().RunServer(nova.RunServerOpts{
                         Name:               e.machineFullName(scfg.machineId),
-                        FlavorId:           spec.InstanceTypeId,
+                        FlavorId:           spec.InstanceType.Id,
                         ImageId:            spec.Image.Id,
                         UserData:           userData,
                         SecurityGroupNames: groupNames,
                 })
                 if err == nil || !gooseerrors.IsNotFound(err) {
                         break
                 }
         }
         if err != nil {
                 return nil, fmt.Errorf("cannot run instance: %v", err)
         }
         detail, err := e.nova().GetServer(server.Id)
         if err != nil {
                 return nil, fmt.Errorf("cannot get started instance: %v", err)
         }
-        inst := &instance{e, detail, ""}
+        inst := &openstackInstance{
+                e:            e,
+                ServerDetail: detail,
+                arch:         &spec.Image.Arch,
+                instType:     &spec.InstanceType,
+        }
         log.Infof("environs/openstack: started instance %q", inst.Id())
         if scfg.withPublicIP {
                 if err := e.assignPublicIP(publicIP, string(inst.Id())); err != nil {
-                        if err := e.terminateInstances([]state.InstanceId{inst.Id()}); err != nil {
+                        if err := e.terminateInstances([]instance.Id{inst.Id()}); err != nil {
                                 // ignore the failure at this stage, just log it
                                 log.Debugf("environs/openstack: failed to terminate instance %q: %v", inst.Id(), err)
                         }
                         return nil, fmt.Errorf("cannot assign public address %s to instance %q: %v", publicIP.IP, inst.Id(), err)
                 }
                 log.Infof("environs/openstack: assigned public IP %s to %q", publicIP.IP, 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 {
-                instanceValue, ok := inst.(*instance)
+                instanceValue, ok := inst.(*openstackInstance)
                 if !ok {
-                        return errors.New("Incompatible environs.Instance supplied")
+                        return errors.New("Incompatible instance.Instance supplied")
                 }
                 ids[i] = instanceValue.Id()
         }
         log.Debugf("environs/openstack: terminating instances %v", ids)
         return e.terminateInstances(ids)
 }
 
 // collectInstances tries to get information on each instance id in ids.
 // It fills the slots in the given map for known servers with status
 // either ACTIVE or BUILD. Returns a list of missing ids.
-func (e *environ) collectInstances(ids []state.InstanceId, out map[state.InstanceId]environs.Instance) []state.InstanceId {
+func (e *environ) collectInstances(ids []instance.Id, out map[instance.Id]instance.Instance) []instance.Id {
         var err error
         serversById := make(map[string]nova.ServerDetail)
         if len(ids) == 1 {
                 // most common case - single instance
                 var server *nova.ServerDetail
                 server, err = e.nova().GetServer(string(ids[0]))
                 if server != nil {
                         serversById[server.Id] = *server
                 }
         } else {
                 var servers []nova.ServerDetail
                 servers, err = e.nova().ListServersDetail(e.machinesFilter())
                 for _, server := range servers {
                         serversById[server.Id] = server
                 }
         }
         if err != nil {
                 return ids
         }
-        var missing []state.InstanceId
+        var missing []instance.Id
         for _, id := range ids {
                 if server, found := serversById[string(id)]; found {
                         if server.Status == nova.StatusActive || server.Status == nova.StatusBuild {
-                                out[id] = &instance{e, &server, ""}
+                                // TODO(wallyworld): lookup the flavor details to fill in the instance type data
+                                out[id] = &openstackInstance{e: e, ServerDetail: &server}
                         }
                         continue
                 }
                 missing = append(missing, id)
         }
         return missing
 }
 
-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
         }
         missing := ids
-        found := make(map[state.InstanceId]environs.Instance)
+        found := make(map[instance.Id]instance.Instance)
         // Make a series of requests to cope with eventual consistency.
         // Each request will attempt to add more instances to the requested
         // set.
         for a := shortAttempt.Start(); a.Next(); {
                 if missing = e.collectInstances(missing, found); len(missing) == 0 {
                         break
                 }
         }
         if len(found) == 0 {
                 return nil, environs.ErrNoInstances
         }
-        insts := make([]environs.Instance, len(ids))
+        insts := make([]instance.Instance, len(ids))
         var err error
         for i, id := range ids {
                 if inst := found[id]; inst != nil {
                         insts[i] = inst
                 } else {
                         err = environs.ErrPartialInstances
                 }
         }
         return insts, err
 }
 
-func (e *environ) AllInstances() (insts []environs.Instance, err error) {
+func (e *environ) AllInstances() (insts []instance.Instance, err error) {
         servers, err := e.nova().ListServersDetail(e.machinesFilter())
         if err != nil {
                 return nil, err
         }
         for _, server := range servers {
                 if server.Status == nova.StatusActive || server.Status == nova.StatusBuild {
                         var s = server
-                        insts = append(insts, &instance{e, &s, ""})
+                        // TODO(wallyworld): lookup the flavor details to fill in the instance type data
+                        insts = append(insts, &openstackInstance{
+                                e:            e,
+                                ServerDetail: &s,
+                        })
                 }
         }
         return insts, err
 }
 
-func (e *environ) Destroy(ensureInsts []environs.Instance) error {
+func (e *environ) Destroy(ensureInsts []instance.Instance) error {
         log.Infof("environs/openstack: 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).Id())
+                id := instance.Id(inst.(*openstackInstance).Id())
                 if !found[id] {
                         ids = append(ids, id)
                         found[id] = true
                 }
         }
         err = e.terminateInstances(ids)
         if err != nil {
                 return err
         }
 
@@ skipping 20 matching lines @@
         return fmt.Sprintf("juju-%s-%s", e.Name(), state.MachineTag(machineId))
 }
 
 // machinesFilter returns a nova.Filter matching all machines in the environment.
 func (e *environ) machinesFilter() *nova.Filter {
         filter := nova.NewFilter()
         filter.Set(nova.FilterServer, fmt.Sprintf("juju-%s-.*", e.Name()))
         return filter
 }
 
-func (e *environ) openPortsInGroup(name string, ports []params.Port) error {
+func (e *environ) openPortsInGroup(name string, ports []instance.Port) error {
         novaclient := e.nova()
         group, err := novaclient.SecurityGroupByName(name)
         if err != nil {
                 return err
         }
         for _, port := range ports {
                 _, err := novaclient.CreateSecurityGroupRule(nova.RuleInfo{
                         ParentGroupId: group.Id,
                         FromPort:      port.Number,
                         ToPort:        port.Number,
                         IPProtocol:    port.Protocol,
                         Cidr:          "0.0.0.0/0",
                 })
                 if err != nil {
                         // TODO: if err is not rule already exists, raise?
                         log.Debugf("error creating security group rule: %v", err.Error())
                 }
         }
         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
         }
         novaclient := e.nova()
         group, err := novaclient.SecurityGroupByName(name)
         if err != nil {
                 return err
         }
         // TODO: Hey look ma, it's quadratic
         for _, port := range ports {
                 for _, p := range (*group).Rules {
                         if p.IPProtocol == nil || *p.IPProtocol != port.Protocol ||
                                 p.FromPort == nil || *p.FromPort != port.Number ||
                                 p.ToPort == nil || *p.ToPort != port.Number {
                                 continue
                         }
                         err := novaclient.DeleteSecurityGroupRule(p.Id)
                         if err != nil {
                                 return err
                         }
                         break
                 }
         }
         return nil
 }
 
-func (e *environ) portsInGroup(name string) (ports []params.Port, err error) {
+func (e *environ) portsInGroup(name string) (ports []instance.Port, err error) {
         group, err := e.nova().SecurityGroupByName(name)
         if err != nil {
                 return nil, err
         }
         for _, p := range (*group).Rules {
                 for i := *p.FromPort; i <= *p.ToPort; i++ {
-                        ports = append(ports, params.Port{
+                        ports = append(ports, instance.Port{
                                 Protocol: *p.IPProtocol,
                                 Number:   i,
                         })
                 }
         }
         state.SortPorts(ports)
         return ports, nil
 }
 
 // TODO: following 30 lines nearly verbatim from environs/ec2
 
-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/openstack: 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/openstack: 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 (e *environ) Provider() environs.EnvironProvider {
         return &providerInstance
 }
@@ skipping 76 matching lines @@
         for _, rule := range rules {
                 rule.ParentGroupId = group.Id
                 _, err := novaClient.CreateSecurityGroupRule(rule)
                 if err != nil && !gooseerrors.IsDuplicateValue(err) {
                         return zeroGroup, err
                 }
         }
         return *group, nil
 }
 
-func (e *environ) terminateInstances(ids []state.InstanceId) error {
+func (e *environ) terminateInstances(ids []instance.Id) error {
         if len(ids) == 0 {
                 return nil
         }
         var firstErr error
         novaClient := e.nova()
         for _, id := range ids {
                 err := novaClient.DeleteServer(string(id))
                 if gooseerrors.IsNotFound(err) {
                         err = nil
                 }
                 if err != nil && firstErr == nil {
                         log.Debugf("environs/openstack: error terminating instance %q: %v", id, err)
                         firstErr = err
                 }
         }
         return firstErr
 }