func (s *UnitSuite) newAgent(c *gc.C, unit *state.Unit) *UnitAgent {
a := NewUnitAgent(nil, nil)
s.InitAgent(c, a, "--unit-name", unit.Name(), "--log-to-stderr=true")
err := a.ReadConfig(unit.Tag().String())
c.Assert(err, jc.ErrorIsNil)
return a
}
func (s *AssignSuite) assertAssignedUnit(c *gc.C, unit *state.Unit) string {
// Get service networks.
service, err := unit.Service()
c.Assert(err, jc.ErrorIsNil)
serviceNetworks, err := service.Networks()
c.Assert(err, jc.ErrorIsNil)
serviceCons, err := service.Constraints()
c.Assert(err, jc.ErrorIsNil)
// Check the machine on the unit is set.
machineId, err := unit.AssignedMachineId()
c.Assert(err, jc.ErrorIsNil)
// Check that the principal is set on the machine.
machine, err := s.State.Machine(machineId)
c.Assert(err, jc.ErrorIsNil)
machineCons, err := machine.Constraints()
c.Assert(err, jc.ErrorIsNil)
machineNetworks, err := machine.RequestedNetworks()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machineNetworks, gc.DeepEquals, serviceNetworks)
c.Assert(serviceCons.IncludeNetworks(), gc.DeepEquals, machineCons.IncludeNetworks())
c.Assert(serviceCons.ExcludeNetworks(), gc.DeepEquals, machineCons.ExcludeNetworks())
machineUnits, err := machine.Units()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machineUnits, gc.HasLen, 1)
// Make sure it is the right unit.
c.Assert(machineUnits[0].Name(), gc.Equals, unit.Name())
return machineId
}
// 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 (s *UnitSuite) newAgent(c *gc.C, unit *state.Unit) *UnitAgent {
a := &UnitAgent{}
s.initAgent(c, a, "--unit-name", unit.Name())
err := a.ReadConfig(unit.Tag().String())
c.Assert(err, gc.IsNil)
return a
}
func (s *AssignSuite) assertAssignedUnit(c *gc.C, unit *state.Unit) string {
// Check the machine on the unit is set.
machineId, err := unit.AssignedMachineId()
c.Assert(err, jc.ErrorIsNil)
// Check that the principal is set on the machine.
machine, err := s.State.Machine(machineId)
c.Assert(err, jc.ErrorIsNil)
machineUnits, err := machine.Units()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machineUnits, gc.HasLen, 1)
// Make sure it is the right unit.
c.Assert(machineUnits[0].Name(), gc.Equals, unit.Name())
return machineId
}
func (context *statusContext) processUnit(unit *state.Unit, serviceCharm string) params.UnitStatus {
var result params.UnitStatus
addr, err := unit.PublicAddress()
if err != nil {
// Usually this indicates that no addresses have been set on the
// machine yet.
addr = network.Address{}
logger.Debugf("error fetching public address: %v", err)
}
result.PublicAddress = addr.Value
unitPorts, _ := unit.OpenedPorts()
for _, port := range unitPorts {
result.OpenedPorts = append(result.OpenedPorts, port.String())
}
if unit.IsPrincipal() {
result.Machine, _ = unit.AssignedMachineId()
}
curl, _ := unit.CharmURL()
if serviceCharm != "" && curl != nil && curl.String() != serviceCharm {
result.Charm = curl.String()
}
workloadVersion, err := unit.WorkloadVersion()
if err == nil {
result.WorkloadVersion = workloadVersion
} else {
logger.Debugf("error fetching workload version: %v", err)
}
processUnitAndAgentStatus(unit, &result)
if subUnits := unit.SubordinateNames(); len(subUnits) > 0 {
result.Subordinates = make(map[string]params.UnitStatus)
for _, name := range subUnits {
subUnit := context.unitByName(name)
// subUnit may be nil if subordinate was filtered out.
if subUnit != nil {
result.Subordinates[name] = context.processUnit(subUnit, serviceCharm)
}
}
}
if leader := context.leaders[unit.ApplicationName()]; leader == unit.Name() {
result.Leader = true
}
return result
}
func (s *serviceSuite) claimLeadership(c *gc.C, unit *state.Unit, service *state.Application) {
claimer := s.State.LeadershipClaimer()
err := claimer.ClaimLeadership(service.Name(), unit.Name(), time.Minute)
c.Assert(err, jc.ErrorIsNil)
}
// processUnitLost determines whether the given unit should be marked as lost.
// TODO(fwereade/wallyworld): this is also model-level code and should sit in
// between state and this package.
func processUnitLost(unit *state.Unit, status *params.UnitStatus) {
if !canBeLost(status) {
// The status is allocating or installing - there's no point
// in enquiring about the agent liveness.
return
}
agentAlive, err := unit.AgentPresence()
if err != nil {
return
}
if unit.Life() != state.Dead && !agentAlive {
// If the unit is in error, it would be bad to throw away
// the error information as when the agent reconnects, that
// error information would then be lost.
if status.Workload.Status != params.StatusError {
status.Workload.Status = params.StatusUnknown
status.Workload.Info = fmt.Sprintf("agent is lost, sorry! See 'juju status-history %s'", unit.Name())
}
status.UnitAgent.Status = params.StatusLost
status.UnitAgent.Info = "agent is not communicating with the server"
}
}
func (s *serviceSuite) claimLeadership(c *gc.C, unit *state.Unit, service *state.Service) {
leadership := leadership.NewLeadershipManager(lease.Manager())
err := leadership.ClaimLeadership(service.Name(), unit.Name(), time.Minute)
c.Assert(err, jc.ErrorIsNil)
}
func checkUnitVersion(c *gc.C, appStatus params.ApplicationStatus, unit *state.Unit, expectedVersion string) {
unitStatus, found := appStatus.Units[unit.Name()]
c.Check(found, jc.IsTrue)
c.Check(unitStatus.WorkloadVersion, gc.Equals, expectedVersion)
}
