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.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 *machinerSuite) TestWatch(c *gc.C) {
machine, err := s.machiner.Machine("machine-0")
c.Assert(err, gc.IsNil)
c.Assert(machine.Life(), gc.Equals, params.Alive)
w, err := machine.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 lifecycle and make sure it's
// not detected.
err = machine.SetStatus(params.StatusStarted, "not really")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the machine dead and check it's detected.
err = machine.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *ServiceSuite) TestWatchService(c *C) {
w := s.mysql.Watch()
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Make one change (to a separate instance), check one event.
service, err := s.State.Service(s.mysql.Name())
c.Assert(err, IsNil)
err = service.SetExposed()
c.Assert(err, IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = service.ClearExposed()
c.Assert(err, IsNil)
err = service.SetCharm(s.charm, true)
c.Assert(err, IsNil)
wc.AssertOneChange()
// Stop, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Remove service, start new watch, check single event.
err = service.Destroy()
c.Assert(err, IsNil)
w = s.mysql.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
func (s *uniterSuite) TestWatch(c *gc.C) {
unit, err := s.uniter.Unit("unit-wordpress-0")
c.Assert(err, gc.IsNil)
c.Assert(unit.Life(), gc.Equals, params.Alive)
w, err := unit.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 lifecycle and make sure it's
// not detected.
err = unit.SetStatus(params.StatusStarted, "not really")
c.Assert(err, gc.IsNil)
wc.AssertNoChange()
// Make the unit dead and check it's detected.
err = unit.EnsureDead()
c.Assert(err, gc.IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *RelationUnitSuite) TestContainerWatchScope(c *C) {
prr := NewProReqRelation(c, &s.ConnSuite, charm.ScopeContainer)
// Test empty initial events for all RUs.
ws := prr.watches()
for _, w := range ws {
defer testing.AssertStop(c, w)
}
for _, w := range ws {
s.assertScopeChange(c, w, nil, nil)
}
s.assertNoScopeChange(c, ws...)
// pru0 enters; check detected only by same-container req.
err := prr.pru0.EnterScope(nil)
c.Assert(err, IsNil)
s.assertScopeChange(c, ws[2], []string{"mysql/0"}, nil)
s.assertNoScopeChange(c, ws...)
// req1 enters; check detected only by same-container pro.
err = prr.rru1.EnterScope(nil)
c.Assert(err, IsNil)
s.assertScopeChange(c, ws[1], []string{"logging/1"}, nil)
s.assertNoScopeChange(c, ws...)
// Stop watches; remaining RUs enter scope.
for _, w := range ws {
testing.AssertStop(c, w)
}
err = prr.pru1.EnterScope(nil)
c.Assert(err, IsNil)
err = prr.rru0.EnterScope(nil)
c.Assert(err, IsNil)
// Start new watches, check initial events.
ws = prr.watches()
for _, w := range ws {
defer testing.AssertStop(c, w)
}
s.assertScopeChange(c, ws[0], []string{"logging/0"}, nil)
s.assertScopeChange(c, ws[1], []string{"logging/1"}, nil)
s.assertScopeChange(c, ws[2], []string{"mysql/0"}, nil)
s.assertScopeChange(c, ws[3], []string{"mysql/1"}, nil)
s.assertNoScopeChange(c, ws...)
// pru0 leaves; check detected only by same-container req.
err = prr.pru0.LeaveScope()
c.Assert(err, IsNil)
s.assertScopeChange(c, ws[2], nil, []string{"mysql/0"})
s.assertNoScopeChange(c, ws...)
// rru0 leaves; check detected only by same-container pro.
err = prr.rru0.LeaveScope()
c.Assert(err, IsNil)
s.assertScopeChange(c, ws[0], nil, []string{"logging/0"})
s.assertNoScopeChange(c, ws...)
}
func (s *RelationUnitSuite) TestPeerWatchScope(c *C) {
pr := NewPeerRelation(c, &s.ConnSuite)
// 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.
err := pr.ru0.EnterScope(map[string]interface{}{"foo": "bar"})
c.Assert(err, IsNil)
s.assertNoScopeChange(c, w0)
node, err := pr.ru0.Settings()
c.Assert(err, IsNil)
c.Assert(node.Map(), DeepEquals, map[string]interface{}{"foo": "bar"})
// ru1 enters; check change is observed.
err = pr.ru1.EnterScope(nil)
c.Assert(err, IsNil)
s.assertScopeChange(c, w0, []string{"riak/1"}, nil)
s.assertNoScopeChange(c, w0)
// ru1 enters again, check no problems and no changes.
err = pr.ru1.EnterScope(nil)
c.Assert(err, IsNil)
s.assertNoScopeChange(c, w0)
// Stop watching; ru2 enters.
testing.AssertStop(c, w0)
err = pr.ru2.EnterScope(nil)
c.Assert(err, IsNil)
// 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.
err = pr.ru1.LeaveScope()
c.Assert(err, IsNil)
s.assertScopeChange(c, w0, nil, []string{"riak/1"})
s.assertNoScopeChange(c, w0)
// ru1 leaves again; check no problems and no changes.
err = pr.ru1.LeaveScope()
c.Assert(err, IsNil)
s.assertNoScopeChange(c, w0)
}
func (s *deployerSuite) TestWatchUnits(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.deployer.WatchUnits(args)
c.Assert(err, gc.IsNil)
sort.Strings(result.Results[0].Changes)
c.Assert(result, gc.DeepEquals, params.StringsWatchResults{
Results: []params.StringsWatchResult{
{Changes: []string{"logging/0", "mysql/0"}, StringsWatcherId: "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].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 *uniterSuite) TestWatch(c *gc.C) {
c.Assert(s.resources.Count(), gc.Equals, 0)
args := params.Entities{Entities: []params.Entity{
{Tag: "unit-mysql-0"},
{Tag: "unit-wordpress-0"},
{Tag: "unit-foo-42"},
}}
result, err := s.uniter.Watch(args)
c.Assert(err, gc.IsNil)
c.Assert(result, gc.DeepEquals, params.NotifyWatchResults{
Results: []params.NotifyWatchResult{
{Error: apiservertesting.ErrUnauthorized},
{NotifyWatcherId: "1"},
{Error: apiservertesting.ErrUnauthorized},
},
})
// Verify the resource was registered and stop when done
c.Assert(s.resources.Count(), gc.Equals, 1)
c.Assert(result.Results[1].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 *watcherSuite) TestWatchUnitsKeepsEvents(c *gc.C) {
// Create two services, relate them, and add one unit to each - a
// principal and a subordinate.
mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
c.Assert(err, gc.IsNil)
logging, err := s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
c.Assert(err, gc.IsNil)
eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
c.Assert(err, gc.IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, gc.IsNil)
principal, err := mysql.AddUnit()
c.Assert(err, gc.IsNil)
err = principal.AssignToMachine(s.rawMachine)
c.Assert(err, gc.IsNil)
relUnit, err := rel.Unit(principal)
c.Assert(err, gc.IsNil)
err = relUnit.EnterScope(nil)
c.Assert(err, gc.IsNil)
subordinate, err := logging.Unit("logging/0")
c.Assert(err, gc.IsNil)
// Call the Deployer facade's WatchUnits for machine-0.
var results params.StringsWatchResults
args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}}
err = s.stateAPI.Call("Deployer", "", "WatchUnits", args, &results)
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
// Start a StringsWatcher and check the initial event.
w := watcher.NewStringsWatcher(s.stateAPI, result)
wc := statetesting.NewStringsWatcherC(c, s.State, w)
wc.AssertChange("mysql/0", "logging/0")
wc.AssertNoChange()
// Now, without reading any changes advance the lifecycle of both
// units, inducing an update server-side after each two changes to
// ensure they're reported as separate events over the API.
err = subordinate.EnsureDead()
c.Assert(err, gc.IsNil)
s.BackingState.Sync()
err = subordinate.Remove()
c.Assert(err, gc.IsNil)
err = principal.EnsureDead()
c.Assert(err, gc.IsNil)
s.BackingState.Sync()
// Expect these changes as 2 separate events, so that
// nothing gets lost.
wc.AssertChange("logging/0")
wc.AssertChange("mysql/0")
wc.AssertNoChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *MachineSuite) TestWatchMachine(c *C) {
w := s.machine.Watch()
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Make one change (to a separate instance), check one event.
machine, err := s.State.Machine(s.machine.Id())
c.Assert(err, IsNil)
err = machine.SetProvisioned("m-foo", "fake_nonce", nil)
c.Assert(err, IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = machine.SetAgentTools(&tools.Tools{
URL: "foo",
Binary: version.MustParseBinary("0.0.3-series-arch"),
})
c.Assert(err, IsNil)
err = machine.Destroy()
c.Assert(err, IsNil)
wc.AssertOneChange()
// Stop, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Remove machine, start new watch, check single event.
err = machine.EnsureDead()
c.Assert(err, IsNil)
err = machine.Remove()
c.Assert(err, IsNil)
w = s.machine.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
func (s *upgraderSuite) TestWatchAPIVersion(c *C) {
w, err := s.st.WatchAPIVersion(s.rawMachine.Tag())
c.Assert(err, 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, 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, IsNil)
wc.AssertNoChange()
vers = version.MustParse("10.20.35")
err = statetesting.SetAgentVersion(s.BackingState, vers)
c.Assert(err, IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *UnitSuite) TestWatchUnit(c *C) {
preventUnitDestroyRemove(c, s.unit)
w := s.unit.Watch()
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Make one change (to a separate instance), check one event.
unit, err := s.State.Unit(s.unit.Name())
c.Assert(err, IsNil)
err = unit.SetPublicAddress("example.foobar.com")
c.Assert(err, IsNil)
wc.AssertOneChange()
// Make two changes, check one event.
err = unit.SetPrivateAddress("example.foobar")
c.Assert(err, IsNil)
err = unit.Destroy()
c.Assert(err, IsNil)
wc.AssertOneChange()
// Stop, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Remove unit, start new watch, check single event.
err = unit.EnsureDead()
c.Assert(err, IsNil)
err = unit.Remove()
c.Assert(err, IsNil)
w = s.unit.Watch()
defer testing.AssertStop(c, w)
testing.NewNotifyWatcherC(c, s.State, w).AssertOneChange()
}
func (s *UpgraderSuite) TestUpgraderSetsTools(c *gc.C) {
vers := version.MustParseBinary("5.4.3-foo-bar")
err := statetesting.SetAgentVersion(s.State, vers.Number)
c.Assert(err, gc.IsNil)
agentTools := s.primeTools(c, vers)
_, err = s.machine.AgentTools()
c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
u := upgrader.New(s.state.Upgrader(), s.machine.Tag(), s.DataDir())
statetesting.AssertStop(c, u)
s.machine.Refresh()
gotTools, err := s.machine.AgentTools()
c.Assert(err, gc.IsNil)
c.Assert(gotTools, gc.DeepEquals, agentTools)
}
func (s *watcherSuite) TestWatchMachine(c *gc.C) {
var results params.NotifyWatchResults
args := params.Entities{Entities: []params.Entity{{Tag: s.rawMachine.Tag()}}}
err := s.stateAPI.Call("Machiner", "", "Watch", args, &results)
c.Assert(err, gc.IsNil)
c.Assert(results.Results, gc.HasLen, 1)
result := results.Results[0]
c.Assert(result.Error, gc.IsNil)
// params.NotifyWatcher conforms to the state.NotifyWatcher interface
w := watcher.NewNotifyWatcher(s.stateAPI, result)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *ServiceSuite) TestWatchUnitsLifecycle(c *C) {
// Empty initial event when no units.
w := s.mysql.WatchUnits()
defer testing.AssertStop(c, w)
wc := testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChange()
wc.AssertNoChange()
// Create one unit, check one change.
quick, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
wc.AssertChange(quick.Name())
wc.AssertNoChange()
// Destroy that unit (short-circuited to removal), check one change.
err = quick.Destroy()
c.Assert(err, IsNil)
wc.AssertChange(quick.Name())
wc.AssertNoChange()
// Create another, check one change.
slow, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
wc.AssertChange(slow.Name())
wc.AssertNoChange()
// Change unit itself, no change.
preventUnitDestroyRemove(c, slow)
wc.AssertNoChange()
// Make unit Dying, change detected.
err = slow.Destroy()
c.Assert(err, IsNil)
wc.AssertChange(slow.Name())
wc.AssertNoChange()
// Make unit Dead, change detected.
err = slow.EnsureDead()
c.Assert(err, IsNil)
wc.AssertChange(slow.Name())
wc.AssertNoChange()
// Remove unit, final change not detected.
err = slow.Remove()
c.Assert(err, IsNil)
wc.AssertNoChange()
}
func (s *UnitSuite) TestWatchConfigSettings(c *C) {
err := s.unit.SetCharmURL(s.charm.URL())
c.Assert(err, IsNil)
w, err := s.unit.WatchConfigSettings()
c.Assert(err, IsNil)
defer testing.AssertStop(c, w)
// Initial event.
wc := testing.NewNotifyWatcherC(c, s.State, w)
wc.AssertOneChange()
// Update config a couple of times, check a single event.
err = s.service.UpdateConfigSettings(charm.Settings{
"blog-title": "superhero paparazzi",
})
c.Assert(err, IsNil)
err = s.service.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, IsNil)
wc.AssertOneChange()
// Non-change is not reported.
err = s.service.UpdateConfigSettings(charm.Settings{
"blog-title": "sauceror central",
})
c.Assert(err, IsNil)
wc.AssertNoChange()
// Change service's charm; nothing detected.
newCharm := s.AddConfigCharm(c, "wordpress", floatConfig, 123)
err = s.service.SetCharm(newCharm, false)
c.Assert(err, IsNil)
wc.AssertNoChange()
// Change service config for new charm; nothing detected.
err = s.service.UpdateConfigSettings(charm.Settings{
"key": 42.0,
})
c.Assert(err, IsNil)
wc.AssertNoChange()
// NOTE: if we were to change the unit to use the new charm, we'd see
// another event, because the originally-watched document will become
// unreferenced and be removed. But I'm not testing that behaviour
// because it's not very helpful and subject to change.
}
func (s *ServiceSuite) TestWatchUnitsBulkEvents(c *C) {
// Alive unit...
alive, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
// Dying unit...
dying, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
preventUnitDestroyRemove(c, dying)
err = dying.Destroy()
c.Assert(err, IsNil)
// Dead unit...
dead, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
preventUnitDestroyRemove(c, dead)
err = dead.Destroy()
c.Assert(err, IsNil)
err = dead.EnsureDead()
c.Assert(err, IsNil)
// Gone unit.
gone, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
err = gone.Destroy()
c.Assert(err, IsNil)
// All except gone unit are reported in initial event.
w := s.mysql.WatchUnits()
defer testing.AssertStop(c, w)
wc := testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChange(alive.Name(), dying.Name(), dead.Name())
wc.AssertNoChange()
// Remove them all; alive/dying changes reported; dead never mentioned again.
err = alive.Destroy()
c.Assert(err, IsNil)
err = dying.EnsureDead()
c.Assert(err, IsNil)
err = dying.Remove()
c.Assert(err, IsNil)
err = dead.Remove()
c.Assert(err, IsNil)
wc.AssertChange(alive.Name(), dying.Name())
wc.AssertNoChange()
}
func (s *UpgraderSuite) TestUpgraderSetToolsEvenWithNoToolsToRead(c *gc.C) {
vers := version.MustParseBinary("5.4.3-foo-bar")
s.primeTools(c, vers)
err := os.RemoveAll(filepath.Join(s.DataDir(), "tools"))
c.Assert(err, gc.IsNil)
_, err = s.machine.AgentTools()
c.Assert(err, jc.Satisfies, errors.IsNotFoundError)
err = statetesting.SetAgentVersion(s.State, vers.Number)
c.Assert(err, gc.IsNil)
u := upgrader.New(s.state.Upgrader(), s.machine.Tag(), s.DataDir())
statetesting.AssertStop(c, u)
s.machine.Refresh()
gotTools, err := s.machine.AgentTools()
c.Assert(err, gc.IsNil)
c.Assert(gotTools, gc.DeepEquals, &tools.Tools{Version: version.Current})
}
func (s *upgraderSuite) TestWatchAPIVersion(c *C) {
args := params.Entities{
Entities: []params.Entity{{Tag: s.rawMachine.Tag()}},
}
results, err := s.upgrader.WatchAPIVersion(args)
c.Assert(err, IsNil)
c.Check(results.Results, HasLen, 1)
c.Check(results.Results[0].NotifyWatcherId, Not(Equals), "")
c.Check(results.Results[0].Error, IsNil)
resource := s.resources.Get(results.Results[0].NotifyWatcherId)
c.Check(resource, NotNil)
w := resource.(state.NotifyWatcher)
wc := statetesting.NewNotifyWatcherC(c, s.State, w)
wc.AssertNoChange()
err = statetesting.SetAgentVersion(s.State, version.MustParse("3.4.567.8"))
c.Assert(err, IsNil)
wc.AssertOneChange()
statetesting.AssertStop(c, w)
wc.AssertClosed()
}
func (s *MachineSuite) TestWatchUnits(c *C) {
// Start a watch on an empty machine; check no units reported.
w := s.machine.WatchUnits()
defer testing.AssertStop(c, w)
wc := testing.NewLaxStringsWatcherC(c, s.State, w)
wc.AssertChange()
wc.AssertNoChange()
// Change machine; no change.
err := s.machine.SetProvisioned("cheese", "fake_nonce", nil)
c.Assert(err, IsNil)
wc.AssertNoChange()
// Assign a unit (to a separate instance); change detected.
mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
c.Assert(err, IsNil)
mysql0, err := mysql.AddUnit()
c.Assert(err, IsNil)
machine, err := s.State.Machine(s.machine.Id())
c.Assert(err, IsNil)
err = mysql0.AssignToMachine(machine)
c.Assert(err, IsNil)
wc.AssertChange("mysql/0")
wc.AssertNoChange()
// Change the unit; no change.
err = mysql0.SetStatus(params.StatusStarted, "")
c.Assert(err, IsNil)
wc.AssertNoChange()
// Assign another unit and make the first Dying; check both changes detected.
mysql1, err := mysql.AddUnit()
c.Assert(err, IsNil)
err = mysql1.AssignToMachine(machine)
c.Assert(err, IsNil)
err = mysql0.Destroy()
c.Assert(err, IsNil)
wc.AssertChange("mysql/0", "mysql/1")
wc.AssertNoChange()
// Add a subordinate to the Alive unit; change detected.
logging, err := s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
c.Assert(err, IsNil)
eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
c.Assert(err, IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, IsNil)
mysqlru1, err := rel.Unit(mysql1)
c.Assert(err, IsNil)
err = mysqlru1.EnterScope(nil)
c.Assert(err, IsNil)
logging0, err := logging.Unit("logging/0")
c.Assert(err, IsNil)
wc.AssertChange("logging/0")
wc.AssertNoChange()
// Change the subordinate; no change.
err = logging0.SetStatus(params.StatusStarted, "")
c.Assert(err, IsNil)
wc.AssertNoChange()
// Make the Dying unit Dead; change detected.
err = mysql0.EnsureDead()
c.Assert(err, IsNil)
wc.AssertChange("mysql/0")
wc.AssertNoChange()
// Stop watcher; check Changes chan closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Start a fresh watcher; check all units reported.
w = s.machine.WatchUnits()
defer testing.AssertStop(c, w)
wc = testing.NewLaxStringsWatcherC(c, s.State, w)
wc.AssertChange("mysql/0", "mysql/1", "logging/0")
wc.AssertNoChange()
// Remove the Dead unit; no change.
err = mysql0.Remove()
c.Assert(err, IsNil)
wc.AssertNoChange()
// Destroy the subordinate; change detected.
err = logging0.Destroy()
c.Assert(err, IsNil)
wc.AssertChange("logging/0")
wc.AssertNoChange()
// Unassign the principal; check subordinate departure also reported.
err = mysql1.UnassignFromMachine()
c.Assert(err, IsNil)
wc.AssertChange("mysql/1", "logging/0")
wc.AssertNoChange()
}
func (s *UnitSuite) TestWatchSubordinates(c *C) {
w := s.unit.WatchSubordinateUnits()
defer testing.AssertStop(c, w)
wc := testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChange()
wc.AssertNoChange()
// Add a couple of subordinates, check change.
subCharm := s.AddTestingCharm(c, "logging")
var subUnits []*state.Unit
for i := 0; i < 2; i++ {
// Note: subordinate units can only be created as a side effect of a
// principal entering scope; and a given principal can only have a
// single subordinate unit of each service.
name := "logging" + strconv.Itoa(i)
subSvc, err := s.State.AddService(name, subCharm)
c.Assert(err, IsNil)
eps, err := s.State.InferEndpoints([]string{name, "wordpress"})
c.Assert(err, IsNil)
rel, err := s.State.AddRelation(eps...)
c.Assert(err, IsNil)
ru, err := rel.Unit(s.unit)
c.Assert(err, IsNil)
err = ru.EnterScope(nil)
c.Assert(err, IsNil)
units, err := subSvc.AllUnits()
c.Assert(err, IsNil)
c.Assert(units, HasLen, 1)
subUnits = append(subUnits, units[0])
}
wc.AssertChange(subUnits[0].Name(), subUnits[1].Name())
wc.AssertNoChange()
// Set one to Dying, check change.
err := subUnits[0].Destroy()
c.Assert(err, IsNil)
wc.AssertChange(subUnits[0].Name())
wc.AssertNoChange()
// Set both to Dead, and remove one; check change.
err = subUnits[0].EnsureDead()
c.Assert(err, IsNil)
err = subUnits[1].EnsureDead()
c.Assert(err, IsNil)
err = subUnits[1].Remove()
c.Assert(err, IsNil)
wc.AssertChange(subUnits[0].Name(), subUnits[1].Name())
wc.AssertNoChange()
// Stop watcher, check closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Start a new watch, check Dead unit is reported.
w = s.unit.WatchSubordinateUnits()
defer testing.AssertStop(c, w)
wc = testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChange(subUnits[0].Name())
wc.AssertNoChange()
// Remove the leftover, check no change.
err = subUnits[0].Remove()
c.Assert(err, IsNil)
wc.AssertNoChange()
}
func (s *ServiceSuite) TestWatchRelations(c *C) {
// TODO(fwereade) split this test up a bit.
w := s.mysql.WatchRelations()
defer testing.AssertStop(c, w)
wc := testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChange()
wc.AssertNoChange()
// Add a relation; check change.
mysqlep, err := s.mysql.Endpoint("server")
c.Assert(err, IsNil)
wpch := s.AddTestingCharm(c, "wordpress")
wpi := 0
addRelation := func() *state.Relation {
name := fmt.Sprintf("wp%d", wpi)
wpi++
wp, err := s.State.AddService(name, wpch)
c.Assert(err, IsNil)
wpep, err := wp.Endpoint("db")
c.Assert(err, IsNil)
rel, err := s.State.AddRelation(mysqlep, wpep)
c.Assert(err, IsNil)
return rel
}
rel0 := addRelation()
wc.AssertChange(rel0.String())
wc.AssertNoChange()
// Add another relation; check change.
rel1 := addRelation()
wc.AssertChange(rel1.String())
wc.AssertNoChange()
// Destroy a relation; check change.
err = rel0.Destroy()
c.Assert(err, IsNil)
wc.AssertChange(rel0.String())
wc.AssertNoChange()
// Stop watcher; check change chan is closed.
testing.AssertStop(c, w)
wc.AssertClosed()
// Add a new relation; start a new watcher; check initial event.
rel2 := addRelation()
w = s.mysql.WatchRelations()
defer testing.AssertStop(c, w)
wc = testing.NewStringsWatcherC(c, s.State, w)
wc.AssertChange(rel1.String(), rel2.String())
wc.AssertNoChange()
// Add a unit to the new relation; check no change.
unit, err := s.mysql.AddUnit()
c.Assert(err, IsNil)
ru2, err := rel2.Unit(unit)
c.Assert(err, IsNil)
err = ru2.EnterScope(nil)
c.Assert(err, IsNil)
wc.AssertNoChange()
// Destroy the relation with the unit in scope, and add another; check
// changes.
err = rel2.Destroy()
c.Assert(err, IsNil)
rel3 := addRelation()
wc.AssertChange(rel2.String(), rel3.String())
wc.AssertNoChange()
// Leave scope, destroying the relation, and check that change as well.
err = ru2.LeaveScope()
c.Assert(err, IsNil)
wc.AssertChange(rel2.String())
wc.AssertNoChange()
}
func (s *RelationUnitSuite) TestProReqWatchScope(c *C) {
prr := NewProReqRelation(c, &s.ConnSuite, charm.ScopeGlobal)
// Test empty initial events for all RUs.
ws := prr.watches()
for _, w := range ws {
defer testing.AssertStop(c, w)
}
for _, w := range ws {
s.assertScopeChange(c, w, nil, nil)
}
s.assertNoScopeChange(c, ws...)
// pru0 enters; check detected only by req RUs.
err := prr.pru0.EnterScope(nil)
c.Assert(err, IsNil)
rws := func() []*state.RelationScopeWatcher {
return []*state.RelationScopeWatcher{ws[2], ws[3]}
}
for _, w := range rws() {
s.assertScopeChange(c, w, []string{"mysql/0"}, nil)
}
s.assertNoScopeChange(c, ws...)
// req0 enters; check detected only by pro RUs.
err = prr.rru0.EnterScope(nil)
c.Assert(err, IsNil)
pws := func() []*state.RelationScopeWatcher {
return []*state.RelationScopeWatcher{ws[0], ws[1]}
}
for _, w := range pws() {
s.assertScopeChange(c, w, []string{"wordpress/0"}, nil)
}
s.assertNoScopeChange(c, ws...)
// Stop watches; remaining RUs enter.
for _, w := range ws {
testing.AssertStop(c, w)
}
err = prr.pru1.EnterScope(nil)
c.Assert(err, IsNil)
err = prr.rru1.EnterScope(nil)
c.Assert(err, IsNil)
// Start new watches, check initial events.
ws = prr.watches()
for _, w := range ws {
defer testing.AssertStop(c, w)
}
for _, w := range pws() {
s.assertScopeChange(c, w, []string{"wordpress/0", "wordpress/1"}, nil)
}
for _, w := range rws() {
s.assertScopeChange(c, w, []string{"mysql/0", "mysql/1"}, nil)
}
s.assertNoScopeChange(c, ws...)
// pru0 leaves; check detected only by req RUs.
err = prr.pru0.LeaveScope()
c.Assert(err, IsNil)
for _, w := range rws() {
s.assertScopeChange(c, w, nil, []string{"mysql/0"})
}
s.assertNoScopeChange(c, ws...)
// rru0 leaves; check detected only by pro RUs.
err = prr.rru0.LeaveScope()
c.Assert(err, IsNil)
for _, w := range pws() {
s.assertScopeChange(c, w, nil, []string{"wordpress/0"})
}
s.assertNoScopeChange(c, ws...)
}