// StartInstance is specified in the Environ interface. func (env *localEnviron) StartInstance( machineId, machineNonce, series string, cons constraints.Value, stateInfo *state.Info, apiInfo *api.Info, ) (instance.Instance, *instance.HardwareCharacteristics, error) { // We pretty much ignore the constraints. logger.Debugf("StartInstance: %q, %s", machineId, series) possibleTools, err := environs.FindInstanceTools(env, series, cons) if err != nil { return nil, nil, err } if len(possibleTools) == 0 { return nil, nil, fmt.Errorf("could not find appropriate tools") } tools := possibleTools[0] logger.Debugf("tools: %#v", tools) inst, err := env.containerManager.StartContainer( machineId, series, machineNonce, tools, env.config.Config, stateInfo, apiInfo) if err != nil { return nil, nil, err } // TODO(thumper): return some hardware characteristics. return inst, nil, nil }
func (s *ToolsSuite) TestFindInstanceTools(c *C) { for i, test := range findInstanceToolsTests { c.Logf("\ntest %d: %s", i, test.info) s.Reset(c, map[string]interface{}{ "agent-version": test.agentVersion.String(), }) available := s.uploadPrivate(c, test.available...) if len(available) > 0 { // These should never be chosen. s.uploadPublic(c, vAll...) } cons := constraints.MustParse(test.constraints) actual, err := environs.FindInstanceTools(s.env, test.series, cons) if test.err != nil { if len(actual) > 0 { c.Logf(actual.String()) } c.Check(err, DeepEquals, &errors.NotFoundError{test.err, ""}) continue } expect := map[version.Binary]string{} for _, expected := range test.expect { expect[expected] = available[expected] } c.Check(actual.URLs(), DeepEquals, expect) } }
// TODO(bug 1199847): This work can be shared between providers. func (e *environ) StartInstance(machineId, machineNonce string, series string, cons constraints.Value, stateInfo *state.Info, apiInfo *api.Info) (instance.Instance, *instance.HardwareCharacteristics, error) { 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 } machineConfig := environs.NewMachineConfig(machineId, machineNonce, stateInfo, apiInfo) return e.internalStartInstance(cons, possibleTools, machineConfig) }
// StartInstance is specified in the Environ interface. // TODO(bug 1199847): This work can be shared between providers. func (env *azureEnviron) StartInstance(machineID, machineNonce string, series string, cons constraints.Value, stateInfo *state.Info, apiInfo *api.Info) (instance.Instance, *instance.HardwareCharacteristics, error) { possibleTools, err := environs.FindInstanceTools(env, series, cons) if err != nil { return nil, nil, err } err = environs.CheckToolsSeries(possibleTools, series) if err != nil { return nil, nil, err } machineConfig := environs.NewMachineConfig(machineID, machineNonce, stateInfo, apiInfo) // TODO(bug 1193998) - return instance hardware characteristics as well. inst, err := env.internalStartInstance(cons, possibleTools, machineConfig) return inst, nil, err }
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 }