Implement container lifecycle watcher

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"
@@ skipping 227 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 {
+type openstackInstance struct {
         e *environ
         *nova.ServerDetail
         address string
 }
 
-func (inst *instance) String() string {
+func (inst *openstackInstance) String() string {
         return inst.ServerDetail.Id
 }
 
-var _ environs.Instance = (*instance)(nil)
+var _ instance.Instance = (*openstackInstance)(nil)
 
-func (inst *instance) Id() state.InstanceId {
+func (inst *openstackInstance) Id() state.InstanceId {
         return state.InstanceId(inst.ServerDetail.Id)
 }
 
 // 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 {
@@ skipping 16 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 []params.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 []params.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) ([]params.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 107 matching lines @@
         })
         if err != nil {
                 return fmt.Errorf("cannot start bootstrap instance: %v", err)
         }
         err = e.saveState(&bootstrapState{
                 StateInstances: []state.InstanceId{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 44 matching lines @@
                         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, detail, ""}
         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 {
                                 // 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 {
+func (e *environ) StopInstances(insts []instance.Instance) error {
         ids := make([]state.InstanceId, 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 []state.InstanceId, out map[state.InstanceId]instance.Instance) []state.InstanceId {
         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
         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, ""}
+                                out[id] = &openstackInstance{e, &server, ""}
                         }
                         continue
                 }
                 missing = append(missing, id)
         }
         return missing
 }
 
-func (e *environ) Instances(ids []state.InstanceId) ([]environs.Instance, error) {
+func (e *environ) Instances(ids []state.InstanceId) ([]instance.Instance, error) {
         if len(ids) == 0 {
                 return nil, nil
         }
         missing := ids
-        found := make(map[state.InstanceId]environs.Instance)
+        found := make(map[state.InstanceId]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, ""})
+                        insts = append(insts, &openstackInstance{e, &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
         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 := state.InstanceId(inst.(*openstackInstance).Id())
                 if !found[id] {
                         ids = append(ids, id)
                         found[id] = true
                 }
         }
         err = e.terminateInstances(ids)
         if err != nil {
                 return err
         }
 
@@ skipping 227 matching lines @@
                 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
 }