worker/apiuniter: State to API migration

worker/apiuniter/modes.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package apiuniter
 
 import (
         stderrors "errors"
         "fmt"
 
         "launchpad.net/tomb"
 
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/charm/hooks"
         "launchpad.net/juju-core/environs"
-        "launchpad.net/juju-core/errors"
-        "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/state/watcher"
         "launchpad.net/juju-core/worker"
         ucharm "launchpad.net/juju-core/worker/apiuniter/charm"
         "launchpad.net/juju-core/worker/apiuniter/hook"
 )
 
 // Mode defines the signature of the functions that implement the possible
 // states of a running Uniter.
 type Mode func(u *Uniter) (Mode, error)
 
 // ModeInit is the initial Uniter mode.
 func ModeInit(u *Uniter) (next Mode, err error) {
         defer modeContext("ModeInit", &err)()
         logger.Infof("updating unit addresses")
-        // TODO(dimitern): Once the uniter is using the API, change the
-        // following block to use st.ProviderType() instead of calling
-        // st.EnvironConfig. Also, We might be able to drop all this
-        // address stuff entirely once we have machine addresses.
-        cfg, err := u.st.EnvironConfig()
+        // TODO(dimitern): We might be able to drop all this address stuff
+        // entirely once we have machine addresses.
+        providerType, err := u.st.ProviderType()
         if err != nil {
                 return nil, err
         }
-        provider, err := environs.Provider(cfg.Type())
+        provider, err := environs.Provider(providerType)
         if err != nil {
                 return nil, err
         }
         if private, err := provider.PrivateAddress(); err != nil {
+                logger.Errorf("cannot get unit's private address: %v", err)
                 return nil, err
         } else if err = u.unit.SetPrivateAddress(private); err != nil {
+                logger.Errorf("cannot set unit's private address: %v", err)
                 return nil, err
         }
         if public, err := provider.PublicAddress(); err != nil {
+                logger.Errorf("cannot get unit's public address: %v", err)
                 return nil, err
         } else if err = u.unit.SetPublicAddress(public); err != nil {
+                logger.Errorf("cannot set unit's public address: %v", err)
                 return nil, err
         }
         logger.Infof("reconciling relation state")
         if err := u.restoreRelations(); err != nil {
                 return nil, err
         }
         return ModeContinue, nil
 }
 
 // ModeContinue determines what action to take based on persistent uniter state.
 func ModeContinue(u *Uniter) (next Mode, err error) {
         defer modeContext("ModeContinue", &err)()
 
         // If we haven't yet loaded state, do so.
         if u.s == nil {
                 logger.Infof("loading uniter state")
                 if u.s, err = u.sf.Read(); err == ErrNoStateFile {
                         // When no state exists, start from scratch.
                         logger.Infof("charm is not deployed")
-                        curl, _ := u.service.CharmURL()
+                        curl, _, err := u.service.CharmURL()
+                        if err != nil {
+                                return nil, err
+                        }
                         return ModeInstalling(curl), nil
                 } else if err != nil {
                         return nil, err
                 }
         }
 
         // Filter out states not related to charm deployment.
         switch u.s.Op {
         case Continue:
                 logger.Infof("continuing after %q hook", u.s.Hook.Kind)
@@ skipping 106 matching lines @@
         }
         return ModeContinue, nil
 }
 
 // ModeTerminating marks the unit dead and returns ErrTerminateAgent.
 func ModeTerminating(u *Uniter) (next Mode, err error) {
         defer modeContext("ModeTerminating", &err)()
         if err = u.unit.SetStatus(params.StatusStopped, ""); err != nil {
                 return nil, err
         }
-        w := u.unit.Watch()
+        w, err := u.unit.Watch()
+        if err != nil {
+                return nil, err
+        }
         defer watcher.Stop(w, &u.tomb)
         for {
                 select {
                 case <-u.tomb.Dying():
                         return nil, tomb.ErrDying
                 case _, ok := <-w.Changes():
                         if !ok {
                                 return nil, watcher.MustErr(w)
                         }
                         if err := u.unit.Refresh(); err != nil {
                                 return nil, err
                         }
-                        // TODO(dimitern): Once the uniter uses the API, call
-                        // u.unit.HasSubordinates() here instead.
-                        if len(u.unit.SubordinateNames()) > 0 {
+                        if hasSubs, err := u.unit.HasSubordinates(); err != nil {
+                                return nil, err
+                        } else if hasSubs {
                                 continue
                         }
                         // The unit is known to be Dying; so if it didn't have subordinates
                         // just above, it can't acquire new ones before this call.
                         if err := u.unit.EnsureDead(); err != nil {
                                 return nil, err
                         }
                         return nil, worker.ErrTerminateAgent
                 }
         }
@@ skipping 63 matching lines @@
                 }
         }
 }
 
 // modeAbideDyingLoop handles the proper termination of all relations in
 // response to a Dying unit.
 func modeAbideDyingLoop(u *Uniter) (next Mode, err error) {
         if err := u.unit.Refresh(); err != nil {
                 return nil, err
         }
-        // TODO(dimitern): Once the uniter uses the API, use
-        // u.unit.DestroyAllSubordinates() here, instead of going
-        // through each subordinate calling Destroy() on it.
-        for _, name := range u.unit.SubordinateNames() {
-                if sub, err := u.st.Unit(name); errors.IsNotFoundError(err) {
-                        continue
-                } else if err != nil {
-                        return nil, err
-                } else if err = sub.Destroy(); err != nil {
-                        return nil, err
-                }
+        if err = u.unit.DestroyAllSubordinates(); err != nil {
+                return nil, err
         }
         for id, r := range u.relationers {
                 if err := r.SetDying(); err != nil {
                         return nil, err
                 } else if r.IsImplicit() {
                         delete(u.relationers, id)
                 }
         }
         for {
                 if len(u.relationers) == 0 {
@@ skipping 28 matching lines @@
                 return nil, err
         }
         u.f.WantResolvedEvent()
         u.f.WantUpgradeEvent(true)
         for {
                 select {
                 case <-u.tomb.Dying():
                         return nil, tomb.ErrDying
                 case rm := <-u.f.ResolvedEvents():
                         switch rm {
-                        case state.ResolvedRetryHooks:
+                        case params.ResolvedRetryHooks:
                                 err = u.runHook(*u.s.Hook)
-                        case state.ResolvedNoHooks:
+                        case params.ResolvedNoHooks:
                                 err = u.commitHook(*u.s.Hook)
                         default:
                                 return nil, fmt.Errorf("unknown resolved mode %q", rm)
                         }
                         if e := u.f.ClearResolved(); e != nil {
                                 return nil, e
                         }
                         if err == errHookFailed {
                                 continue
                         } else if err != nil {
@@ skipping 46 matching lines @@
         logger.Infof("%s starting", name)
         return func() {
                 logger.Debugf("%s exiting", name)
                 switch *err {
                 case nil, tomb.ErrDying, worker.ErrTerminateAgent:
                 default:
                         *err = stderrors.New(name + ": " + (*err).Error())
                 }
         }
 }