// assertForceMachine ensures that the result of assigning a unit with --to
// is as expected.
func (s *AddUnitSuite) assertForceMachine(c *C, svc *state.Service, expectedNumMachines, unitNum int, machineId string) {
units, err := svc.AllUnits()
c.Assert(err, IsNil)
c.Assert(units, HasLen, expectedNumMachines)
mid, err := units[unitNum].AssignedMachineId()
c.Assert(err, IsNil)
c.Assert(mid, Equals, machineId)
}
func removeAllUnits(c *C, s *state.Service) {
us, err := s.AllUnits()
c.Assert(err, IsNil)
for _, u := range us {
err = u.EnsureDead()
c.Assert(err, IsNil)
err = u.Remove()
c.Assert(err, IsNil)
}
}
func removeServiceAndUnits(c *C, service *state.Service) {
// Destroy all units for the service.
units, err := service.AllUnits()
c.Assert(err, IsNil)
for _, unit := range units {
err = unit.EnsureDead()
c.Assert(err, IsNil)
err = unit.Remove()
c.Assert(err, IsNil)
}
err = service.Destroy()
c.Assert(err, IsNil)
err = service.Refresh()
c.Assert(err, checkers.Satisfies, errors.IsNotFoundError)
}
func (s *DeployLocalSuite) assertMachines(c *C, service *state.Service, expectCons constraints.Value, expectIds ...string) {
units, err := service.AllUnits()
c.Assert(err, IsNil)
c.Assert(units, HasLen, len(expectIds))
unseenIds := set.NewStrings(expectIds...)
for _, unit := range units {
id, err := unit.AssignedMachineId()
c.Assert(err, IsNil)
unseenIds.Remove(id)
machine, err := s.State.Machine(id)
c.Assert(err, IsNil)
cons, err := machine.Constraints()
c.Assert(err, IsNil)
c.Assert(cons, DeepEquals, expectCons)
}
c.Assert(unseenIds, DeepEquals, set.NewStrings())
}
func addRU(c *C, svc *state.Service, rel *state.Relation, principal *state.Unit) (*state.Unit, *state.RelationUnit) {
// Given the service svc in the relation rel, add a unit of svc and create
// a RelationUnit with rel. If principal is supplied, svc is assumed to be
// subordinate and the unit will be created by temporarily entering the
// relation's scope as the principal.
var u *state.Unit
if principal == nil {
unit, err := svc.AddUnit()
c.Assert(err, IsNil)
u = unit
} else {
origUnits, err := svc.AllUnits()
c.Assert(err, IsNil)
pru, err := rel.Unit(principal)
c.Assert(err, IsNil)
err = pru.EnterScope(nil) // to create the subordinate
c.Assert(err, IsNil)
err = pru.LeaveScope() // to reset to initial expected state
c.Assert(err, IsNil)
newUnits, err := svc.AllUnits()
c.Assert(err, IsNil)
for _, unit := range newUnits {
found := false
for _, old := range origUnits {
if unit.Name() == old.Name() {
found = true
break
}
}
if !found {
u = unit
break
}
}
c.Assert(u, NotNil)
}
preventUnitDestroyRemove(c, u)
ru, err := rel.Unit(u)
c.Assert(err, IsNil)
return u, ru
}
func processService(service *state.Service) (map[string]interface{}, error) {
r := m()
ch, _, err := service.Charm()
if err != nil {
return nil, err
}
r["charm"] = ch.String()
r["exposed"] = service.IsExposed()
// TODO(dfc) service.IsSubordinate() ?
units, err := service.AllUnits()
if err != nil {
return nil, err
}
u := checkError(processUnits(units))
if len(u) > 0 {
r["units"] = u
}
// TODO(dfc) process relations
return r, nil
}
func assertAllUnits(c *C, service *state.Service, expected int) {
units, err := service.AllUnits()
c.Assert(err, IsNil)
c.Assert(units, HasLen, expected)
}
