state: add machine status; refractor unit status

state/machine.go

 package state
 
 import (
         "fmt"
         "labix.org/v2/mgo"
         "labix.org/v2/mgo/txn"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/state/presence"
         "launchpad.net/juju-core/trivial"
@@ skipping 41 matching lines @@
 type machineDoc struct {
         Id           string `bson:"_id"`
         Series       string
         InstanceId   InstanceId
         Principals   []string
         Life         Life
         Tools        *Tools `bson:",omitempty"`
         TxnRevno     int64  `bson:"txn-revno"`
         Jobs         []MachineJob
         PasswordHash string
+}
+
+// machineStatusDoc represents the internal state of a machine status in MongoDB.
+// The implicit _id field is explicitly set to the global key of the
+// associated machine in the document's creation transaction, but omitted to
+// allow direct use of the document in both create and update transactions.
+type machineStatusDoc struct {
+        Status     params.MachineStatus
+        StatusInfo string
 }
 
 func newMachine(st *State, doc *machineDoc) *Machine {
         machine := &Machine{
                 st:  st,
                 doc: *doc,
         }
         machine.annotator = annotator{
                 globalKey: machine.globalKey(),
                 tag:       machine.Tag(),
@@ skipping 216 matching lines @@
         if m.doc.Life != Dead {
                 return fmt.Errorf("machine is not dead")
         }
         ops := []txn.Op{
                 {
                         C:      m.st.machines.Name,
                         Id:     m.doc.Id,
                         Assert: txn.DocExists,
                         Remove: true,
                 },
+                removeStatusOp(m.st, m.globalKey()),
                 removeConstraintsOp(m.st, m.globalKey()),
                 annotationRemoveOp(m.st, m.globalKey()),
-                removeStatusOp(m.st, m),

[fwereade, 2013/04/03 11:42:34]

I don't really like the inconsistency here. IMO we should either be using
globalKeyer either a lot, or not at all... using it in just a few places doesn't
feel worth it.

[dimitern, 2013/04/03 14:29:27]

As discussed, I'm removing globalKeyer until there is a better logic behind it.

         }
         // The only abort conditions in play indicate that the machine has already
         // been removed.
         return onAbort(m.st.runner.Run(ops, "", nil), nil)
 }
 
 // Refresh refreshes the contents of the machine from the underlying
 // state. It returns an error that satisfies IsNotFound if the machine has
 // been removed.
 func (m *Machine) Refresh() error {
@@ skipping 132 matching lines @@
                 if m, err = m.st.Machine(m.doc.Id); err != nil {
                         return err
                 }
         }
         return ErrExcessiveContention
 }
 
 // Status returns the status of the machine.
 func (m *Machine) Status() (status params.MachineStatus, info string, err error) {
         doc := &machineStatusDoc{}
-        if err := getStatus(m.st, m, doc); IsNotFound(err) {
-                if err := m.Refresh(); IsNotFound(err) {
-                        return "", "", fmt.Errorf("cannot get status of machine %q: not found", m)
-                }
-                return params.MachinePending, "", nil
-        } else if err != nil {
+        if err := getStatus(m.st, m.globalKey(), doc); err != nil {
                 return "", "", err
         }
         return doc.Status, doc.StatusInfo, nil
 }
 
 // SetStatus sets the status of the machine.
 func (m *Machine) SetStatus(status params.MachineStatus, info string) error {
         if status == params.MachinePending {
                 panic("cannot set machine status to pending")
         } else if status == params.MachineError && info == "" {
                 panic("machine error status with no info")
         }
         doc := &machineStatusDoc{status, info}
         ops := []txn.Op{{
                 C:      m.st.machines.Name,
                 Id:     m.doc.Id,
                 Assert: notDeadDoc,
         },
-                setStatusOp(m.st, m, doc),
+                updateStatusOp(m.st, m.globalKey(), doc),
         }
         if err := m.st.runner.Run(ops, "", nil); err != nil {
                 return fmt.Errorf("cannot set status of machine %q: %v", m, onAbort(err, errNotAlive))
         }
         return nil
 }