func (s *deployerSuite) TestWatchUnits(c *gc.C) {
machine, err := s.st.Machine(s.machine.Tag())
c.Assert(err, gc.IsNil)
w, err := machine.WatchUnits()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange("mysql/0", "logging/0")
wc.AssertNoChange()
// Change something other than the lifecycle and make sure it's
// not detected.
err = s.subordinate.SetPassword("foo")
c.Assert(err, gc.ErrorMatches, "password is only 3 bytes long, and is not a valid Agent password")
wc.AssertNoChange()
err = s.subordinate.SetPassword("foo-12345678901234567890")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the subordinate dead and check it's detected.
err = s.subordinate.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertChange("logging/0")
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *RelationUnitSuite) TestPeerWatchScope(c *gc.C) {
pr := NewPeerRelation(c, s.State)
// Test empty initial event.
w0 := pr.ru0.WatchScope()
defer testing.AssertStop(c, w0)
s.assertScopeChange(c, w0, nil, nil)
s.assertNoScopeChange(c, w0)
// ru0 enters; check no change, but settings written.
assertNotInScope(c, pr.ru0)
err := pr.ru0.EnterScope(map[string]interface{}{"foo": "bar"})
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
node, err := pr.ru0.Settings()
c.Assert(err, gc.IsNil)
c.Assert(node.Map(), gc.DeepEquals, map[string]interface{}{"foo": "bar"})
assertJoined(c, pr.ru0)
// ru1 enters; check change is observed.
assertNotInScope(c, pr.ru1)
err = pr.ru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, []string{"riak/1"}, nil)
s.assertNoScopeChange(c, w0)
assertJoined(c, pr.ru1)
// ru1 enters again, check no problems and no changes.
err = pr.ru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
assertJoined(c, pr.ru1)
// Stop watching; ru2 enters.
testing.AssertStop(c, w0)
assertNotInScope(c, pr.ru2)
err = pr.ru2.EnterScope(nil)
c.Assert(err, gc.IsNil)
assertJoined(c, pr.ru2)
// Start watch again, check initial event.
w0 = pr.ru0.WatchScope()
defer testing.AssertStop(c, w0)
s.assertScopeChange(c, w0, []string{"riak/1", "riak/2"}, nil)
s.assertNoScopeChange(c, w0)
// ru1 leaves; check event.
assertJoined(c, pr.ru1)
err = pr.ru1.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, nil, []string{"riak/1"})
s.assertNoScopeChange(c, w0)
assertNotInScope(c, pr.ru1)
// ru1 leaves again; check no problems and no changes.
err = pr.ru1.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
assertNotInScope(c, pr.ru1)
}
func (s *machineSuite) TestWatchUnits(c *gc.C) {
w, err := s.apiMachine.WatchUnits()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange("wordpress/0")
wc.AssertNoChange()
// Change something other than the life cycle and make sure it's
// not detected.
err = s.machines[0].SetPassword("foo")
c.Assert(err, gc.ErrorMatches, "password is only 3 bytes long, and is not a valid Agent password")
wc.AssertNoChange()
err = s.machines[0].SetPassword("foo-12345678901234567890")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Unassign unit 0 from the machine and check it's detected.
err = s.units[0].UnassignFromMachine()
c.Assert(err, gc.IsNil)
wc.AssertChange("wordpress/0")
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *stateSuite) TestWatchEnvironMachines(c *gc.C) {
w, err := s.firewaller.WatchEnvironMachines()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewStringsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange(s.machines[0].Id(), s.machines[1].Id(), s.machines[2].Id())
// Add another machine make sure they are detected.
otherMachine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
wc.AssertChange(otherMachine.Id())
// Change the life cycle of last machine.
err = otherMachine.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertChange(otherMachine.Id())
// Add a container and make sure it's not detected.
template := state.MachineTemplate{
Series: "quantal",
Jobs: []state.MachineJob{state.JobHostUnits},
}
_, err = s.State.AddMachineInsideMachine(template, s.machines[0].Id(), instance.LXC)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *unitSuite) TestWatch(c *gc.C) {
c.Assert(s.apiUnit.Life(), gc.Equals, params.Alive)
w, err := s.apiUnit.Watch()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Change something other than the life cycle and make sure it's
// not detected.
err = s.units[0].SetStatus(params.StatusStarted, "not really", nil)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the unit dead and check it's detected.
err = s.units[0].EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *APIAddresserTests) TestWatchAPIHostPorts(c *gc.C) {
expectServerAddrs := [][]instance.HostPort{{{
Address: instance.NewAddress("0.1.2.3", instance.NetworkUnknown),
Port: 1234,
}}}
err := s.state.SetAPIHostPorts(expectServerAddrs)
c.Assert(err, gc.IsNil)
w, err := s.facade.WatchAPIHostPorts()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.state, w)
// Initial event.
wc.AssertOneChange()
// Change the state addresses and check that we get a notification
expectServerAddrs[0][0].Value = "0.1.99.99"
err = s.state.SetAPIHostPorts(expectServerAddrs)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *firewallerSuite) TestWatchUnits(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[0].Tag()},
}})
result, err := s.firewaller.WatchUnits(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{Changes: []string{"wordpress/0"}, StringsWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
c.Assert(result.Results[0].StringsWatcherId, gc.Equals, "1")
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewStringsWatcherC(c, s.State, resource.(state.StringsWatcher))
wc.AssertNoChange()
}
func (s *RelationUnitSuite) TestCoalesceWatchScope(c *gc.C) {
pr := NewPeerRelation(c, s.State)
// Test empty initial event.
w0 := pr.ru0.WatchScope()
defer testing.AssertStop(c, w0)
s.assertScopeChange(c, w0, nil, nil)
s.assertNoScopeChange(c, w0)
// ru1 and ru2 enter; check changes observed together.
err := pr.ru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
err = pr.ru2.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, []string{"riak/1", "riak/2"}, nil)
s.assertNoScopeChange(c, w0)
// ru1 leaves and re-enters; check no change observed.
err = pr.ru1.LeaveScope()
c.Assert(err, gc.IsNil)
err = pr.ru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
// ru1 and ru2 leave; check changes observed together.
err = pr.ru1.LeaveScope()
c.Assert(err, gc.IsNil)
err = pr.ru2.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, nil, []string{"riak/1", "riak/2"})
s.assertNoScopeChange(c, w0)
}
func (s *FilterSuite) TestServiceDeath(c *gc.C) {
f, err := newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
dyingAsserter := coretesting.NotifyAsserterC{
C: c,
Precond: func() { s.BackingState.StartSync() },
Chan: f.UnitDying(),
}
dyingAsserter.AssertNoReceive()
err = s.unit.SetStatus(params.StatusStarted, "", nil)
c.Assert(err, gc.IsNil)
err = s.wordpress.Destroy()
c.Assert(err, gc.IsNil)
timeout := time.After(coretesting.LongWait)
loop:
for {
select {
case <-f.UnitDying():
break loop
case <-time.After(coretesting.ShortWait):
s.BackingState.StartSync()
case <-timeout:
c.Fatalf("dead not detected")
}
}
err = s.unit.Refresh()
c.Assert(err, gc.IsNil)
c.Assert(s.unit.Life(), gc.Equals, state.Dying)
// Can't set s.wordpress to Dead while it still has units.
}
func (s *machinerSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: "machine-1"},
{Tag: "machine-0"},
{Tag: "machine-42"},
}}
result, err := s.machiner.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
c.Assert(result.Results[0].NotifyWatcherId, gc.Equals, "1")
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc := statetesting.NewNotifyWatcherC(c, s.State, resource.(state.NotifyWatcher))
wc.AssertNoChange()
}
func (s *authorisedKeysSuite) TestWatchAuthorisedKeys(c *gc.C) {
args := params.Entities{
Entities: []params.Entity{
{Tag: s.rawMachine.Tag()},
{Tag: s.unrelatedMachine.Tag()},
{Tag: "machine-42"},
},
}
results, err := s.keyupdater.WatchAuthorisedKeys(args)
c.Assert(err, gc.IsNil)
c.Assert(results, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
c.Assert(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
c.Assert(results.Results[0].Error, gc.IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Assert(resource, gc.NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
s.setAuthorizedKeys(c, "key1\nkey2")
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *unitSuite) TestWatchConfigSettings(c *gc.C) {
// Make sure WatchConfigSettings returns an error when
// no charm URL is set, as its state counterpart does.
w, err := s.apiUnit.WatchConfigSettings()
c.Assert(err, gc.ErrorMatches, "unit charm not set")
// Now set the charm and try again.
err = s.apiUnit.SetCharmURL(s.wordpressCharm.URL())
c.Assert(err, gc.IsNil)
w, err = s.apiUnit.WatchConfigSettings()
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Update config a couple of times, check a single event.
err = s.wordpressService.UpdateConfigSettings(charm.Settings{
"blog-title": "superhero paparazzi",
})
c.Assert(err, gc.IsNil)
err = s.wordpressService.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Non-change is not reported.
err = s.wordpressService.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// NOTE: This test is not as exhaustive as the one in state,
// because the watcher is already tested there. Here we just
// ensure we get the events when we expect them and don't get
// them when they're not expected.
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *unitUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawUnit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event
wc.AssertOneChange()
vers := version.MustParseBinary("10.20.34-quantal-amd64")
err = s.rawMachine.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
// One change noticing the new version
wc.AssertOneChange()
vers = version.MustParseBinary("10.20.35-quantal-amd64")
err = s.rawMachine.SetAgentVersion(vers)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *keyupdaterSuite) TestWatchAuthorisedKeys(c *gc.C) {
watcher, err := s.keyupdater.WatchAuthorisedKeys(s.rawMachine.Tag())
c.Assert(err, gc.IsNil)
defer testing.AssertStop(c, watcher)
wc := testing.NewNotifyWatcherC(c, s.BackingState, watcher)
// Initial event
wc.AssertOneChange()
s.setAuthorisedKeys(c, "key1\nkey2")
// One change noticing the new version
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
s.setAuthorisedKeys(c, "key1\nkey2")
wc.AssertNoChange()
s.setAuthorisedKeys(c, "key1\nkey2\nkey3")
wc.AssertOneChange()
testing.AssertStop(c, watcher)
wc.AssertClosed()
}
func (s *relationUnitSuite) TestWatchRelationUnits(c *gc.C) {
// Enter scope with mysqlUnit.
myRelUnit, err := s.stateRelation.Unit(s.mysqlUnit)
c.Assert(err, gc.IsNil)
err = myRelUnit.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertInScope(c, myRelUnit, true)
apiRel, err := s.uniter.Relation(s.stateRelation.Tag())
c.Assert(err, gc.IsNil)
apiUnit, err := s.uniter.Unit("unit-wordpress-0")
c.Assert(err, gc.IsNil)
apiRelUnit, err := apiRel.Unit(apiUnit)
c.Assert(err, gc.IsNil)
w, err := apiRelUnit.Watch()
defer statetesting.AssertStop(c, w)
wc := statetesting.NewRelationUnitsWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertChange([]string{"mysql/0"}, nil)
// Leave scope with mysqlUnit, check it's detected.
err = myRelUnit.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertInScope(c, myRelUnit, false)
wc.AssertChange(nil, []string{"mysql/0"})
// Non-change is not reported.
err = myRelUnit.LeaveScope()
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// NOTE: This test is not as exhaustive as the one in state,
// because the watcher is already tested there. Here we just
// ensure we get the events when we expect them and don't get
// them when they're not expected.
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *firewallerSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := addFakeEntities(params.Entities{Entities: []params.Entity{
{Tag: s.machines[0].Tag()},
{Tag: s.service.Tag()},
{Tag: s.units[0].Tag()},
}})
result, err := s.firewaller.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, jc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{Error: apiservertesting.ErrUnauthorized},
{NotifyWatcherId: "1"},
{NotifyWatcherId: "2"},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.NotFoundError(`unit "foo/0"`)},
{Error: apiservertesting.NotFoundError(`service "bar"`)},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resources were registered and stop when done.
c.Assert(s.resources.Count(), gc.Equals, 2)
c.Assert(result.Results[1].NotifyWatcherId, gc.Equals, "1")
watcher1 := s.resources.Get("1")
defer statetesting.AssertStop(c, watcher1)
c.Assert(result.Results[2].NotifyWatcherId, gc.Equals, "2")
watcher2 := s.resources.Get("2")
defer statetesting.AssertStop(c, watcher2)
// Check that the Watch has consumed the initial event ("returned" in
// the Watch call)
wc1 := statetesting.NewNotifyWatcherC(c, s.State, watcher1.(state.NotifyWatcher))
wc1.AssertNoChange()
wc2 := statetesting.NewNotifyWatcherC(c, s.State, watcher2.(state.NotifyWatcher))
wc2.AssertNoChange()
}
func (s *FilterSuite) TestResolvedEvents(c *gc.C) {
f, err := newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
resolvedAsserter := coretesting.ContentAsserterC{
C: c,
Precond: func() { s.BackingState.StartSync() },
Chan: f.ResolvedEvents(),
}
resolvedAsserter.AssertNoReceive()
// Request an event; no interesting event is available.
f.WantResolvedEvent()
resolvedAsserter.AssertNoReceive()
// Change the unit in an irrelevant way; no events.
err = s.unit.SetStatus(params.StatusError, "blarg", nil)
c.Assert(err, gc.IsNil)
resolvedAsserter.AssertNoReceive()
// Change the unit's resolved to an interesting value; new event received.
err = s.unit.SetResolved(state.ResolvedRetryHooks)
c.Assert(err, gc.IsNil)
assertChange := func(expect params.ResolvedMode) {
rm := resolvedAsserter.AssertOneReceive().(params.ResolvedMode)
c.Assert(rm, gc.Equals, expect)
}
assertChange(params.ResolvedRetryHooks)
// Ask for the event again, and check it's resent.
f.WantResolvedEvent()
assertChange(params.ResolvedRetryHooks)
// Clear the resolved status *via the filter*; check not resent...
err = f.ClearResolved()
c.Assert(err, gc.IsNil)
resolvedAsserter.AssertNoReceive()
// ...even when requested.
f.WantResolvedEvent()
resolvedAsserter.AssertNoReceive()
// Induce several events; only latest state is reported.
err = s.unit.SetResolved(state.ResolvedRetryHooks)
c.Assert(err, gc.IsNil)
err = f.ClearResolved()
c.Assert(err, gc.IsNil)
err = s.unit.SetResolved(state.ResolvedNoHooks)
c.Assert(err, gc.IsNil)
assertChange(params.ResolvedNoHooks)
}
func (s *EnvironWatcherTests) TestWatchForEnvironConfigChanges(c *gc.C) {
envConfig, err := s.state.EnvironConfig()
c.Assert(err, gc.IsNil)
w, err := s.facade.WatchForEnvironConfigChanges()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.state, w)
// Initial event.
wc.AssertOneChange()
// Change the environment configuration by updating an existing attribute, check it's detected.
newAttrs := map[string]interface{}{"logging-config": "juju=ERROR"}
err = s.state.UpdateEnvironConfig(newAttrs, nil, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Change the environment configuration by adding a new attribute, check it's detected.
newAttrs = map[string]interface{}{"foo": "bar"}
err = s.state.UpdateEnvironConfig(newAttrs, nil, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Change the environment configuration by removing an attribute, check it's detected.
err = s.state.UpdateEnvironConfig(map[string]interface{}{}, []string{"foo"}, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Change it back to the original config.
oldAttrs := map[string]interface{}{"logging-config": envConfig.AllAttrs()["logging-config"]}
err = s.state.UpdateEnvironConfig(oldAttrs, nil, nil)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *machineUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
w, err := s.st.WatchAPIVersion(s.rawMachine.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event
wc.AssertOneChange()
vers := version.MustParse("10.20.34")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
// One change noticing the new version
wc.AssertOneChange()
// Setting the version to the same value doesn't trigger a change
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
vers = version.MustParse("10.20.35")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *serviceSuite) TestWatch(c *gc.C) {
c.Assert(s.apiService.Life(), gc.Equals, params.Alive)
w, err := s.apiService.Watch()
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, w)
wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w)
// Initial event.
wc.AssertOneChange()
// Change something and check it's detected.
err = s.service.SetExposed()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
// Destroy the service and check it's detected.
err = s.service.Destroy()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *RelationUnitSuite) TestPrepareLeaveScope(c *gc.C) {
prr := NewProReqRelation(c, &s.ConnSuite, charm.ScopeGlobal)
// Test empty initial event.
w0 := prr.pru0.WatchScope()
defer testing.AssertStop(c, w0)
s.assertScopeChange(c, w0, nil, nil)
s.assertNoScopeChange(c, w0)
// rru0 and rru1 enter; check changes.
err := prr.rru0.EnterScope(nil)
c.Assert(err, gc.IsNil)
err = prr.rru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, []string{"wordpress/0", "wordpress/1"}, nil)
s.assertNoScopeChange(c, w0)
// rru0 notifies that it will leave soon; it's reported as departed by the
// watcher, but InScope remains accurate.
err = prr.rru0.PrepareLeaveScope()
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, nil, []string{"wordpress/0"})
s.assertNoScopeChange(c, w0)
assertInScope(c, prr.rru0)
assertNotJoined(c, prr.rru0)
// rru1 leaves, and the relation is destroyed; it's not removed, because
// rru0 keeps it alive until it really leaves scope.
err = prr.rru1.LeaveScope()
c.Assert(err, gc.IsNil)
s.assertScopeChange(c, w0, nil, []string{"wordpress/1"})
s.assertNoScopeChange(c, w0)
err = prr.rel.Destroy()
c.Assert(err, gc.IsNil)
err = prr.rel.Refresh()
c.Assert(err, gc.IsNil)
// rru0 really leaves; the relation is cleaned up.
err = prr.rru0.LeaveScope()
c.Assert(err, gc.IsNil)
err = prr.rel.Destroy()
c.Assert(err, gc.IsNil)
s.assertNoScopeChange(c, w0)
err = prr.rel.Refresh()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (s *UpgraderSuite) TestUpgraderSetsTools(c *gc.C) {
vers := version.MustParseBinary("5.4.3-precise-amd64")
err := statetesting.SetAgentVersion(s.State, vers.Number)
c.Assert(err, gc.IsNil)
stor := s.Conn.Environ.Storage()
agentTools := envtesting.PrimeTools(c, stor, s.DataDir(), vers)
s.PatchValue(&version.Current, agentTools.Version)
err = envtools.MergeAndWriteMetadata(stor, coretools.List{agentTools}, envtools.DoNotWriteMirrors)
_, err = s.machine.AgentTools()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
u := s.makeUpgrader()
statetesting.AssertStop(c, u)
s.machine.Refresh()
gotTools, err := s.machine.AgentTools()
c.Assert(err, gc.IsNil)
envtesting.CheckTools(c, gotTools, agentTools)
}
func (s *EnvironWatcherTest) TestWatchForEnvironConfigChanges(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
result, err := s.envWatcher.WatchForEnvironConfigChanges()
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResult{
NotifyWatcherId: "1",
})
// Verify the resources were registered and stop them when done.
c.Assert(s.resources.Count(), gc.Equals, 1)
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned"
// in the Watch call)
wc := statetesting.NewNotifyWatcherC(c, s.st, resource.(state.NotifyWatcher))
wc.AssertNoChange()
}
func (s *UpgraderSuite) TestUpgraderSetVersion(c *gc.C) {
vers := version.MustParseBinary("5.4.3-precise-amd64")
agentTools := envtesting.PrimeTools(c, s.Conn.Environ.Storage(), s.DataDir(), vers)
s.PatchValue(&version.Current, agentTools.Version)
err := os.RemoveAll(filepath.Join(s.DataDir(), "tools"))
c.Assert(err, gc.IsNil)
_, err = s.machine.AgentTools()
c.Assert(err, jc.Satisfies, errors.IsNotFound)
err = statetesting.SetAgentVersion(s.State, vers.Number)
c.Assert(err, gc.IsNil)
u := s.makeUpgrader()
statetesting.AssertStop(c, u)
s.machine.Refresh()
gotTools, err := s.machine.AgentTools()
c.Assert(err, gc.IsNil)
c.Assert(gotTools, gc.DeepEquals, &coretools.Tools{Version: version.Current})
}
func (s *unitUpgraderSuite) TestWatchAPIVersion(c *gc.C) {
args := params.Entities{
Entities: []params.Entity{{Tag: s.rawUnit.Tag()}},
}
results, err := s.upgrader.WatchAPIVersion(args)
c.Assert(err, gc.IsNil)
c.Check(results.Results, gc.HasLen, 1)
c.Check(results.Results[0].NotifyWatcherId, gc.Not(gc.Equals), "")
c.Check(results.Results[0].Error, gc.IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Check(resource, gc.NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
err = s.rawMachine.SetAgentVersion(version.MustParseBinary("3.4.567.8-quantal-amd64"))
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *firewallerSuite) TestWatchEnvironMachines(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
got, err := s.firewaller.WatchEnvironMachines()
c.Assert(err, gc.IsNil)
want := params.StringsWatchResult{
StringsWatcherId: "1",
Changes: []string{"0", "1", "2"},
}
c.Assert(got.StringsWatcherId, gc.Equals, want.StringsWatcherId)
c.Assert(got.Changes, jc.SameContents, want.Changes)
// Verify the resources were registered and stop them when done.
c.Assert(s.resources.Count(), gc.Equals, 1)
resource := s.resources.Get("1")
defer statetesting.AssertStop(c, resource)
// Check that the Watch has consumed the initial event ("returned"
// in the Watch call)
wc := statetesting.NewStringsWatcherC(c, s.State, resource.(state.StringsWatcher))
wc.AssertNoChange()
}
func (s *FilterSuite) TestRelationsEvents(c *gc.C) {
f, err := newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
assertNoChange := func() {
s.BackingState.StartSync()
select {
case ids := <-f.RelationsEvents():
c.Fatalf("unexpected relations event %#v", ids)
case <-time.After(coretesting.ShortWait):
}
}
assertNoChange()
// Add a couple of relations; check the event.
rel0 := s.addRelation(c)
rel1 := s.addRelation(c)
assertChange := func(expect []int) {
s.BackingState.StartSync()
select {
case got := <-f.RelationsEvents():
c.Assert(got, gc.DeepEquals, expect)
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out")
}
assertNoChange()
}
assertChange([]int{0, 1})
// Add another relation, and change another's Life (by entering scope before
// Destroy, thereby setting the relation to Dying); check event.
s.addRelation(c)
ru0, err := rel0.Unit(s.unit)
c.Assert(err, gc.IsNil)
err = ru0.EnterScope(nil)
c.Assert(err, gc.IsNil)
err = rel0.Destroy()
c.Assert(err, gc.IsNil)
assertChange([]int{0, 2})
// Remove a relation completely; check no event, because the relation
// could not have been removed if the unit was in scope, and therefore
// the uniter never needs to hear about it.
err = rel1.Destroy()
c.Assert(err, gc.IsNil)
assertNoChange()
err = f.Stop()
c.Assert(err, gc.IsNil)
// Start a new filter, check initial event.
f, err = newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
assertChange([]int{0, 2})
// Check setting the charm URL generates all new relation events.
err = f.SetCharm(s.wpcharm.URL())
c.Assert(err, gc.IsNil)
assertChange([]int{0, 2})
}
func (s *FilterSuite) TestConfigEvents(c *gc.C) {
f, err := newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
// Test no changes before the charm URL is set.
assertNoChange := func() {
s.BackingState.StartSync()
select {
case <-f.ConfigEvents():
c.Fatalf("unexpected config event")
case <-time.After(coretesting.ShortWait):
}
}
assertNoChange()
// Set the charm URL to trigger config events.
err = f.SetCharm(s.wpcharm.URL())
c.Assert(err, gc.IsNil)
assertChange := func() {
s.BackingState.StartSync()
select {
case _, ok := <-f.ConfigEvents():
c.Assert(ok, gc.Equals, true)
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out")
}
assertNoChange()
}
assertChange()
// Change the config; new event received.
changeConfig := func(title interface{}) {
err := s.wordpress.UpdateConfigSettings(charm.Settings{
"blog-title": title,
})
c.Assert(err, gc.IsNil)
}
changeConfig("20,000 leagues in the cloud")
assertChange()
// Change the config a few more times, then reset the events. We sync to
// make sure the events have arrived in the watcher -- and then wait a
// little longer, to allow for the delay while the events are coalesced
// -- before we tell it to discard all received events. This would be
// much better tested by controlling a mocked-out watcher directly, but
// that's a bit inconvenient for this change.
changeConfig(nil)
changeConfig("the curious incident of the dog in the cloud")
s.BackingState.StartSync()
time.Sleep(250 * time.Millisecond)
f.DiscardConfigEvent()
assertNoChange()
// Check that a filter's initial event works with DiscardConfigEvent
// as expected.
f, err = newFilter(s.uniter, s.unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
s.BackingState.StartSync()
f.DiscardConfigEvent()
assertNoChange()
// Further changes are still collapsed as appropriate.
changeConfig("forsooth")
changeConfig("imagination failure")
assertChange()
}
func (s *FilterSuite) TestCharmUpgradeEvents(c *gc.C) {
oldCharm := s.AddTestingCharm(c, "upgrade1")
svc := s.AddTestingService(c, "upgradetest", oldCharm)
unit, err := svc.AddUnit()
c.Assert(err, gc.IsNil)
s.APILogin(c, unit)
f, err := newFilter(s.uniter, unit.Tag())
c.Assert(err, gc.IsNil)
defer statetesting.AssertStop(c, f)
// No initial event is sent.
assertNoChange := func() {
s.BackingState.StartSync()
select {
case sch := <-f.UpgradeEvents():
c.Fatalf("unexpected %#v", sch)
case <-time.After(coretesting.ShortWait):
}
}
assertNoChange()
// Setting a charm generates no new events if it already matches.
err = f.SetCharm(oldCharm.URL())
c.Assert(err, gc.IsNil)
assertNoChange()
// Explicitly request an event relative to the existing state; nothing.
f.WantUpgradeEvent(false)
assertNoChange()
// Change the service in an irrelevant way; no events.
err = svc.SetExposed()
c.Assert(err, gc.IsNil)
assertNoChange()
// Change the service's charm; new event received.
newCharm := s.AddTestingCharm(c, "upgrade2")
err = svc.SetCharm(newCharm, false)
c.Assert(err, gc.IsNil)
assertChange := func(url *charm.URL) {
s.BackingState.StartSync()
select {
case upgradeCharm := <-f.UpgradeEvents():
c.Assert(upgradeCharm, gc.DeepEquals, url)
case <-time.After(coretesting.LongWait):
c.Fatalf("timed out")
}
}
assertChange(newCharm.URL())
assertNoChange()
// Request a new upgrade *unforced* upgrade event, we should see one.
f.WantUpgradeEvent(false)
assertChange(newCharm.URL())
assertNoChange()
// Request only *forced* upgrade events; nothing.
f.WantUpgradeEvent(true)
assertNoChange()
// But when we have a forced upgrade to the same URL, no new event.
err = svc.SetCharm(oldCharm, true)
c.Assert(err, gc.IsNil)
assertNoChange()
// ...but a *forced* change to a different URL should generate an event.
err = svc.SetCharm(newCharm, true)
assertChange(newCharm.URL())
assertNoChange()
}
func (s *WatchScopeSuite) TestProviderRequirerGlobal(c *gc.C) {
// Create a pair of services and a relation between them.
mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
mysqlEP, err := mysql.Endpoint("server")
c.Assert(err, gc.IsNil)
wordpress := s.AddTestingService(c, "wordpress", s.AddTestingCharm(c, "wordpress"))
wordpressEP, err := wordpress.Endpoint("db")
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(mysqlEP, wordpressEP)
c.Assert(err, gc.IsNil)
// Add some units to the services and set their private addresses.
addUnit := func(srv *state.Service, sub string, ep state.Endpoint) *state.RelationUnit {
unit, err := srv.AddUnit()
c.Assert(err, gc.IsNil)
ru, err := rel.Unit(unit)
c.Assert(err, gc.IsNil)
c.Assert(ru.Endpoint(), gc.Equals, ep)
return ru
}
msru0 := addUnit(mysql, "ms0", mysqlEP)
msru1 := addUnit(mysql, "ms1", mysqlEP)
wpru0 := addUnit(wordpress, "wp0", wordpressEP)
wpru1 := addUnit(wordpress, "wp1", wordpressEP)
// ---------- Single role active ----------
// Watch the relation from the perspective of the first provider unit and
// check initial event.
msw0 := msru0.Watch()
defer testing.AssertStop(c, msw0)
msw0c := testing.NewRelationUnitsWatcherC(c, s.State, msw0)
msw0c.AssertChange(nil, nil)
msw0c.AssertNoChange()
// Join the unit to the relation, change its settings, and check that
// nothing apparently happens.
err = msru0.EnterScope(nil)
c.Assert(err, gc.IsNil)
changeSettings(c, msru0)
msw0c.AssertNoChange()
// Join the second provider unit, start its watch, and check what it thinks the
// state of the relation is.
err = msru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
msw1 := msru1.Watch()
defer testing.AssertStop(c, msw1)
msw1c := testing.NewRelationUnitsWatcherC(c, s.State, msw1)
msw1c.AssertChange(nil, nil)
msw1c.AssertNoChange()
// Change the unit's settings, and check that neither provider unit
// observes any change.
changeSettings(c, msru1)
msw1c.AssertNoChange()
msw0c.AssertNoChange()
// ---------- Two roles active ----------
// Start watches from both requirer units' perspectives, and check that
// they see the provider units.
expectChanged := []string{"mysql/0", "mysql/1"}
wpw0 := wpru0.Watch()
defer testing.AssertStop(c, wpw0)
wpw0c := testing.NewRelationUnitsWatcherC(c, s.State, wpw0)
wpw0c.AssertChange(expectChanged, nil)
wpw0c.AssertNoChange()
wpw1 := wpru1.Watch()
defer testing.AssertStop(c, wpw1)
wpw1c := testing.NewRelationUnitsWatcherC(c, s.State, wpw1)
wpw1c.AssertChange(expectChanged, nil)
wpw1c.AssertNoChange()
// Join the first requirer unit, and check the provider units see it.
err = wpru0.EnterScope(nil)
c.Assert(err, gc.IsNil)
expectChanged = []string{"wordpress/0"}
msw0c.AssertChange(expectChanged, nil)
msw0c.AssertNoChange()
msw1c.AssertChange(expectChanged, nil)
msw1c.AssertNoChange()
// Join again, check no-op.
err = wpru0.EnterScope(nil)
c.Assert(err, gc.IsNil)
msw0c.AssertNoChange()
msw1c.AssertNoChange()
// Join the second requirer, and check the provider units see the change.
err = wpru1.EnterScope(nil)
c.Assert(err, gc.IsNil)
expectChanged = []string{"wordpress/1"}
msw0c.AssertChange(expectChanged, nil)
msw0c.AssertNoChange()
msw1c.AssertChange(expectChanged, nil)
msw1c.AssertNoChange()
// Verify that neither requirer has observed any change to the relation.
wpw0c.AssertNoChange()
wpw1c.AssertNoChange()
// Change settings for the first requirer, check providers see it...
changeSettings(c, wpru0)
expectChanged = []string{"wordpress/0"}
msw0c.AssertChange(expectChanged, nil)
msw0c.AssertNoChange()
msw1c.AssertChange(expectChanged, nil)
msw1c.AssertNoChange()
// ...and requirers don't.
wpw0c.AssertNoChange()
wpw1c.AssertNoChange()
// Depart the second requirer and check the providers see it...
err = wpru1.LeaveScope()
c.Assert(err, gc.IsNil)
expectDeparted := []string{"wordpress/1"}
msw0c.AssertChange(nil, expectDeparted)
msw0c.AssertNoChange()
msw1c.AssertChange(nil, expectDeparted)
msw1c.AssertNoChange()
// ...and the requirers don't.
wpw0c.AssertNoChange()
wpw1c.AssertNoChange()
// Cleanup handled by defers as before.
}