// 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
}