// startUnit creates a new data value for tracking details of the
// unit and starts watching the unit for port changes. The provided
// machineId must be the id for the machine the unit was last observed
// to be assigned to.
func (fw *Firewaller) startUnit(unit *state.Unit, machineId string) error {
service, err := unit.Service()
if err != nil {
return err
}
serviceName := service.Name()
unitName := unit.Name()
unitd := &unitData{
fw: fw,
unit: unit,
ports: unit.OpenedPorts(),
}
fw.unitds[unitName] = unitd
unitd.machined = fw.machineds[machineId]
unitd.machined.unitds[unitName] = unitd
if fw.serviceds[serviceName] == nil {
err := fw.startService(service)
if err != nil {
delete(fw.unitds, unitName)
return err
}
}
unitd.serviced = fw.serviceds[serviceName]
unitd.serviced.unitds[unitName] = unitd
ports := make([]instance.Port, len(unitd.ports))
copy(ports, unitd.ports)
go unitd.watchLoop(ports)
return nil
}
// matchUnit attempts to match a state.Unit to one of
// a set of patterns, taking into account subordinate
// relationships.
func (m unitMatcher) matchUnit(u *state.Unit) bool {
if m.matchesAny() {
return true
}
// Keep the unit if:
// (a) its name matches a pattern, or
// (b) it's a principal and one of its subordinates matches, or
// (c) it's a subordinate and its principal matches.
//
// Note: do *not* include a second subordinate if the principal is
// only matched on account of a first subordinate matching.
if m.matchString(u.Name()) {
return true
}
if u.IsPrincipal() {
for _, s := range u.SubordinateNames() {
if m.matchString(s) {
return true
}
}
return false
}
principal, valid := u.PrincipalName()
if !valid {
panic("PrincipalName failed for subordinate unit")
}
return m.matchString(principal)
}
func (c *DebugHooksCommand) validateHooks(unit *state.Unit) error {
if len(c.hooks) == 0 {
return nil
}
service, err := unit.Service()
if err != nil {
return err
}
eps, err := service.Endpoints()
if err != nil {
return err
}
validHooks := make(map[string]bool)
for _, hook := range hooks.UnitHooks() {
validHooks[string(hook)] = true
}
for _, ep := range eps {
for _, hook := range hooks.RelationHooks() {
hook := fmt.Sprintf("%s-%s", ep.Relation.Name, hook)
validHooks[hook] = true
}
}
for _, hook := range c.hooks {
if !validHooks[hook] {
return fmt.Errorf("unit %q does not contain hook %q", unit.Name(), hook)
}
}
return nil
}
// remove will remove the supplied unit from state. It will panic if it
// observes inconsistent internal state.
func (d *Deployer) remove(unit *state.Unit) error {
if d.deployed.Contains(unit.Name()) {
panic("must not remove a deployed unit")
} else if unit.Life() == state.Alive {
panic("must not remove an Alive unit")
}
logger.Infof("removing unit %q", unit)
if err := unit.EnsureDead(); err != nil {
return err
}
return unit.Remove()
}
func (s *AssignSuite) assertAssignedUnit(c *C, unit *state.Unit) string {
// Check the machine on the unit is set.
machineId, err := unit.AssignedMachineId()
c.Assert(err, IsNil)
// Check that the principal is set on the machine.
machine, err := s.State.Machine(machineId)
c.Assert(err, IsNil)
machineUnits, err := machine.Units()
c.Assert(err, IsNil)
c.Assert(machineUnits, HasLen, 1)
// Make sure it is the right unit.
c.Assert(machineUnits[0].Name(), Equals, unit.Name())
return machineId
}
// remove will remove the supplied unit from state. It will panic if it
// observes inconsistent internal state.
func (d *Deployer) remove(unit *state.Unit) error {
if d.deployed[unit.Name()] {
panic("must not remove a deployed unit")
} else if unit.Life() == state.Alive {
panic("must not remove an Alive unit")
}
log.Printf("worker/deployer: removing unit %q", unit)
if err := unit.EnsureDead(); err != nil {
return err
}
service, err := unit.Service()
if err != nil {
return err
}
return service.RemoveUnit(unit)
}
// deploy will deploy the supplied unit with the deployer's manager. It will
// panic if it observes inconsistent internal state.
func (d *Deployer) deploy(unit *state.Unit) error {
unitName := unit.Name()
if d.deployed[unit.Name()] {
panic("must not re-deploy a deployed unit")
}
log.Printf("worker/deployer: deploying unit %q", unit)
initialPassword, err := trivial.RandomPassword()
if err != nil {
return err
}
if err := unit.SetMongoPassword(initialPassword); err != nil {
return err
}
if err := d.mgr.DeployUnit(unitName, initialPassword); err != nil {
return err
}
d.deployed[unitName] = true
return nil
}
// deploy will deploy the supplied unit with the deployer's manager. It will
// panic if it observes inconsistent internal state.
func (d *Deployer) deploy(unit *state.Unit) error {
unitName := unit.Name()
if d.deployed.Contains(unit.Name()) {
panic("must not re-deploy a deployed unit")
}
logger.Infof("deploying unit %q", unit)
initialPassword, err := utils.RandomPassword()
if err != nil {
return err
}
if err := unit.SetPassword(initialPassword); err != nil {
return fmt.Errorf("cannot set password for unit %q: %v", unit, err)
}
if err := unit.SetMongoPassword(initialPassword); err != nil {
return fmt.Errorf("cannot set mongo password for unit %q: %v", unit, err)
}
if err := d.ctx.DeployUnit(unitName, initialPassword); err != nil {
return err
}
d.deployed.Add(unitName)
return nil
}
func (s *UnitSuite) newAgent(c *C, unit *state.Unit) *UnitAgent {
a := &UnitAgent{}
s.initAgent(c, a, "--unit-name", unit.Name())
return a
}