// FinishMachineConfig sets fields on a MachineConfig that can be determined by
// inspecting a plain config.Config and the machine constraints at the last
// moment before bootstrapping. It assumes that the supplied Config comes from
// an environment that has passed through all the validation checks in the
// Bootstrap func, and that has set an agent-version (via FindBootstrapTools,
// or otherwise).
// TODO(fwereade) This function is not meant to be "good" in any serious way:
// it is better that this functionality be collected in one place here than
// that it be spread out across 3 or 4 providers, but this is its only
// redeeming feature.
func FinishMachineConfig(mcfg *cloudinit.MachineConfig, cfg *config.Config, cons constraints.Value) (err error) {
defer utils.ErrorContextf(&err, "cannot complete machine configuration")
// Everything needs the environment's authorized keys.
authKeys := cfg.AuthorizedKeys()
if authKeys == "" {
return fmt.Errorf("environment configuration has no authorized-keys")
}
mcfg.AuthorizedKeys = authKeys
if mcfg.MachineEnvironment == nil {
mcfg.MachineEnvironment = make(map[string]string)
}
mcfg.MachineEnvironment[osenv.JujuProviderType] = cfg.Type()
if !mcfg.StateServer {
return nil
}
// These settings are only appropriate at bootstrap time. At the
// moment, the only state server is the bootstrap node, but this
// will probably change.
if mcfg.APIInfo != nil || mcfg.StateInfo != nil {
return fmt.Errorf("machine configuration already has api/state info")
}
caCert, hasCACert := cfg.CACert()
if !hasCACert {
return fmt.Errorf("environment configuration has no ca-cert")
}
password := cfg.AdminSecret()
if password == "" {
return fmt.Errorf("environment configuration has no admin-secret")
}
passwordHash := utils.PasswordHash(password)
mcfg.APIInfo = &api.Info{Password: passwordHash, CACert: caCert}
mcfg.StateInfo = &state.Info{Password: passwordHash, CACert: caCert}
mcfg.StatePort = cfg.StatePort()
mcfg.APIPort = cfg.APIPort()
mcfg.Constraints = cons
if mcfg.Config, err = BootstrapConfig(cfg); err != nil {
return err
}
// These really are directly relevant to running a state server.
cert, key, err := cfg.GenerateStateServerCertAndKey()
if err != nil {
return fmt.Errorf("cannot generate state server certificate: %v", err)
}
mcfg.StateServerCert = cert
mcfg.StateServerKey = key
return nil
}
// internalStartInstance allocates and starts a MAAS node. It is used both
// for the implementation of StartInstance, and to initialize the bootstrap
// node.
// The instance will be set up for the same series for which you pass tools.
// All tools in possibleTools must be for the same series.
// machineConfig will be filled out with further details, but should contain
// MachineID, MachineNonce, StateInfo, and APIInfo.
// TODO(bug 1199847): Some of this work can be shared between providers.
func (environ *maasEnviron) internalStartInstance(cons constraints.Value, possibleTools tools.List, machineConfig *cloudinit.MachineConfig) (_ *maasInstance, err error) {
series := possibleTools.Series()
if len(series) != 1 {
panic(fmt.Errorf("should have gotten tools for one series, got %v", series))
}
var instance *maasInstance
if node, tools, err := environ.acquireNode(cons, possibleTools); err != nil {
return nil, fmt.Errorf("cannot run instances: %v", err)
} else {
instance = &maasInstance{&node, environ}
machineConfig.Tools = tools
}
defer func() {
if err != nil {
if err := environ.releaseInstance(instance); err != nil {
logger.Errorf("error releasing failed instance: %v", err)
}
}
}()
hostname, err := instance.DNSName()
if err != nil {
return nil, err
}
info := machineInfo{hostname}
runCmd, err := info.cloudinitRunCmd()
if err != nil {
return nil, err
}
if err := environs.FinishMachineConfig(machineConfig, environ.Config(), cons); err != nil {
return nil, err
}
// Explicitly specify that the lxc containers use the network bridge defined above.
machineConfig.MachineEnvironment[osenv.JujuLxcBridge] = "br0"
userdata, err := environs.ComposeUserData(
machineConfig,
runCmd,
createBridgeNetwork(),
"service networking restart",
)
if err != nil {
msg := fmt.Errorf("could not compose userdata for bootstrap node: %v", err)
return nil, msg
}
logger.Debugf("maas user data; %d bytes", len(userdata))
if err := environ.startNode(*instance.maasObject, series[0], userdata); err != nil {
return nil, err
}
logger.Debugf("started instance %q", instance.Id())
return instance, nil
}
// internalStartInstance is the internal version of StartInstance, used by
// Bootstrap as well as via StartInstance itself.
// machineConfig will be filled out with further details, but should contain
// MachineID, MachineNonce, StateInfo, and APIInfo.
// TODO(bug 1199847): Some of this work can be shared between providers.
func (e *environ) internalStartInstance(cons constraints.Value, possibleTools tools.List, machineConfig *cloudinit.MachineConfig) (instance.Instance, *instance.HardwareCharacteristics, error) {
series := possibleTools.Series()
if len(series) != 1 {
panic(fmt.Errorf("should have gotten tools for one series, got %v", series))
}
arches := possibleTools.Arches()
spec, err := findInstanceSpec(e, &instances.InstanceConstraint{
Region: e.ecfg().region(),
Series: series[0],
Arches: arches,
Constraints: cons,
})
if err != nil {
return nil, nil, err
}
tools, err := possibleTools.Match(tools.Filter{Arch: spec.Image.Arch})
if err != nil {
return nil, nil, fmt.Errorf("chosen architecture %v not present in %v", spec.Image.Arch, arches)
}
machineConfig.Tools = tools[0]
if err := environs.FinishMachineConfig(machineConfig, e.Config(), cons); err != nil {
return nil, nil, err
}
userData, err := environs.ComposeUserData(machineConfig)
if err != nil {
return nil, nil, fmt.Errorf("cannot make user data: %v", err)
}
log.Debugf("environs/openstack: openstack user data; %d bytes", len(userData))
withPublicIP := e.ecfg().useFloatingIP()
var publicIP *nova.FloatingIP
if withPublicIP {
if fip, err := e.allocatePublicIP(); err != nil {
return nil, nil, fmt.Errorf("cannot allocate a public IP as needed: %v", err)
} else {
publicIP = fip
log.Infof("environs/openstack: allocated public IP %s", publicIP.IP)
}
}
config := e.Config()
groups, err := e.setUpGroups(machineConfig.MachineId, config.StatePort(), config.APIPort())
if err != nil {
return nil, nil, fmt.Errorf("cannot set up groups: %v", err)
}
var groupNames = make([]nova.SecurityGroupName, len(groups))
for i, g := range groups {
groupNames[i] = nova.SecurityGroupName{g.Name}
}
var server *nova.Entity
for a := shortAttempt.Start(); a.Next(); {
server, err = e.nova().RunServer(nova.RunServerOpts{
Name: e.machineFullName(machineConfig.MachineId),
FlavorId: spec.InstanceType.Id,
ImageId: spec.Image.Id,
UserData: userData,
SecurityGroupNames: groupNames,
})
if err == nil || !gooseerrors.IsNotFound(err) {
break
}
}
if err != nil {
return nil, nil, fmt.Errorf("cannot run instance: %v", err)
}
detail, err := e.nova().GetServer(server.Id)
if err != nil {
return nil, nil, fmt.Errorf("cannot get started instance: %v", err)
}
inst := &openstackInstance{
e: e,
ServerDetail: detail,
arch: &spec.Image.Arch,
instType: &spec.InstanceType,
}
log.Infof("environs/openstack: started instance %q", inst.Id())
if withPublicIP {
if err := e.assignPublicIP(publicIP, string(inst.Id())); err != nil {
if err := e.terminateInstances([]instance.Id{inst.Id()}); err != nil {
// ignore the failure at this stage, just log it
log.Debugf("environs/openstack: failed to terminate instance %q: %v", inst.Id(), err)
}
return nil, nil, fmt.Errorf("cannot assign public address %s to instance %q: %v", publicIP.IP, inst.Id(), err)
}
log.Infof("environs/openstack: assigned public IP %s to %q", publicIP.IP, inst.Id())
}
return inst, inst.hardwareCharacteristics(), nil
}
// internalStartInstance is the internal version of StartInstance, used by
// Bootstrap as well as via StartInstance itself.
// TODO(bug 1199847): Some of this work can be shared between providers.
func (e *environ) internalStartInstance(cons constraints.Value, possibleTools tools.List, machineConfig *cloudinit.MachineConfig) (instance.Instance, *instance.HardwareCharacteristics, error) {
series := possibleTools.Series()
if len(series) != 1 {
panic(fmt.Errorf("should have gotten tools for one series, got %v", series))
}
arches := possibleTools.Arches()
storage := ebsStorage
baseURLs, err := e.getImageBaseURLs()
if err != nil {
return nil, nil, err
}
spec, err := findInstanceSpec(baseURLs, &instances.InstanceConstraint{
Region: e.ecfg().region(),
Series: series[0],
Arches: arches,
Constraints: cons,
Storage: &storage,
})
if err != nil {
return nil, nil, err
}
tools, err := possibleTools.Match(tools.Filter{Arch: spec.Image.Arch})
if err != nil {
return nil, nil, fmt.Errorf("chosen architecture %v not present in %v", spec.Image.Arch, arches)
}
machineConfig.Tools = tools[0]
if err := environs.FinishMachineConfig(machineConfig, e.Config(), cons); err != nil {
return nil, nil, err
}
userData, err := environs.ComposeUserData(machineConfig)
if err != nil {
return nil, nil, fmt.Errorf("cannot make user data: %v", err)
}
log.Debugf("environs/ec2: ec2 user data; %d bytes", len(userData))
config := e.Config()
groups, err := e.setUpGroups(machineConfig.MachineId, config.StatePort(), config.APIPort())
if err != nil {
return nil, nil, fmt.Errorf("cannot set up groups: %v", err)
}
var instances *ec2.RunInstancesResp
for a := shortAttempt.Start(); a.Next(); {
instances, err = e.ec2().RunInstances(&ec2.RunInstances{
ImageId: spec.Image.Id,
MinCount: 1,
MaxCount: 1,
UserData: userData,
InstanceType: spec.InstanceType.Name,
SecurityGroups: groups,
})
if err == nil || ec2ErrCode(err) != "InvalidGroup.NotFound" {
break
}
}
if err != nil {
return nil, nil, fmt.Errorf("cannot run instances: %v", err)
}
if len(instances.Instances) != 1 {
return nil, nil, fmt.Errorf("expected 1 started instance, got %d", len(instances.Instances))
}
inst := &ec2Instance{
e: e,
Instance: &instances.Instances[0],
arch: &spec.Image.Arch,
instType: &spec.InstanceType,
}
log.Infof("environs/ec2: started instance %q", inst.Id())
return inst, inst.hardwareCharacteristics(), nil
}
// internalStartInstance does the provider-specific work of starting an
// instance. The code in StartInstance is actually largely agnostic across
// the EC2/OpenStack/MAAS/Azure providers.
// The instance will be set up for the same series for which you pass tools.
// All tools in possibleTools must be for the same series.
// machineConfig will be filled out with further details, but should contain
// MachineID, MachineNonce, StateInfo, and APIInfo.
// TODO(bug 1199847): Some of this work can be shared between providers.
func (env *azureEnviron) internalStartInstance(cons constraints.Value, possibleTools tools.List, machineConfig *cloudinit.MachineConfig) (_ instance.Instance, err error) {
// Declaring "err" in the function signature so that we can "defer"
// any cleanup that needs to run during error returns.
series := possibleTools.Series()
if len(series) != 1 {
panic(fmt.Errorf("should have gotten tools for one series, got %v", series))
}
err = environs.FinishMachineConfig(machineConfig, env.Config(), cons)
if err != nil {
return nil, err
}
// Pick tools. Needed for the custom data (which is what we normally
// call userdata).
machineConfig.Tools = possibleTools[0]
logger.Infof("picked tools %q", machineConfig.Tools)
// Compose userdata.
userData, err := makeCustomData(machineConfig)
if err != nil {
return nil, fmt.Errorf("custom data: %v", err)
}
azure, err := env.getManagementAPI()
if err != nil {
return nil, err
}
defer env.releaseManagementAPI(azure)
service, err := newHostedService(azure.ManagementAPI, env.getEnvPrefix(), env.getAffinityGroupName())
if err != nil {
return nil, err
}
serviceName := service.ServiceName
// If we fail after this point, clean up the hosted service.
defer func() {
if err != nil {
azure.DestroyHostedService(
&gwacl.DestroyHostedServiceRequest{
ServiceName: serviceName,
})
}
}()
// TODO: use simplestreams to get the name of the image given
// the constraints provided by Juju.
// In the meantime we use a temporary Saucy image containing a
// cloud-init package which supports Azure.
sourceImageName := "b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-13_10-amd64-server-DEVELOPMENT-20130713-Juju_ALPHA-en-us-30GB"
// virtualNetworkName is the virtual network to which all the
// deployments in this environment belong.
virtualNetworkName := env.getVirtualNetworkName()
// 1. Create an OS Disk.
vhd := env.newOSDisk(sourceImageName)
// 2. Create a Role for a Linux machine.
role := env.newRole(vhd, userData, roleHostname)
// 3. Create the Deployment object.
deployment := env.newDeployment(role, serviceName, serviceName, virtualNetworkName)
err = azure.AddDeployment(deployment, serviceName)
if err != nil {
return nil, err
}
var inst instance.Instance
// From here on, remember to shut down the instance before returning
// any error.
defer func() {
if err != nil && inst != nil {
err2 := env.StopInstances([]instance.Instance{inst})
if err2 != nil {
// Failure upon failure. Log it, but return
// the original error.
logger.Errorf("error releasing failed instance: %v", err)
}
}
}()
// Assign the returned instance to 'inst' so that the deferred method
// above can perform its check.
inst, err = env.getInstance(serviceName)
if err != nil {
return nil, err
}
return inst, nil
}
// internalStartInstance does the provider-specific work of starting an
// instance. The code in StartInstance is actually largely agnostic across
// the EC2/OpenStack/MAAS/Azure providers.
// The instance will be set up for the same series for which you pass tools.
// All tools in possibleTools must be for the same series.
// machineConfig will be filled out with further details, but should contain
// MachineID, MachineNonce, StateInfo, and APIInfo.
// TODO(bug 1199847): Some of this work can be shared between providers.
func (env *azureEnviron) internalStartInstance(cons constraints.Value, possibleTools tools.List, machineConfig *cloudinit.MachineConfig) (_ instance.Instance, err error) {
// Declaring "err" in the function signature so that we can "defer"
// any cleanup that needs to run during error returns.
series := possibleTools.Series()
if len(series) != 1 {
panic(fmt.Errorf("should have gotten tools for one series, got %v", series))
}
err = environs.FinishMachineConfig(machineConfig, env.Config(), cons)
if err != nil {
return nil, err
}
// Pick tools. Needed for the custom data (which is what we normally
// call userdata).
machineConfig.Tools = possibleTools[0]
logger.Infof("picked tools %q", machineConfig.Tools)
// Compose userdata.
userData, err := makeCustomData(machineConfig)
if err != nil {
return nil, fmt.Errorf("custom data: %v", err)
}
azure, err := env.getManagementAPI()
if err != nil {
return nil, err
}
defer env.releaseManagementAPI(azure)
snap := env.getSnapshot()
location := snap.ecfg.location()
service, err := newHostedService(azure.ManagementAPI, env.getEnvPrefix(), env.getAffinityGroupName(), location)
if err != nil {
return nil, err
}
serviceName := service.ServiceName
// If we fail after this point, clean up the hosted service.
defer func() {
if err != nil {
azure.DestroyHostedService(
&gwacl.DestroyHostedServiceRequest{
ServiceName: serviceName,
})
}
}()
instanceType, sourceImageName, err := env.selectInstanceTypeAndImage(cons, series[0], location)
if err != nil {
return nil, err
}
// virtualNetworkName is the virtual network to which all the
// deployments in this environment belong.
virtualNetworkName := env.getVirtualNetworkName()
// 1. Create an OS Disk.
vhd := env.newOSDisk(sourceImageName)
// 2. Create a Role for a Linux machine.
role := env.newRole(instanceType, vhd, userData, roleHostname)
// 3. Create the Deployment object.
deployment := env.newDeployment(role, serviceName, serviceName, virtualNetworkName)
err = azure.AddDeployment(deployment, serviceName)
if err != nil {
return nil, err
}
var inst instance.Instance
// From here on, remember to shut down the instance before returning
// any error.
defer func() {
if err != nil && inst != nil {
err2 := env.StopInstances([]instance.Instance{inst})
if err2 != nil {
// Failure upon failure. Log it, but return
// the original error.
logger.Errorf("error releasing failed instance: %v", err)
}
}
}()
// Assign the returned instance to 'inst' so that the deferred method
// above can perform its check.
inst, err = env.getInstance(serviceName)
if err != nil {
return nil, err
}
return inst, nil
}
