// WatchContainers returns a StringsWatcher that notifies of changes
// to the lifecycles of containers of the specified type on the machine.
func (m *Machine) WatchContainers(ctype instance.ContainerType) (watcher.StringsWatcher, error) {
if string(ctype) == "" {
return nil, errors.New("container type must be specified")
}
supported := false
for _, c := range instance.ContainerTypes {
if ctype == c {
supported = true
break
}
}
if !supported {
return nil, fmt.Errorf("unsupported container type %q", ctype)
}
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag, ContainerType: string(ctype)},
},
}
err := m.st.call("WatchContainers", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := watcher.NewStringsWatcher(m.st.caller, result)
return w, nil
}
func (s *watcherSuite) TestStringsWatcherStopsWithPendingSend(c *gc.C) {
// 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)
// Create a service, deploy a unit of it on the machine.
mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
principal, err := mysql.AddUnit()
c.Assert(err, gc.IsNil)
err = principal.AssignToMachine(s.rawMachine)
c.Assert(err, gc.IsNil)
// Ensure the initial event is delivered. Then test the watcher
// can be stopped cleanly without reading the pending change.
s.BackingState.StartSync()
statetesting.AssertCanStopWhenSending(c, w)
wc.AssertClosed()
}
func (s *watcherSuite) TestWatchUnitsKeepsEvents(c *gc.C) {
// Create two services, relate them, and add one unit to each - a
// principal and a subordinate.
mysql := s.AddTestingService(c, "mysql", s.AddTestingCharm(c, "mysql"))
logging := s.AddTestingService(c, "logging", s.AddTestingCharm(c, "logging"))
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.StartSync()
err = subordinate.Remove()
c.Assert(err, gc.IsNil)
err = principal.EnsureDead()
c.Assert(err, gc.IsNil)
s.BackingState.StartSync()
// 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()
}
// WatchEnvironMachines returns a StringsWatcher that notifies of
// changes to the lifecycles of the machines (but not containers) in
// the current environment.
func (st *State) WatchEnvironMachines() (watcher.StringsWatcher, error) {
var result params.StringsWatchResult
err := st.call("WatchEnvironMachines", nil, &result)
if err != nil {
return nil, err
}
if err := result.Error; err != nil {
return nil, result.Error
}
w := watcher.NewStringsWatcher(st.caller, result)
return w, nil
}
// WatchRelations returns a StringsWatcher that notifies of changes to
// the lifecycles of relations involving s.
func (s *Service) WatchRelations() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.Entities{
Entities: []params.Entity{{Tag: s.tag}},
}
err := s.st.call("WatchServiceRelations", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := watcher.NewStringsWatcher(s.st.caller, result)
return w, nil
}
// WatchUnits starts a StringsWatcher to watch all units deployed to
// the machine, in order to track which ones should be deployed or
// recalled.
func (m *Machine) WatchUnits() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.tag}},
}
err := m.st.call("WatchUnits", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := watcher.NewStringsWatcher(m.st.caller, result)
return w, nil
}
// WatchAllContainers returns a StringsWatcher that notifies of changes
// to the lifecycles of all containers on the machine.
func (m *Machine) WatchAllContainers() (watcher.StringsWatcher, error) {
var results params.StringsWatchResults
args := params.WatchContainers{
Params: []params.WatchContainer{
{MachineTag: m.tag},
},
}
err := m.st.call("WatchContainers", args, &results)
if err != nil {
return nil, err
}
if len(results.Results) != 1 {
return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
}
result := results.Results[0]
if result.Error != nil {
return nil, result.Error
}
w := watcher.NewStringsWatcher(m.st.caller, result)
return w, nil
}
