environs/state: simplify watcher implementation

state/watcher/watcher.go

 package watcher
 
 import (
         "fmt"
         "launchpad.net/gozk/zookeeper"
         "launchpad.net/tomb"
 )
 
 // ErrStopper is implemented by all watchers.
 type ErrStopper interface {
@@ skipping 28 matching lines @@
         Exists  bool
         Version int
         Content string
 }
 
 // ContentWatcher observes a ZooKeeper node and delivers a
 // notification when a content change is detected.
 type ContentWatcher struct {
         zk           *zookeeper.Conn
         path         string
-        tomb         tomb.Tomb
         changeChan   chan ContentChange
         emittedValue bool
         content      ContentChange
+        err error
+        stop <-chan struct{}
 }
 
 // NewContentWatcher creates a ContentWatcher observing
 // the ZooKeeper node at watchedPath.
-func NewContentWatcher(zk *zookeeper.Conn, watchedPath string) *ContentWatcher {
+func NewContentWatcher(zk *zookeeper.Conn, watchedPath string, stop <-chan struct{}) *ContentWatcher {
         w := &ContentWatcher{
                 zk:         zk,
                 path:       watchedPath,
                 changeChan: make(chan ContentChange),
+                stop: stop,
         }
         go w.loop()
         return w
 }
 
 // Changes returns a channel that will receive the new node
 // content when a change is detected. Note that multiple
 // changes may be observed as a single event in the channel.
 // The first event on the channel holds the initial state.
 func (w *ContentWatcher) Changes() <-chan ContentChange {
         return w.changeChan
 }
 
-// Dying returns a channel that is closed when the
-// watcher has stopped or is about to stop.
-func (w *ContentWatcher) Dying() <-chan struct{} {
-        return w.tomb.Dying()
-}
-
-// Err returns the error that stopped the watcher, or
-// tomb.ErrStillAlive if the watcher is still running.
-func (w *ContentWatcher) Err() error {
-        return w.tomb.Err()
-}
-
-// Stop stops the watch and returns any error encountered
-// while watching. This method should always be called before
-// discarding the watcher.
-func (w *ContentWatcher) Stop() error {
-        w.tomb.Kill(nil)
-        return w.tomb.Wait()
+// Wait reads all remaining changes and returns
+// any error the watcher encounted while running.
+func (w *ContentWatcher) Wait() error {
+        for _ = range w.changeChan {
+        }
+        return w.err
 }
 
 // loop is the backend for watching.
 func (w *ContentWatcher) loop() {
-        defer w.tomb.Done()
         defer close(w.changeChan)
 
         watch, err := w.update()
         if err != nil {
-                w.tomb.Kill(err)
+                w.err = err
                 return
         }
 
         for {
                 select {
-                case <-w.tomb.Dying():
+                case <-w.stop:
                         return
                 case evt := <-watch:
                         if !evt.Ok() {
-                                w.tomb.Killf("watcher: critical session event: %v", evt)
+                                w.err = fmt.Errorf("watcher: critical session event: %v", evt)
                                 return
                         }
                         watch, err = w.update()
                         if err != nil {
-                                w.tomb.Kill(err)
+                                w.err = err
                                 return
                         }
                 }
         }
 }
 
 // update retrieves the node content and emits it as well as an existence
 // flag to the change channel if it has changed. It returns the next watch.
 func (w *ContentWatcher) update() (nextWatch <-chan zookeeper.Event, err error) {
         var content string
@@ skipping 24 matching lines @@
         newContent := ContentChange{}
         if stat != nil {
                 newContent.Exists = true
                 newContent.Version = stat.Version()
                 newContent.Content = content
         }
         if w.emittedValue && newContent == w.content {
                 return nextWatch, nil
         }
         w.content = newContent
-        select {
-        case <-w.tomb.Dying():
-                return nil, tomb.ErrDying
-        case w.changeChan <- w.content:
-                w.emittedValue = true
-        }
+        w.changeChan <- w.content
+        w.emittedValue = true
         return nextWatch, nil
 }
 
 // ChildrenChange contains information about
 // children that have been added or removed.
 type ChildrenChange struct {
         Added   []string
         Removed []string
 }
 
@@ skipping 124 matching lines @@
                 return
         }
         select {
         case <-w.tomb.Dying():
                 return nil, tomb.ErrDying
         case w.changeChan <- change:
                 w.emittedValue = true
         }
         return
 }