func (u *UndertakerAPI) environResourceWatcher() params.NotifyWatchResult { var nothing params.NotifyWatchResult machines, err := u.st.AllMachines() if err != nil { nothing.Error = common.ServerError(err) return nothing } services, err := u.st.AllServices() if err != nil { nothing.Error = common.ServerError(err) return nothing } var watchers []state.NotifyWatcher for _, machine := range machines { watchers = append(watchers, machine.Watch()) } for _, service := range services { watchers = append(watchers, service.Watch()) } watch := common.NewMultiNotifyWatcher(watchers...) if _, ok := <-watch.Changes(); ok { return params.NotifyWatchResult{ NotifyWatcherId: u.resources.Register(watch), } } nothing.Error = common.ServerError(watcher.EnsureErr(watch)) return nothing }
// WatchBlockDevices watches for changes to the specified machines' block devices. func (s *StorageProvisionerAPI) WatchBlockDevices(args params.Entities) (params.NotifyWatchResults, error) { canAccess, err := s.getBlockDevicesAuthFunc() if err != nil { return params.NotifyWatchResults{}, common.ServerError(common.ErrPerm) } results := params.NotifyWatchResults{ Results: make([]params.NotifyWatchResult, len(args.Entities)), } one := func(arg params.Entity) (string, error) { machineTag, err := names.ParseMachineTag(arg.Tag) if err != nil { return "", err } if !canAccess(machineTag) { return "", common.ErrPerm } w := s.st.WatchBlockDevices(machineTag) if _, ok := <-w.Changes(); ok { return s.resources.Register(w), nil } return "", watcher.EnsureErr(w) } for i, arg := range args.Entities { var result params.NotifyWatchResult id, err := one(arg) if err != nil { result.Error = common.ServerError(err) } else { result.NotifyWatcherId = id } results.Results[i] = result } return results, nil }
// WatchMachineErrorRetry returns a NotifyWatcher that notifies when // the provisioner should retry provisioning machines with transient errors. func (p *ProvisionerAPI) WatchMachineErrorRetry() (params.NotifyWatchResult, error) { result := params.NotifyWatchResult{} if !p.authorizer.AuthModelManager() { return result, common.ErrPerm } watch := newWatchMachineErrorRetry() // Consume any initial event and forward it to the result. if _, ok := <-watch.Changes(); ok { result.NotifyWatcherId = p.resources.Register(watch) } else { return result, watcher.EnsureErr(watch) } return result, nil }
// WatchForModelConfigChanges returns a NotifyWatcher that observes // changes to the environment configuration. // Note that although the NotifyWatchResult contains an Error field, // it's not used because we are only returning a single watcher, // so we use the regular error return. func (e *ModelWatcher) WatchForModelConfigChanges() (params.NotifyWatchResult, error) { result := params.NotifyWatchResult{} watch := e.st.WatchForModelConfigChanges() // 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 = e.resources.Register(watch) } else { return result, watcher.EnsureErr(watch) } return result, nil }
func (api *ProxyUpdaterAPI) oneWatch() params.NotifyWatchResult { var result params.NotifyWatchResult watch := common.NewMultiNotifyWatcher( api.backend.WatchForModelConfigChanges(), api.backend.WatchAPIHostPorts()) if _, ok := <-watch.Changes(); ok { result = params.NotifyWatchResult{ NotifyWatcherId: api.resources.Register(watch), } } result.Error = common.ServerError(watcher.EnsureErr(watch)) return result }
// 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 }