Exemplo n.º 1
0
// 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
}
Exemplo n.º 2
0
// 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)
}
Exemplo n.º 3
0
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
}
Exemplo n.º 4
0
// 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()
}
Exemplo n.º 5
0
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
}
Exemplo n.º 6
0
// 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)
}
Exemplo n.º 7
0
// 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
}
Exemplo n.º 8
0
// 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
}
Exemplo n.º 9
0
func (s *UnitSuite) newAgent(c *C, unit *state.Unit) *UnitAgent {
	a := &UnitAgent{}
	s.initAgent(c, a, "--unit-name", unit.Name())
	return a
}