state, machiner: new style principal units watcher

state/unit.go

 package state
 
 import (
         "errors"
         "fmt"
         "labix.org/v2/mgo"
         "labix.org/v2/mgo/txn"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/state/presence"
         "launchpad.net/juju-core/trivial"
@@ skipping 386 matching lines @@
 // It returns the started pinger.
 func (u *Unit) SetAgentAlive() (*presence.Pinger, error) {
         p := presence.NewPinger(u.st.presence, u.globalKey())
         err := p.Start()
         if err != nil {
                 return nil, err
         }
         return p, nil
 }
 
-// IsAssignedTo returns whether u is a principal assigned to machine m.
-// It panics if u is not a principal unit.
-func (u *Unit) IsAssignedTo(m *Machine) bool {

[rog, 2012/11/09 09:08:08]

is this necessary? can't we just use AssignedMachineId instead?

[aram, 2012/11/09 16:50:08]

It was impossible to use the previous version of AssignedMachineId, but I fixed
that function instead to return usable errors and I deleted this.

-        if !u.IsPrincipal() {
-                panic("unit is not a principal")
-        }
-        return u.doc.MachineId != nil && *u.doc.MachineId == m.doc.Id
+// notAssignedError represents the error that a unit is not assigned.
+type notAssignedError struct {
+        msg string
+}
+
+func (e *notAssignedError) Error() string {
+        return e.msg
+}
+
+func notAssigned(format string, args ...interface{}) error {
+        return &notAssignedError{fmt.Sprintf(format+" is not assigned to a machine", args...)}

[niemeyer, 2012/11/14 23:34:08]

Pre-req has a missing test?  It should have a test actually expecting the
NotAssignedError suggested there.

+}
+
+func IsNotAssigned(err error) bool {
+        _, ok := err.(*notAssignedError)
+        return ok
 }
 
 // AssignedMachineId returns the id of the assigned machine.
 func (u *Unit) AssignedMachineId() (id int, err error) {
-        defer trivial.ErrorContextf(&err, "cannot get machine id of unit %q", u)
         if u.IsPrincipal() {
                 if u.doc.MachineId == nil {
-                        return 0, errors.New("unit not assigned to machine")
+                        return 0, notAssigned("unit %q", u)
                 }
                 return *u.doc.MachineId, nil
         }
         pudoc := unitDoc{}
         err = u.st.units.Find(D{{"_id", u.doc.Principal}}).One(&pudoc)
-        if err != nil {
-                return 0, err
+        if err == mgo.ErrNotFound {
+                return 0, notFound("cannot get machine id of unit %q: principal %q %v", u, u.doc.Principal)
+        }
+        if err != nil {
+                return 0, fmt.Errorf("cannot get machine id of unit %q: %v", u, err)
         }
         if pudoc.MachineId == nil {
-                return 0, errors.New("unit not assigned to machine")
+                return 0, notAssigned("unit %q", u)
         }
         return *pudoc.MachineId, nil
 }
 
 var (
         machineDeadErr     = errors.New("machine is dead")
         unitDeadErr        = errors.New("unit is dead")
         alreadyAssignedErr = errors.New("unit is already assigned to a machine")
         inUseErr           = errors.New("machine is not unused")
 )
@@ skipping 223 matching lines @@
                 return p1.Protocol < p2.Protocol
         }
         return p1.Number < p2.Number
 }
 
 // SortPorts sorts the given ports, first by protocol,
 // then by number.
 func SortPorts(ports []Port) {
         sort.Sort(portSlice(ports))
 }