state: deprecate JobManageState

state/machine.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state
 
 import (
         "fmt"
         "strings"
         "time"
 
@@ skipping 131 matching lines @@
 
 // globalKey returns the global database key for the machine.
 func (m *Machine) globalKey() string {
         return machineGlobalKey(m.doc.Id)
 }
 
 // instanceData holds attributes relevant to a provisioned machine.
 type instanceData struct {
         Id         string      `bson:"_id"`
         InstanceId instance.Id `bson:"instanceid"`
+        Status     string      `bson:"status,omitempty"`
         Arch       *string     `bson:"arch,omitempty"`
         Mem        *uint64     `bson:"mem,omitempty"`
         RootDisk   *uint64     `bson:"rootdisk,omitempty"`
         CpuCores   *uint64     `bson:"cpucores,omitempty"`
         CpuPower   *uint64     `bson:"cpupower,omitempty"`
         Tags       *[]string   `bson:"tags,omitempty"`
 }
 
 // TODO(wallyworld): move this method to a service.
 func (m *Machine) HardwareCharacteristics() (*instance.HardwareCharacteristics, error) {
@@ skipping 33 matching lines @@
 // Life returns whether the machine is Alive, Dying or Dead.
 func (m *Machine) Life() Life {
         return m.doc.Life
 }
 
 // Jobs returns the responsibilities that must be fulfilled by m's agent.
 func (m *Machine) Jobs() []MachineJob {
         return m.doc.Jobs
 }
 
 // IsManager returns true if the machine has JJobManageEnviron.

[mue, 2014/01/24 13:05:51]

s/JJobManageEnviron/JobManageEnviron

[rog, 2014/01/24 13:10:35]

I've fixed that in a downstream branch; will leave alone here to save the
recommit effort, if that's ok.

[dimitern, 2014/01/24 13:31:38]

As long as it doesn't land like this eventually..

 func (m *Machine) IsManager() bool {
         for _, job := range m.doc.Jobs {
                 switch job {
                 case JobManageEnviron:
                         return true
                 }
         }
         return false
 }
 
@@ skipping 388 matching lines @@
 // InstanceId returns the provider specific instance id for this
 // machine, or a NotProvisionedError, if not set.
 func (m *Machine) InstanceId() (instance.Id, error) {
         // SCHEMACHANGE
         // TODO(wallyworld) - remove this backward compatibility code when schema upgrades are possible
         // (we first check for InstanceId stored on the machineDoc)
         if m.doc.InstanceId != "" {
                 return m.doc.InstanceId, nil
         }
         instData, err := getInstanceData(m.st, m.Id())
-        if (err == nil && instData.InstanceId == "") || (err != nil && errors.IsNotFoundError(err)) {
+        if (err == nil && instData.InstanceId == "") || errors.IsNotFoundError(err) {
                 err = NotProvisionedError(m.Id())
         }
         if err != nil {
                 return "", err
         }
         return instData.InstanceId, nil
+}
+
+// InstanceStatus returns the provider specific instance status for this machine,
+// or a NotProvisionedError if instance is not yet provisioned.
+func (m *Machine) InstanceStatus() (string, error) {
+        // SCHEMACHANGE
+        // InstanceId may not be stored in the instanceData doc, so we
+        // get it using an API on machine which knows to look in the old
+        // place if necessary.
+        instId, err := m.InstanceId()
+        if err != nil {
+                return "", err
+        }
+        instData, err := getInstanceData(m.st, m.Id())
+        if (err == nil && instId == "") || errors.IsNotFoundError(err) {
+                err = NotProvisionedError(m.Id())
+        }
+        if err != nil {
+                return "", err
+        }
+        return instData.Status, nil
+}
+
+// SetInstanceStatus sets the provider specific instance status for a machine.
+func (m *Machine) SetInstanceStatus(status string) (err error) {
+        defer utils.ErrorContextf(&err, "cannot set instance status for machine %q", m)
+
+        // SCHEMACHANGE - we can't do this yet until the schema is updated
+        // so just do a txn.DocExists for now.
+        // provisioned := D{{"instanceid", D{{"$ne", ""}}}}
+        ops := []txn.Op{
+                {
+                        C:      m.st.instanceData.Name,
+                        Id:     m.doc.Id,
+                        Assert: txn.DocExists,
+                        Update: D{{"$set", D{{"status", status}}}},
+                },
+        }
+
+        if err = m.st.runTransaction(ops); err == nil {
+                return nil
+        } else if err != txn.ErrAborted {
+                return err
+        }
+        return NotProvisionedError(m.Id())
 }
 
 // Units returns all the units that have been assigned to the machine.
 func (m *Machine) Units() (units []*Unit, err error) {
         defer utils.ErrorContextf(&err, "cannot get units assigned to machine %v", m)
         pudocs := []unitDoc{}
         err = m.st.units.Find(D{{"machineid", m.doc.Id}}).All(&pudocs)
         if err != nil {
                 return nil, err
         }
@@ skipping 22 matching lines @@
 func (m *Machine) SetProvisioned(id instance.Id, nonce string, characteristics *instance.HardwareCharacteristics) (err error) {
         defer utils.ErrorContextf(&err, "cannot set instance data for machine %q", m)
 
         if id == "" || nonce == "" {
                 return fmt.Errorf("instance id and nonce cannot be empty")
         }
 
         if characteristics == nil {
                 characteristics = &instance.HardwareCharacteristics{}
         }
-        hc := &instanceData{
+        instData := &instanceData{
                 Id:         m.doc.Id,
                 InstanceId: id,
                 Arch:       characteristics.Arch,
                 Mem:        characteristics.Mem,
                 RootDisk:   characteristics.RootDisk,
                 CpuCores:   characteristics.CpuCores,
                 CpuPower:   characteristics.CpuPower,
                 Tags:       characteristics.Tags,
         }
         // SCHEMACHANGE
         // TODO(wallyworld) - do not check instanceId on machineDoc after schema is upgraded
         notSetYet := D{{"instanceid", ""}, {"nonce", ""}}
         ops := []txn.Op{
                 {
                         C:      m.st.machines.Name,
                         Id:     m.doc.Id,
                         Assert: append(isAliveDoc, notSetYet...),
                         Update: D{{"$set", D{{"instanceid", id}, {"nonce", nonce}}}},
                 }, {
                         C:      m.st.instanceData.Name,
                         Id:     m.doc.Id,
                         Assert: txn.DocMissing,
-                        Insert: hc,
+                        Insert: instData,
                 },
         }
 
         if err = m.st.runTransaction(ops); err == nil {
                 m.doc.Nonce = nonce
                 // SCHEMACHANGE
                 // TODO(wallyworld) - remove this backward compatibility code when schema upgrades are possible
                 // (InstanceId is stored on the instanceData document but we duplicate the value on the machineDoc.
                 m.doc.InstanceId = id
                 return nil
@@ skipping 274 matching lines @@
                                 containerType := ContainerTypeFromId(containerId)
                                 container.SetStatus(
                                         params.StatusError, "unsupported container", params.StatusData{"type": containerType})
                         } else {
                                 logger.Errorf("unsupported container %v has unexpected status %v", containerId, status)
                         }
                 }
         }
         return nil
 }