// waitRemoved waits for the supplied machine to be removed from state.
func (s *CommonProvisionerSuite) waitRemoved(c *gc.C, m *state.Machine) {
s.waitMachine(c, m, func() bool {
err := m.Refresh()
if errors.IsNotFound(err) {
return true
}
c.Assert(err, jc.ErrorIsNil)
c.Logf("machine %v is still %s", m, m.Life())
return false
})
}
// processMachine retrieves version and status information for the given machine.
// It also returns deprecated legacy status information.
func processMachine(machine *state.Machine) (out params.AgentStatus, compat params.AgentStatus) {
out.Life = processLife(machine)
if t, err := machine.AgentTools(); err == nil {
out.Version = t.Version.Number.String()
}
populateStatusFromGetter(&out, machine)
compat = out
if out.Err != nil {
return
}
if out.Status == params.StatusPending {
// The status is pending - there's no point
// in enquiring about the agent liveness.
return
}
agentAlive, err := machine.AgentPresence()
if err != nil {
return
}
if machine.Life() != state.Dead && !agentAlive {
// The agent *should* be alive but is not. Set status to
// StatusDown and munge Info to indicate the previous status and
// info. This is unfortunately making presentation decisions
// on behalf of the client (crappy).
//
// This is munging is only being left in place for
// compatibility with older clients. TODO: At some point we
// should change this so that Info left alone. API version may
// help here.
//
// Better yet, Status shouldn't be changed here in the API at
// all! Status changes should only happen in State. One
// problem caused by this is that this status change won't be
// seen by clients using a watcher because it didn't happen in
// State.
if out.Info != "" {
compat.Info = fmt.Sprintf("(%s: %s)", out.Status, out.Info)
} else {
compat.Info = fmt.Sprintf("(%s)", out.Status)
}
compat.Status = params.StatusDown
}
return
}
func (s *MigrationImportSuite) AssertMachineEqual(c *gc.C, newMachine, oldMachine *state.Machine) {
c.Assert(newMachine.Id(), gc.Equals, oldMachine.Id())
c.Assert(newMachine.Principals(), jc.DeepEquals, oldMachine.Principals())
c.Assert(newMachine.Series(), gc.Equals, oldMachine.Series())
c.Assert(newMachine.ContainerType(), gc.Equals, oldMachine.ContainerType())
newHardware, err := newMachine.HardwareCharacteristics()
c.Assert(err, jc.ErrorIsNil)
oldHardware, err := oldMachine.HardwareCharacteristics()
c.Assert(err, jc.ErrorIsNil)
c.Assert(newHardware, jc.DeepEquals, oldHardware)
c.Assert(newMachine.Jobs(), jc.DeepEquals, oldMachine.Jobs())
c.Assert(newMachine.Life(), gc.Equals, oldMachine.Life())
newTools, err := newMachine.AgentTools()
c.Assert(err, jc.ErrorIsNil)
oldTools, err := oldMachine.AgentTools()
c.Assert(err, jc.ErrorIsNil)
c.Assert(newTools, jc.DeepEquals, oldTools)
}