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 }