state: simplify entity watchers

worker/uniter/filter.go

 package uniter
 
 import (
         "fmt"
         "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/watcher"
         "launchpad.net/juju-core/worker"
         "launchpad.net/tomb"
@@ skipping 174 matching lines @@
         // once we receive the initial change, we unblock discard requests by
         // setting this channel to its namesake on f.
         var discardConfig chan struct{}
         for {
                 var ok bool
                 select {
                 case <-f.tomb.Dying():
                         return tomb.ErrDying
 
                 // Handle watcher changes.
-                case f.unit, ok = <-unitw.Changes():
+                case _, ok = <-unitw.Changes():
                         log.Debugf("worker/uniter/filter: got unit change")
                         if !ok {
                                 return watcher.MustErr(unitw)
                         }
                         if err = f.unitChanged(); err != nil {
                                 return err
                         }
-                case f.service, ok = <-servicew.Changes():
+                case _, ok = <-servicew.Changes():
                         log.Debugf("worker/uniter/filter: got service change")
                         if !ok {
                                 return watcher.MustErr(servicew)
                         }
                         if err = f.serviceChanged(); err != nil {
                                 return err
                         }
                 case _, ok := <-configw.Changes():
                         log.Debugf("worker/uniter/filter: got config change")
                         if !ok {
@@ skipping 40 matching lines @@
                 case <-discardConfig:
                         log.Debugf("filter: discarded config event")
                         f.outConfig = nil
                 }
         }
         panic("unreachable")
 }
 
 // unitChanged responds to changes in the unit.
 func (f *filter) unitChanged() error {
+        if err := f.unit.Refresh(); err != nil {
+                if state.IsNotFound(err) {
+                        return worker.ErrDead
+                }
+                return err
+        }
         if f.life != f.unit.Life() {
                 switch f.life = f.unit.Life(); f.life {
                 case state.Dying:
                         log.Printf("worker/uniter: unit is dying")
                         close(f.outUnitDying)
                         f.outUpgrade = nil
                 case state.Dead:
                         log.Printf("worker/uniter: unit is dead")
                         return worker.ErrDead
                 }
         }
         if resolved := f.unit.Resolved(); resolved != f.resolved {
                 f.resolved = resolved
                 if f.resolved != state.ResolvedNone {
                         f.outResolved = f.outResolvedOn
                 }
         }
         return nil
 }
 
 // serviceChanged responds to changes in the service.
 func (f *filter) serviceChanged() error {
+        if err := f.service.Refresh(); err != nil {
+                if state.IsNotFound(err) {
+                        return fmt.Errorf("service unexpectedly removed")
+                }
+                return err
+        }
         url, force := f.service.CharmURL()
         f.upgradeAvailable = serviceCharm{url, force}
         switch f.service.Life() {
         case state.Dying:
                 if err := f.unit.EnsureDying(); err != nil {
                         return err
                 }
         case state.Dead:
                 return fmt.Errorf("service unexpectedly dead")
         }
@@ skipping 43 matching lines @@
 }
 
 // serviceCharm holds information about a charm.
 type serviceCharm struct {
         url   *charm.URL
         force bool
 }
 
 // nothing is marginally more pleasant to read than "struct{}{}".
 var nothing = struct{}{}