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
}