// WatchEnvironMachines returns a StringsWatcher that notifies of
// changes to the life cycles of the top level machines in the current
// environment.
func (e *EnvironMachinesWatcher) WatchEnvironMachines() (params.StringsWatchResult, error) {
result := params.StringsWatchResult{}
if !e.authorizer.AuthEnvironManager() {
return result, ErrPerm
}
watch := e.st.WatchEnvironMachines()
// Consume the initial event and forward it to the result.
if changes, ok := <-watch.Changes(); ok {
result.StringsWatcherId = e.resources.Register(watch)
result.Changes = changes
} else {
err := watcher.EnsureErr(watch)
return result, fmt.Errorf("cannot obtain initial environment machines: %v", err)
}
return result, nil
}
func (s *StorageProvisionerAPI) watchStorageEntities(
args params.Entities,
watchEnvironStorage func() state.StringsWatcher,
watchMachineStorage func(names.MachineTag) state.StringsWatcher,
) (params.StringsWatchResults, error) {
canAccess, err := s.getScopeAuthFunc()
if err != nil {
return params.StringsWatchResults{}, common.ServerError(common.ErrPerm)
}
results := params.StringsWatchResults{
Results: make([]params.StringsWatchResult, len(args.Entities)),
}
one := func(arg params.Entity) (string, []string, error) {
tag, err := names.ParseTag(arg.Tag)
if err != nil || !canAccess(tag) {
return "", nil, common.ErrPerm
}
var w state.StringsWatcher
if tag, ok := tag.(names.MachineTag); ok {
w = watchMachineStorage(tag)
} else {
w = watchEnvironStorage()
}
if changes, ok := <-w.Changes(); ok {
return s.resources.Register(w), changes, nil
}
return "", nil, watcher.EnsureErr(w)
}
for i, arg := range args.Entities {
var result params.StringsWatchResult
id, changes, err := one(arg)
if err != nil {
result.Error = common.ServerError(err)
} else {
result.StringsWatcherId = id
result.Changes = changes
}
results.Results[i] = result
}
return results, nil
}
