func (*CloudInitSuite) TestUserData(c *C) { testJujuHome := c.MkDir() defer config.SetJujuHome(config.SetJujuHome(testJujuHome)) tools := &tools.Tools{ URL: "http://foo.com/tools/juju1.2.3-linux-amd64.tgz", Binary: version.MustParseBinary("1.2.3-linux-amd64"), } envConfig, err := config.New(map[string]interface{}{ "type": "maas", "name": "foo", "default-series": "series", "authorized-keys": "keys", "ca-cert": testing.CACert, }) c.Assert(err, IsNil) cfg := &cloudinit.MachineConfig{ MachineId: "10", MachineNonce: "5432", Tools: tools, StateServerCert: []byte(testing.ServerCert), StateServerKey: []byte(testing.ServerKey), StateInfo: &state.Info{ Password: "******", CACert: []byte("CA CERT\n" + testing.CACert), }, APIInfo: &api.Info{ Password: "******", CACert: []byte("CA CERT\n" + testing.CACert), }, DataDir: environs.DataDir, Config: envConfig, StatePort: envConfig.StatePort(), APIPort: envConfig.APIPort(), StateServer: true, ProviderType: "dummy", } script1 := "script1" script2 := "script2" scripts := []string{script1, script2} result, err := environs.ComposeUserData(cfg, scripts...) c.Assert(err, IsNil) unzipped, err := utils.Gunzip(result) c.Assert(err, IsNil) config := make(map[interface{}]interface{}) err = goyaml.Unmarshal(unzipped, &config) c.Assert(err, IsNil) // Just check that the cloudinit config looks good. c.Check(config["apt_upgrade"], Equals, true) // The scripts given to userData where added as the first // commands to be run. runCmd := config["runcmd"].([]interface{}) c.Check(runCmd[0], Equals, script1) c.Check(runCmd[1], Equals, script2) }
// makeCustomData produces custom data for Azure. This is a base64-encoded // zipfile of cloudinit userdata. func makeCustomData(cfg *cloudinit.MachineConfig) (string, error) { zipData, err := environs.ComposeUserData(cfg) if err != nil { return "", fmt.Errorf("failure while generating custom data: %v", err) } logger.Debugf("user data; %d bytes", len(zipData)) encodedData := base64.StdEncoding.EncodeToString(zipData) logger.Debugf("base64-encoded custom data: %d bytes", len(encodedData)) return encodedData, nil }
func (*customDataSuite) TestMakeCustomDataEncodesUserData(c *gc.C) { cfg := makeMachineConfig(c) encodedData, err := makeCustomData(cfg) c.Assert(err, gc.IsNil) data, err := base64.StdEncoding.DecodeString(encodedData) c.Assert(err, gc.IsNil) reference, err := environs.ComposeUserData(cfg) c.Assert(err, gc.IsNil) c.Check(data, gc.DeepEquals, reference) }
// 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 }