func (p *ProvisionerAPI) watchOneMachineContainers(arg params.WatchContainer) (params.StringsWatchResult, error) {
nothing := params.StringsWatchResult{}
canAccess, err := p.getAuthFunc()
if err != nil {
return nothing, common.ErrPerm
}
tag, err := names.ParseMachineTag(arg.MachineTag)
if err != nil {
return nothing, common.ErrPerm
}
if !canAccess(tag) {
return nothing, common.ErrPerm
}
machine, err := p.st.Machine(tag.Id())
if err != nil {
return nothing, err
}
var watch state.StringsWatcher
if arg.ContainerType != "" {
watch = machine.WatchContainers(instance.ContainerType(arg.ContainerType))
} else {
watch = machine.WatchAllContainers()
}
// Consume the initial event and forward it to the result.
if changes, ok := <-watch.Changes(); ok {
return params.StringsWatchResult{
StringsWatcherId: p.resources.Register(watch),
Changes: changes,
}, nil
}
return nothing, watcher.EnsureErr(watch)
}
func assertChange(c *gc.C, w state.StringsWatcher) {
select {
case <-w.Changes():
return
case <-time.After(coretesting.LongWait):
c.Fatalf("no changes on watcher")
}
}
func (s *StorageProvisionerAPI) watchAttachments(
args params.Entities,
watchEnvironAttachments func() state.StringsWatcher,
watchMachineAttachments func(names.MachineTag) state.StringsWatcher,
parseAttachmentIds func([]string) ([]params.MachineStorageId, error),
) (params.MachineStorageIdsWatchResults, error) {
canAccess, err := s.getScopeAuthFunc()
if err != nil {
return params.MachineStorageIdsWatchResults{}, common.ServerError(common.ErrPerm)
}
results := params.MachineStorageIdsWatchResults{
Results: make([]params.MachineStorageIdsWatchResult, len(args.Entities)),
}
one := func(arg params.Entity) (string, []params.MachineStorageId, 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 = watchMachineAttachments(tag)
} else {
w = watchEnvironAttachments()
}
if stringChanges, ok := <-w.Changes(); ok {
changes, err := parseAttachmentIds(stringChanges)
if err != nil {
w.Stop()
return "", nil, err
}
return s.resources.Register(w), changes, nil
}
return "", nil, watcher.EnsureErr(w)
}
for i, arg := range args.Entities {
var result params.MachineStorageIdsWatchResult
id, changes, err := one(arg)
if err != nil {
result.Error = common.ServerError(err)
} else {
result.MachineStorageIdsWatcherId = id
result.Changes = changes
}
results.Results[i] = result
}
return results, nil
}