func (s *AssignSuite) assertAssignUnitToNewMachineContainerConstraint(c *C) {
unit, err := s.wordpress.AddUnit()
c.Assert(err, IsNil)
err = unit.AssignToNewMachine()
c.Assert(err, IsNil)
machineId := s.assertAssignedUnit(c, unit)
c.Assert(state.ParentId(machineId), Not(Equals), "")
c.Assert(state.ContainerTypeFromId(machineId), Equals, instance.LXC)
}
func (s *AssignSuite) assertAssignUnitNewPolicyNoContainer(c *C) {
_, err := s.State.AddMachine("series", state.JobHostUnits) // available machine
c.Assert(err, IsNil)
unit, err := s.wordpress.AddUnit()
c.Assert(err, IsNil)
err = s.State.AssignUnit(unit, state.AssignNew)
c.Assert(err, IsNil)
assertMachineCount(c, s.State, 2)
id, err := unit.AssignedMachineId()
c.Assert(err, IsNil)
c.Assert(state.ParentId(id), Equals, "")
}
// fetchUnitMachineIds returns a set of IDs for machines that
// the specified units reside on, and those machines' ancestors.
func fetchUnitMachineIds(units map[string]map[string]*state.Unit) (*set.Strings, error) {
machineIds := new(set.Strings)
for _, svcUnitMap := range units {
for _, unit := range svcUnitMap {
if !unit.IsPrincipal() {
continue
}
mid, err := unit.AssignedMachineId()
if err != nil {
return nil, err
}
for mid != "" {
machineIds.Add(mid)
mid = state.ParentId(mid)
}
}
}
return machineIds, nil
}
func (context *statusContext) processMachine(machines []*state.Machine, host *machineStatus, startIndex int) (nextIndex int) {
nextIndex = startIndex + 1
currentHost := host
var previousContainer *machineStatus
for nextIndex < len(machines) {
machine := machines[nextIndex]
container := context.makeMachineStatus(machine)
if currentHost.Id == state.ParentId(machine.Id()) {
currentHost.Containers[machine.Id()] = container
previousContainer = &container
nextIndex++
} else {
if state.NestingLevel(machine.Id()) > state.NestingLevel(previousContainer.Id) {
nextIndex = context.processMachine(machines, previousContainer, nextIndex-1)
} else {
break
}
}
}
return
}
func (c *NatCommand) UnitContainment(u *state.Unit) (*UnitContainment, error) {
machineId, err := u.AssignedMachineId()
if err != nil {
return nil, err
}
host, ok := c.MachineMap[machineId]
if !ok {
return nil, fmt.Errorf("machine not found: %q", machineId)
}
gatewayId := state.ParentId(machineId)
if gatewayId == "" {
// Ignore machines not in containers
return nil, ErrNoContainer
}
gateway, ok := c.MachineMap[gatewayId]
if !ok {
return nil, fmt.Errorf("parent machine %q not found", gatewayId)
}
return &UnitContainment{Unit: u, GatewayMachine: gateway, HostMachine: host}, nil
}
func (e *environ) StartInstance(machineId, machineNonce string, series string, cons constraints.Value,
info *state.Info, apiInfo *api.Info) (instance.Instance, *instance.HardwareCharacteristics, error) {
defer delay()
log.Infof("environs/dummy: dummy startinstance, machine %s", machineId)
if err := e.checkBroken("StartInstance"); err != nil {
return nil, nil, err
}
possibleTools, err := environs.FindInstanceTools(e, series, cons)
if err != nil {
return nil, nil, err
}
err = environs.CheckToolsSeries(possibleTools, series)
if err != nil {
return nil, nil, err
}
log.Infof("environs/dummy: would pick tools from %s", possibleTools)
e.state.mu.Lock()
defer e.state.mu.Unlock()
if machineNonce == "" {
return nil, nil, fmt.Errorf("cannot start instance: missing machine nonce")
}
if _, ok := e.Config().CACert(); !ok {
return nil, nil, fmt.Errorf("no CA certificate in environment configuration")
}
if info.Tag != names.MachineTag(machineId) {
return nil, nil, fmt.Errorf("entity tag must match started machine")
}
if apiInfo.Tag != names.MachineTag(machineId) {
return nil, nil, fmt.Errorf("entity tag must match started machine")
}
i := &dummyInstance{
state: e.state,
id: instance.Id(fmt.Sprintf("%s-%d", e.state.name, e.state.maxId)),
ports: make(map[instance.Port]bool),
machineId: machineId,
series: series,
}
var hc *instance.HardwareCharacteristics
// To match current system capability, only provide hardware characteristics for
// environ machines, not containers.
if state.ParentId(machineId) == "" {
// We will just assume the instance hardware characteristics exactly matches
// the supplied constraints (if specified).
hc = &instance.HardwareCharacteristics{
Arch: cons.Arch,
Mem: cons.Mem,
CpuCores: cons.CpuCores,
CpuPower: cons.CpuPower,
}
// Fill in some expected instance hardware characteristics if constraints not specified.
if hc.Arch == nil {
arch := "amd64"
hc.Arch = &arch
}
if hc.Mem == nil {
mem := uint64(1024)
hc.Mem = &mem
}
if hc.CpuCores == nil {
cores := uint64(1)
hc.CpuCores = &cores
}
}
e.state.insts[i.id] = i
e.state.maxId++
e.state.ops <- OpStartInstance{
Env: e.state.name,
MachineId: machineId,
MachineNonce: machineNonce,
Constraints: cons,
Instance: i,
Info: info,
APIInfo: apiInfo,
Secret: e.ecfg().secret(),
}
return i, hc, nil
}