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()),
         }
         // 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
@@ skipping 131 matching lines @@
                 if err := m.st.runner.Run(ops, "", nil); err != txn.ErrAborted {
                         return err
                 }
                 if m, err = m.st.Machine(m.doc.Id); err != nil {
                         return err
                 }
         }
         return ErrExcessiveContention
 }
 
-// Status returns the status of the machine's agent.

[fwereade, 2013/04/02 15:33:42]

I think drop the "agent" bit.

[dimitern, 2013/04/03 09:33:00]

Done.

+// 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) {
-                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("machine status must not be set to pending")

[rog, 2013/04/02 15:29:07]

i prefer panic messages to say what went wrong rather than an instruction as to
what to do right.

for example:
panic("cannot set machine status back to pending")

[dimitern, 2013/04/03 09:33:00]

Fair enough, changed.

+                panic("cannot set machine status to pending")
         } else if status == params.MachineError && info == "" {
-                panic("must set info for machine error status")

[rog, 2013/04/02 15:29:07]

panic("machine error status with no info") ?

[dimitern, 2013/04/03 09:33:00]

Done.

+                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
 }