func assertMeterStatusNotChanged(c *gc.C, w state.NotifyWatcher) {
select {
case <-w.Changes():
c.Fatalf("unexpected event from watcher")
case <-time.After(testing.ShortWait):
}
}
func assertMeterStatusChanged(c *gc.C, w state.NotifyWatcher) {
select {
case <-w.Changes():
case <-time.After(testing.LongWait):
c.Fatalf("expected event from watcher by now")
}
}
// WatchForRebootEvent starts a watcher to track if there is a new
// reboot request on the machines ID or any of its parents (in case we are a container).
func (r *RebootAPI) WatchForRebootEvent() (params.NotifyWatchResult, error) {
err := common.ErrPerm
var watch state.NotifyWatcher
var result params.NotifyWatchResult
if r.auth.AuthOwner(r.machine.Tag()) {
watch = r.machine.WatchForRebootEvent()
err = nil
// Consume the initial event. Technically, API
// calls to Watch 'transmit' the initial event
// in the Watch response. But NotifyWatchers
// have no state to transmit.
if _, ok := <-watch.Changes(); ok {
result.NotifyWatcherId = r.resources.Register(watch)
} else {
err = watcher.EnsureErr(watch)
}
}
result.Error = common.ServerError(err)
return result, nil
}
// NewMultiNotifyWatcher creates a NotifyWatcher that combines
// each of the NotifyWatchers passed in. Each watcher's initial
// event is consumed, and a single initial event is sent.
// Subsequent events are not coalesced.
func NewMultiNotifyWatcher(w ...state.NotifyWatcher) *MultiNotifyWatcher {
m := &MultiNotifyWatcher{
watchers: w,
changes: make(chan struct{}),
}
var wg sync.WaitGroup
wg.Add(len(w))
staging := make(chan struct{})
for _, w := range w {
// Consume the first event of each watcher.
<-w.Changes()
go func(w state.NotifyWatcher) {
defer wg.Done()
m.tomb.Kill(w.Wait())
}(w)
// Copy events from the watcher to the staging channel.
go copyEvents(staging, w.Changes(), &m.tomb)
}
go func() {
defer m.tomb.Done()
m.loop(staging)
wg.Wait()
}()
return m
}
func (s *CommonProvisionerSuite) waitForWatcher(c *gc.C, w state.NotifyWatcher, name string, check func() bool) {
// TODO(jam): We need to grow a new method on NotifyWatcherC
// that calls StartSync while waiting for changes, then
// waitMachine and waitHardwareCharacteristics can use that
// instead
defer stop(c, w)
timeout := time.After(coretesting.LongWait)
resync := time.After(0)
for {
select {
case <-w.Changes():
if check() {
return
}
case <-resync:
resync = time.After(coretesting.ShortWait)
s.BackingState.StartSync()
case <-timeout:
c.Fatalf("%v wait timed out", name)
}
}
}
func stopWatcher(c *gc.C, w state.NotifyWatcher) {
err := w.Stop()
c.Check(err, gc.IsNil)
}
