Add machine instance metadata to state

worker/deployer/deployer_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package deployer_test
 
 import (
         "sort"
         "strings"
         stdtesting "testing"
         "time"
@@ skipping 38 matching lines @@
         c.Assert(err, IsNil)
         svc, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
         c.Assert(err, IsNil)
         u0, err := svc.AddUnit()
         c.Assert(err, IsNil)
         u1, err := svc.AddUnit()
         c.Assert(err, IsNil)
 
         // Create a deployer acting on behalf of the machine.
         ctx := s.getContext(c, m.Tag())
-        dep := deployer.NewDeployer(s.State, ctx, m.WatchPrincipalUnits())
+        dep := deployer.NewDeployer(s.State, ctx, m.Id())
         defer stop(c, dep)
 
         // Assign one unit, and wait for it to be deployed.
         err = u0.AssignToMachine(m)
         c.Assert(err, IsNil)
         s.waitFor(c, isDeployed(ctx, u0.Name()))
 
         // Assign another unit, and wait for that to be deployed.
         err = u1.AssignToMachine(m)
         c.Assert(err, IsNil)
@@ skipping 47 matching lines @@
         // have been deployed. But it's instructive to check that the right thing
         // would happen if it were possible to have a dying unit in this situation.
         err = u1.SetStatus(params.StatusInstalled, "")
         c.Assert(err, IsNil)
         err = u1.Destroy()
         c.Assert(err, IsNil)
 
         // When the deployer is started, in each case (1) no unit agent is deployed
         // and (2) the non-Alive unit is been removed from state.
         ctx := s.getContext(c, m.Tag())
-        dep := deployer.NewDeployer(s.State, ctx, m.WatchPrincipalUnits())
+        dep := deployer.NewDeployer(s.State, ctx, m.Id())
         defer stop(c, dep)
         s.waitFor(c, isRemoved(s.State, u0.Name()))
         s.waitFor(c, isRemoved(s.State, u1.Name()))
         s.waitFor(c, isDeployed(ctx))
 }
 
 func (s *DeployerSuite) prepareSubordinates(c *C) (*state.Unit, []*state.RelationUnit) {
+        m, err := s.State.AddMachine("series", state.JobHostUnits)
+        c.Assert(err, IsNil)
         svc, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
         c.Assert(err, IsNil)
         u, err := svc.AddUnit()
+        c.Assert(err, IsNil)
+        err = u.AssignToMachine(m)
         c.Assert(err, IsNil)
         rus := []*state.RelationUnit{}
         logging := s.AddTestingCharm(c, "logging")
         for _, name := range []string{"subsvc0", "subsvc1"} {
                 _, err := s.State.AddService(name, logging)
                 c.Assert(err, IsNil)
                 eps, err := s.State.InferEndpoints([]string{"wordpress", name})
                 c.Assert(err, IsNil)
                 rel, err := s.State.AddRelation(eps...)
                 c.Assert(err, IsNil)
                 ru, err := rel.Unit(u)
                 c.Assert(err, IsNil)
                 rus = append(rus, ru)
         }
         return u, rus
 }
 
 func (s *DeployerSuite) TestDeployRecallRemoveSubordinates(c *C) {
         // Create a deployer acting on behalf of the principal.
         u, rus := s.prepareSubordinates(c)
         ctx := s.getContext(c, u.Tag())
-        dep := deployer.NewDeployer(s.State, ctx, u.WatchSubordinateUnits())
+        machineId, err := u.AssignedMachineId()
+        c.Assert(err, IsNil)
+        dep := deployer.NewDeployer(s.State, ctx, machineId)
         defer stop(c, dep)
 
         // Add a subordinate, and wait for it to be deployed.
-        err := rus[0].EnterScope(nil)
+        err = rus[0].EnterScope(nil)
         c.Assert(err, IsNil)
         sub0, err := s.State.Unit("subsvc0/0")
         c.Assert(err, IsNil)
-        s.waitFor(c, isDeployed(ctx, sub0.Name()))
+        // Make sure the principal is deployed first, then the subordinate
+        s.waitFor(c, isDeployed(ctx, u.Name(), sub0.Name()))
 
         // And another.
         err = rus[1].EnterScope(nil)
         c.Assert(err, IsNil)
         sub1, err := s.State.Unit("subsvc1/0")
         c.Assert(err, IsNil)
-        s.waitFor(c, isDeployed(ctx, sub0.Name(), sub1.Name()))
+        s.waitFor(c, isDeployed(ctx, u.Name(), sub0.Name(), sub1.Name()))
 
         // Set one to Dying; check nothing happens.
         err = sub1.Destroy()
         c.Assert(err, IsNil)
         s.State.StartSync()
         c.Assert(isRemoved(s.State, sub1.Name())(c), Equals, false)
-        s.waitFor(c, isDeployed(ctx, sub0.Name(), sub1.Name()))
+        s.waitFor(c, isDeployed(ctx, u.Name(), sub0.Name(), sub1.Name()))
 
         // Set the other to Dead; check it's recalled and removed.
         err = sub0.EnsureDead()
         c.Assert(err, IsNil)
-        s.waitFor(c, isDeployed(ctx, sub1.Name()))
+        s.waitFor(c, isDeployed(ctx, u.Name(), sub1.Name()))
         s.waitFor(c, isRemoved(s.State, sub0.Name()))
 }
 
 func (s *DeployerSuite) TestNonAliveSubordinates(c *C) {
         // Add two subordinate units and set them to Dead/Dying respectively.
         u, rus := s.prepareSubordinates(c)
         err := rus[0].EnterScope(nil)
         c.Assert(err, IsNil)
         sub0, err := s.State.Unit("subsvc0/0")
         c.Assert(err, IsNil)
         err = sub0.EnsureDead()
         c.Assert(err, IsNil)
         err = rus[1].EnterScope(nil)
         c.Assert(err, IsNil)
         sub1, err := s.State.Unit("subsvc1/0")
         c.Assert(err, IsNil)
         err = sub1.Destroy()
         c.Assert(err, IsNil)
 
         // When we start a new deployer, neither unit will be deployed and
         // both will be removed.
         ctx := s.getContext(c, u.Tag())
-        dep := deployer.NewDeployer(s.State, ctx, u.WatchSubordinateUnits())
+        machineId, err := u.AssignedMachineId()
+        c.Assert(err, IsNil)
+        dep := deployer.NewDeployer(s.State, ctx, machineId)
         defer stop(c, dep)
         s.waitFor(c, isRemoved(s.State, sub0.Name()))
         s.waitFor(c, isRemoved(s.State, sub1.Name()))
 }
 
 func (s *DeployerSuite) waitFor(c *C, t func(c *C) bool) {
         s.State.StartSync()
         if t(c) {
                 return
         }
@@ skipping 32 matching lines @@
         }
 }
 
 type stopper interface {
         Stop() error
 }
 
 func stop(c *C, stopper stopper) {
         c.Assert(stopper.Stop(), IsNil)
 }