// checkStartInstance checks that an instance has been started
// with a machine id the same as m's, and that the machine's
// instance id has been set appropriately.
func (s *ProvisionerSuite) checkStartInstance(c *C, m *state.Machine, secret string) {
s.State.StartSync()
for {
select {
case o := <-s.op:
switch o := o.(type) {
case dummy.OpStartInstance:
info := s.StateInfo(c)
info.EntityName = m.EntityName()
c.Assert(o.Info.Password, Not(HasLen), 0)
info.Password = o.Info.Password
c.Assert(o.Info, DeepEquals, info)
// Check we can connect to the state with
// the machine's entity name and password.
st, err := state.Open(o.Info)
c.Assert(err, IsNil)
st.Close()
c.Assert(o.MachineId, Equals, m.Id())
c.Assert(o.Instance, NotNil)
s.checkInstanceId(c, m, o.Instance)
c.Assert(o.Secret, Equals, secret)
return
default:
c.Logf("ignoring unexpected operation %#v", o)
}
case <-time.After(2 * time.Second):
c.Errorf("provisioner did not start an instance")
return
}
}
}
// startInstance starts a new instance for the given machine.
func (s *FirewallerSuite) startInstance(c *C, m *state.Machine) environs.Instance {
inst, err := s.Conn.Environ.StartInstance(m.Id(), testing.InvalidStateInfo(m.Id()), nil)
c.Assert(err, IsNil)
err = m.SetInstanceId(inst.Id())
c.Assert(err, IsNil)
return inst
}
func (s *assignCleanSuite) assertAssignUnit(c *C, expectedMachine *state.Machine) {
unit, err := s.wordpress.AddUnit()
c.Assert(err, IsNil)
reusedMachine, err := s.assignUnit(unit)
c.Assert(err, IsNil)
c.Assert(reusedMachine.Id(), Equals, expectedMachine.Id())
c.Assert(reusedMachine.Clean(), jc.IsFalse)
}
func (s *CommonProvisionerSuite) checkStartInstanceCustom(c *C, m *state.Machine, secret string, cons constraints.Value) (inst instance.Instance) {
s.State.StartSync()
for {
select {
case o := <-s.op:
switch o := o.(type) {
case dummy.OpStartInstance:
inst = o.Instance
s.waitInstanceId(c, m, inst.Id())
// Check the instance was started with the expected params.
c.Assert(o.MachineId, Equals, m.Id())
nonceParts := strings.SplitN(o.MachineNonce, ":", 2)
c.Assert(nonceParts, HasLen, 2)
c.Assert(nonceParts[0], Equals, state.MachineTag("0"))
c.Assert(nonceParts[1], checkers.Satisfies, utils.IsValidUUIDString)
c.Assert(o.Secret, Equals, secret)
c.Assert(o.Constraints, DeepEquals, cons)
// Check we can connect to the state with
// the machine's entity name and password.
info := s.StateInfo(c)
info.Tag = m.Tag()
c.Assert(o.Info.Password, Not(HasLen), 0)
info.Password = o.Info.Password
c.Assert(o.Info, DeepEquals, info)
// Check we can connect to the state with
// the machine's entity name and password.
st, err := state.Open(o.Info, state.DefaultDialOpts())
c.Assert(err, IsNil)
// All provisioned machines in this test suite have their hardware characteristics
// attributes set to the same values as the constraints due to the dummy environment being used.
hc, err := m.HardwareCharacteristics()
c.Assert(err, IsNil)
c.Assert(*hc, DeepEquals, instance.HardwareCharacteristics{
Arch: cons.Arch,
Mem: cons.Mem,
CpuCores: cons.CpuCores,
CpuPower: cons.CpuPower,
})
st.Close()
return
default:
c.Logf("ignoring unexpected operation %#v", o)
}
case <-time.After(2 * time.Second):
c.Fatalf("provisioner did not start an instance")
return
}
}
return
}
func (c *NatCommand) ExecSsh(m *state.Machine, script string) error {
host := instance.SelectPublicAddress(m.Addresses())
if host == "" {
return fmt.Errorf("could not resolve machine's public address")
}
log.Println("Configuring NAT routing on machine ", m.Id())
var options ssh.Options
cmd := ssh.Command("ubuntu@"+host, []string{"sh -c 'NATCMD=$(mktemp); cat >${NATCMD}; sudo sh -x ${NATCMD}'"}, &options)
cmd.Stdin = strings.NewReader(script)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd.Run()
}
func (task *provisionerTask) startMachine(machine *state.Machine) error {
stateInfo, apiInfo, err := task.auth.SetupAuthentication(machine)
if err != nil {
logger.Errorf("failed to setup authentication: %v", err)
return err
}
cons, err := machine.Constraints()
if err != nil {
return err
}
// Generate a unique nonce for the new instance.
uuid, err := utils.NewUUID()
if err != nil {
return err
}
// Generated nonce has the format: "machine-#:UUID". The first
// part is a badge, specifying the tag of the machine the provisioner
// is running on, while the second part is a random UUID.
nonce := fmt.Sprintf("%s:%s", names.MachineTag(task.machineId), uuid.String())
inst, metadata, err := task.broker.StartInstance(machine.Id(), nonce, machine.Series(), cons, stateInfo, apiInfo)
if err != nil {
// Set the state to error, so the machine will be skipped next
// time until the error is resolved, but don't return an
// error; just keep going with the other machines.
logger.Errorf("cannot start instance for machine %q: %v", machine, err)
if err1 := machine.SetStatus(params.StatusError, err.Error()); err1 != nil {
// Something is wrong with this machine, better report it back.
logger.Errorf("cannot set error status for machine %q: %v", machine, err1)
return err1
}
return nil
}
if err := machine.SetProvisioned(inst.Id(), nonce, metadata); err != nil {
logger.Errorf("cannot register instance for machine %v: %v", machine, err)
// The machine is started, but we can't record the mapping in
// state. It'll keep running while we fail out and restart,
// but will then be detected by findUnknownInstances and
// killed again.
//
// TODO(dimitern) Stop the instance right away here.
//
// Multiple instantiations of a given machine (with the same
// machine ID) cannot coexist, because findUnknownInstances is
// called before startMachines. However, if the first machine
// had started to do work before being replaced, we may
// encounter surprising problems.
return err
}
logger.Infof("started machine %s as instance %s with hardware %q", machine, inst.Id(), metadata)
return nil
}
// 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
}
func (s *ProvisionerSuite) checkStartInstanceCustom(c *C, m *state.Machine, secret string, cons constraints.Value) {
s.State.StartSync()
for {
select {
case o := <-s.op:
switch o := o.(type) {
case dummy.OpStartInstance:
s.waitInstanceId(c, m, o.Instance.Id())
// Check the instance was started with the expected params.
c.Assert(o.MachineId, Equals, m.Id())
nonceParts := strings.SplitN(o.MachineNonce, ":", 2)
c.Assert(nonceParts, HasLen, 2)
c.Assert(nonceParts[0], Equals, state.MachineTag("0"))
c.Assert(utils.IsValidUUIDString(nonceParts[1]), Equals, true)
c.Assert(o.Secret, Equals, secret)
c.Assert(o.Constraints, DeepEquals, cons)
// Check we can connect to the state with
// the machine's entity name and password.
info := s.StateInfo(c)
info.Tag = m.Tag()
c.Assert(o.Info.Password, Not(HasLen), 0)
info.Password = o.Info.Password
c.Assert(o.Info, DeepEquals, info)
// Check we can connect to the state with
// the machine's entity name and password.
st, err := state.Open(o.Info, state.DefaultDialOpts())
c.Assert(err, IsNil)
st.Close()
return
default:
c.Logf("ignoring unexpected operation %#v", o)
}
case <-time.After(2 * time.Second):
c.Fatalf("provisioner did not start an instance")
return
}
}
}
func (p *Provisioner) startMachine(m *state.Machine) error {
// TODO(dfc) the state.Info passed to environ.StartInstance remains contentious
// however as the PA only knows one state.Info, and that info is used by MAs and
// UAs to locate the state for this environment, it is logical to use the same
// state.Info as the PA.
stateInfo, apiInfo, err := p.setupAuthentication(m)
if err != nil {
return err
}
cons, err := m.Constraints()
if err != nil {
return err
}
// Generate a unique nonce for the new instance.
uuid, err := utils.NewUUID()
if err != nil {
return err
}
// Generated nonce has the format: "machine-#:UUID". The first
// part is a badge, specifying the tag of the machine the provisioner
// is running on, while the second part is a random UUID.
nonce := fmt.Sprintf("%s:%s", state.MachineTag(p.machineId), uuid.String())
inst, err := p.environ.StartInstance(m.Id(), nonce, m.Series(), cons, stateInfo, apiInfo)
if err != nil {
// Set the state to error, so the machine will be skipped next
// time until the error is resolved, but don't return an
// error; just keep going with the other machines.
log.Errorf("worker/provisioner: cannot start instance for machine %q: %v", m, err)
if err1 := m.SetStatus(params.StatusError, err.Error()); err1 != nil {
// Something is wrong with this machine, better report it back.
log.Errorf("worker/provisioner: cannot set error status for machine %q: %v", m, err1)
return err1
}
return nil
}
if err := m.SetProvisioned(inst.Id(), nonce); err != nil {
// The machine is started, but we can't record the mapping in
// state. It'll keep running while we fail out and restart,
// but will then be detected by findUnknownInstances and
// killed again.
//
// TODO(dimitern) Stop the instance right away here.
//
// Multiple instantiations of a given machine (with the same
// machine ID) cannot coexist, because findUnknownInstances is
// called before startMachines. However, if the first machine
// had started to do work before being replaced, we may
// encounter surprising problems.
return err
}
// populate the local cache
p.instances[m.Id()] = inst
p.machines[inst.Id()] = m.Id()
log.Noticef("worker/provisioner: started machine %s as instance %s", m, inst.Id())
return nil
}
func MatchNetworks(host, gateway *state.Machine) (string, string, error) {
var bestPrefix, bestHost, bestGw string
for _, hostAddr := range host.Addresses() {
if hostAddr.Type != instance.Ipv4Address || isLoopback(hostAddr.Value) {
continue
}
for _, gwAddr := range gateway.Addresses() {
if gwAddr.Type != instance.Ipv4Address || isLoopback(hostAddr.Value) {
continue
}
prefix := greatestCommonPrefix(hostAddr.Value, gwAddr.Value)
if len(prefix) > len(bestPrefix) {
bestPrefix = prefix
bestHost = hostAddr.Value
bestGw = gwAddr.Value
}
}
}
if bestHost != "" && bestGw != "" {
return bestHost, bestGw, nil
} else {
return "", "", fmt.Errorf("failed to find common network for %s and %s", host.Id(), gateway.Id())
}
}
// startInstance starts a new instance for the given machine.
func (s *FirewallerSuite) startInstance(c *C, m *state.Machine) instance.Instance {
inst, hc := testing.StartInstance(c, s.Conn.Environ, m.Id())
err := m.SetProvisioned(inst.Id(), "fake_nonce", hc)
c.Assert(err, IsNil)
return inst
}
// newAgent returns a new MachineAgent instance
func (s *MachineSuite) newAgent(c *C, m *state.Machine) *MachineAgent {
a := &MachineAgent{}
s.initAgent(c, a, "--machine-id", m.Id())
return a
}