func (s *watcherSuite) TestWatchMachineStorage(c *gc.C) {
registry.RegisterProvider(
"envscoped",
&dummy.StorageProvider{
StorageScope: storage.ScopeEnviron,
},
)
registry.RegisterEnvironStorageProviders("dummy", "envscoped")
defer registry.RegisterProvider("envscoped", nil)
f := factory.NewFactory(s.BackingState)
f.MakeMachine(c, &factory.MachineParams{
Volumes: []state.MachineVolumeParams{{
Volume: state.VolumeParams{
Pool: "envscoped",
Size: 1024,
},
}},
})
var results params.MachineStorageIdsWatchResults
args := params.Entities{Entities: []params.Entity{{
Tag: s.State.EnvironTag().String(),
}}}
err := s.stateAPI.APICall(
"StorageProvisioner",
s.stateAPI.BestFacadeVersion("StorageProvisioner"),
"", "WatchVolumeAttachments", args, &results)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
w := watcher.NewVolumeAttachmentsWatcher(s.stateAPI, result)
select {
case changes, ok := <-w.Changes():
c.Assert(ok, jc.IsTrue)
c.Assert(changes, jc.SameContents, []params.MachineStorageId{{
MachineTag: "machine-1",
AttachmentTag: "volume-0",
}})
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for change")
}
select {
case <-w.Changes():
c.Fatalf("received unexpected change")
case <-time.After(coretesting.ShortWait):
}
statetesting.AssertStop(c, w)
select {
case _, ok := <-w.Changes():
c.Assert(ok, jc.IsFalse)
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for watcher channel to be closed")
}
}
// TODO(fwereade): 2015-11-18 lp:1517391
func (s *watcherSuite) TestWatchMachineStorage(c *gc.C) {
registry.RegisterProvider(
"envscoped",
&dummy.StorageProvider{
StorageScope: storage.ScopeEnviron,
},
)
registry.RegisterEnvironStorageProviders("dummy", "envscoped")
defer registry.RegisterProvider("envscoped", nil)
f := factory.NewFactory(s.BackingState)
f.MakeMachine(c, &factory.MachineParams{
Volumes: []state.MachineVolumeParams{{
Volume: state.VolumeParams{
Pool: "envscoped",
Size: 1024,
},
}},
})
var results params.MachineStorageIdsWatchResults
args := params.Entities{Entities: []params.Entity{{
Tag: s.State.ModelTag().String(),
}}}
err := s.stateAPI.APICall(
"StorageProvisioner",
s.stateAPI.BestFacadeVersion("StorageProvisioner"),
"", "WatchVolumeAttachments", args, &results)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
w := watcher.NewVolumeAttachmentsWatcher(s.stateAPI, result)
defer func() {
// Check we can stop the watcher...
w.Kill()
wait := make(chan error)
go func() {
wait <- w.Wait()
}()
select {
case err := <-wait:
c.Assert(err, jc.ErrorIsNil)
case <-time.After(coretesting.LongWait):
c.Fatalf("watcher never stopped")
}
// ...and that its channel hasn't been closed.
s.BackingState.StartSync()
select {
case change, ok := <-w.Changes():
c.Fatalf("watcher sent unexpected change: (%#v, %v)", change, ok)
default:
}
}()
// Check initial event;
s.BackingState.StartSync()
select {
case changes, ok := <-w.Changes():
c.Assert(ok, jc.IsTrue)
c.Assert(changes, jc.SameContents, []corewatcher.MachineStorageId{{
MachineTag: "machine-1",
AttachmentTag: "volume-0",
}})
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out waiting for change")
}
// check no subsequent event.
s.BackingState.StartSync()
select {
case <-w.Changes():
c.Fatalf("received unexpected change")
case <-time.After(coretesting.ShortWait):
}
}
