// waitInstanceId waits until the supplied machine has an instance id, then
// asserts it is as expected.
func (s *ProvisionerSuite) waitInstanceId(c *C, m *state.Machine, expect state.InstanceId) {
s.waitMachine(c, m, func() bool {
err := m.Refresh()
c.Assert(err, IsNil)
if actual, ok := m.InstanceId(); ok {
c.Assert(actual, Equals, expect)
return true
}
c.Logf("machine %v is still unprovisioned", m)
return false
})
}
// waitInstanceId waits until the supplied machine has an instance id, then
// asserts it is as expected.
func (s *CommonProvisionerSuite) waitInstanceId(c *C, m *state.Machine, expect instance.Id) {
s.waitHardwareCharacteristics(c, m, func() bool {
if actual, err := m.InstanceId(); err == nil {
c.Assert(actual, Equals, expect)
return true
} else if !state.IsNotProvisionedError(err) {
// We don't expect any errors.
panic(err)
}
c.Logf("machine %v is still unprovisioned", m)
return false
})
}
func (s *SSHCommonSuite) addUnit(srv *state.Service, m *state.Machine, c *C) {
u, err := srv.AddUnit()
c.Assert(err, IsNil)
err = u.AssignToMachine(m)
c.Assert(err, IsNil)
// fudge unit.SetPublicAddress
id, err := m.InstanceId()
c.Assert(err, IsNil)
insts, err := s.Conn.Environ.Instances([]state.InstanceId{id})
c.Assert(err, IsNil)
addr, err := insts[0].WaitDNSName()
c.Assert(err, IsNil)
err = u.SetPublicAddress(addr)
c.Assert(err, IsNil)
}
func (t *LiveTests) assertStartInstance(c *C, m *state.Machine) {
// Wait for machine to get an instance id.
for a := waitAgent.Start(); a.Next(); {
err := m.Refresh()
c.Assert(err, IsNil)
instId, err := m.InstanceId()
if err != nil {
c.Assert(state.IsNotProvisionedError(err), IsTrue)
continue
}
_, err = t.Env.Instances([]instance.Id{instId})
c.Assert(err, IsNil)
return
}
c.Fatalf("provisioner failed to start machine after %v", waitAgent.Total)
}
// instanceForMachine returns the environs.Instance that represents this machine's instance.
func (p *Provisioner) instanceForMachine(m *state.Machine) (environs.Instance, error) {
inst, ok := p.instances[m.Id()]
if ok {
return inst, nil
}
instId, ok := m.InstanceId()
if !ok {
return nil, errNotProvisioned
}
// TODO(dfc): Ask for all instances at once.
insts, err := p.environ.Instances([]state.InstanceId{instId})
if err != nil {
return nil, err
}
inst = insts[0]
return inst, nil
}
func (context *statusContext) makeMachineStatus(machine *state.Machine) (status machineStatus) {
status.Id = machine.Id()
status.Life,
status.AgentVersion,
status.AgentState,
status.AgentStateInfo,
status.Err = processAgent(machine)
status.Series = machine.Series()
instid, err := machine.InstanceId()
if err == nil {
status.InstanceId = instid
inst, ok := context.instances[instid]
if ok {
status.DNSName, _ = inst.DNSName()
} else {
// Double plus ungood. There is an instance id recorded
// for this machine in the state, yet the environ cannot
// find that id.
status.InstanceState = "missing"
}
} else {
if state.IsNotProvisionedError(err) {
status.InstanceId = "pending"
} else {
status.InstanceId = "error"
}
// There's no point in reporting a pending agent state
// if the machine hasn't been provisioned. This
// also makes unprovisioned machines visually distinct
// in the output.
status.AgentState = ""
}
hc, err := machine.HardwareCharacteristics()
if err != nil {
if !errors.IsNotFoundError(err) {
status.Hardware = "error"
}
} else {
status.Hardware = hc.String()
}
status.Containers = make(map[string]machineStatus)
return
}
// assertInstanceId asserts that the machine has an instance id
// that matches that of the given instance. If the instance is nil,
// It asserts that the instance id is unset.
func assertInstanceId(c *C, m *state.Machine, inst instance.Instance) {
var wantId, gotId instance.Id
var err error
if inst != nil {
wantId = inst.Id()
}
for a := waitAgent.Start(); a.Next(); {
err := m.Refresh()
c.Assert(err, IsNil)
gotId, err = m.InstanceId()
if err != nil {
c.Assert(state.IsNotProvisionedError(err), IsTrue)
if inst == nil {
return
}
continue
}
break
}
c.Assert(err, IsNil)
c.Assert(gotId, Equals, wantId)
}
// assertInstanceId asserts that the machine has an instance id
// that matches that of the given instance. If the instance is nil,
// It asserts that the instance id is unset.
func assertInstanceId(c *C, m *state.Machine, inst environs.Instance) {
var wantId, gotId state.InstanceId
var err error
if inst != nil {
wantId = inst.Id()
}
for a := waitAgent.Start(); a.Next(); {
err := m.Refresh()
c.Assert(err, IsNil)
gotId, err = m.InstanceId()
if state.IsNotFound(err) {
if inst == nil {
return
}
continue
}
c.Assert(err, IsNil)
break
}
c.Assert(err, IsNil)
c.Assert(gotId, Equals, wantId)
}
// checkInstanceIdSet checks that the machine has an instance id
// that matches that of the given instance. If the instance is nil,
// It checks that the instance id is unset.
func (s *ProvisionerSuite) checkInstanceId(c *C, m *state.Machine, inst environs.Instance) {
// TODO(dfc) add machine.Watch() to avoid having to poll.
s.State.StartSync()
var instId state.InstanceId
if inst != nil {
instId = inst.Id()
}
for a := veryShortAttempt.Start(); a.Next(); {
err := m.Refresh()
c.Assert(err, IsNil)
_, err = m.InstanceId()
if state.IsNotFound(err) {
if inst == nil {
return
}
continue
}
c.Assert(err, IsNil)
break
}
id, err := m.InstanceId()
c.Assert(err, IsNil)
c.Assert(id, Equals, instId)
}