worker/uniter: fix things after new state

worker/uniter/modes.go

 package uniter
 
 import (
         "errors"
         "fmt"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/watcher"
         "launchpad.net/juju-core/worker/uniter/charm"
@@ skipping 133 matching lines @@
         if err = u.unit.SetStatus(state.UnitStarted, ""); err != nil {
                 return nil, err
         }
 
         // To begin with, only watch for config changes, and exploit the
         // guaranteed initial send to ensure we run a config-changed hook
         // before starting any other watches.
         starting := true
         configw := u.service.WatchConfig()
         defer stop(configw, &next, &err)
-        var charmw *state.ServiceCharmWatcher
-        var charms <-chan state.ServiceCharmChange
+        var servicew *state.ServiceWatcher
+        var serviceChanges <-chan *state.Service
         for {
                 select {
                 case <-u.tomb.Dying():
                         return nil, tomb.ErrDying
                 case _, ok := <-configw.Changes():
                         if !ok {
                                 return nil, watcher.MustErr(configw)
                         }
                         hi := hook.Info{Kind: hook.ConfigChanged}
                         if err = u.runHook(hi); err != nil {
                                 if err == errHookFailed {
                                         return ModeHookError, nil
                                 }
                                 return nil, err
                         }
                         if starting {
                                 // If we haven't already set up additional watches, do so now.
                                 starting = false
-                                charmw = u.service.WatchCharm()
-                                defer stop(charmw, &next, &err)
-                                charms = charmw.Changes()
+                                servicew = u.service.Watch()
+                                defer stop(servicew, &next, &err)
+                                serviceChanges = servicew.Changes()
                         }
-                case ch, ok := <-charms:
+                case service, ok := <-serviceChanges:
                         if !ok {
-                                return nil, watcher.MustErr(charmw)
+                                return nil, watcher.MustErr(servicew)
+                        }
+                        ch, _, err := service.Charm()
+                        if err != nil {
+                                return nil, err
                         }
                         url, err := charm.ReadCharmURL(u.charm)
                         if err != nil {
                                 return nil, err
                         }
-                        if *ch.Charm.URL() != *url {
-                                return ModeUpgrading(ch.Charm), nil
+                        if *ch.URL() != *url {
+                                return ModeUpgrading(ch), nil
                         }
                 }
                 // TODO: unit death; relations.
         }
         panic("unreachable")
 }
 
 // ModeHookError is responsible for watching and responding to:
 // * user resolution of hook errors
 // * forced charm upgrade requests (not implemented)
 // * unit death (not implemented)
 func ModeHookError(u *Uniter) (next Mode, err error) {
         defer errorContextf(&err, "ModeHookError")
         s, err := u.sf.Read()
         if err != nil {
                 return nil, err
         }
         if s.Op != RunHook || s.OpStep != Pending {
                 return nil, fmt.Errorf("insane uniter state: %#v", s)
         }
         msg := fmt.Sprintf("hook failed: %q", s.Hook.Kind)
         if err = u.unit.SetStatus(state.UnitError, msg); err != nil {
                 return nil, err
         }
 
         // Wait for shutdown, error resolution, or forced charm upgrade.
-        resolvedw := u.unit.WatchResolved()
-        defer stop(resolvedw, &next, &err)
-        charmw := u.service.WatchCharm()
-        defer stop(charmw, &next, &err)
+        unitw := u.unit.Watch()
+        defer stop(unitw, &next, &err)
+        servicew := u.service.Watch()
+        defer stop(servicew, &next, &err)
         for {
                 select {
                 case <-u.tomb.Dying():
                         return nil, tomb.ErrDying
-                case rm, ok := <-resolvedw.Changes():
+                case unit, ok := <-unitw.Changes():
+                        // TODO: unit death.
                         if !ok {
-                                return nil, watcher.MustErr(resolvedw)
+                                return nil, watcher.MustErr(unitw)
                         }
-                        switch rm {
+                        switch unit.Resolved() {
                         case state.ResolvedNone:
                                 continue
                         case state.ResolvedRetryHooks:
                                 err = u.runHook(*s.Hook)
                         case state.ResolvedNoHooks:
                                 err = u.commitHook(*s.Hook)
                         default:
-                                panic(fmt.Errorf("unhandled resolved mode %q", rm))
+                                panic(fmt.Errorf("unhandled resolved mode %q", unit.Resolved()))
                         }
-                        if e := u.unit.ClearResolved(); e != nil {
+                        if e := unit.ClearResolved(); e != nil {
                                 err = e
                         }
                         if err == errHookFailed {
                                 continue
                         } else if err != nil {
                                 return nil, err
                         }
                         return ModeContinue, nil
-                case ch, ok := <-charmw.Changes():
+                case service, ok := <-servicew.Changes():
                         if !ok {
-                                return nil, watcher.MustErr(charmw)
+                                return nil, watcher.MustErr(servicew)
+                        }
+                        ch, force, err := service.Charm()
+                        if err != nil {
+                                return nil, err
                         }
                         url, err := charm.ReadCharmURL(u.charm)
                         if err != nil {
                                 return nil, err
                         }
-                        if ch.Force && *ch.Charm.URL() != *url {
-                                return ModeUpgrading(ch.Charm), nil
+                        if force && *ch.URL() != *url {
+                                return ModeUpgrading(ch), nil
                         }
                 }
-                // TODO: unit death.
         }
         panic("unreachable")
 }
 
 // ModeUpgrading is responsible for upgrading the charm.
 func ModeUpgrading(sch *state.Charm) Mode {
         return func(u *Uniter) (Mode, error) {
                 log.Printf("upgrading charm to %q", sch.URL())
                 if err := u.deploy(sch, Upgrade); err != nil {
                         if err == charm.ErrConflict {
@@ skipping 67 matching lines @@
 }
 
 // errorContextf prefixes the error stored in err with text formatted
 // according to the format specifier. If err does not contain an error,
 // or if err is tomb.ErrDying, errorContextf does nothing.
 func errorContextf(err *error, format string, args ...interface{}) {
         if *err != nil && *err != tomb.ErrDying {
                 *err = errors.New(fmt.Sprintf(format, args...) + ": " + (*err).Error())
         }
 }