// TestCloudInitVerify checks that required fields are appropriately // checked for by NewCloudInit. func (*cloudinitSuite) TestCloudInitVerify(c *gc.C) { cfg := &cloudinit.MachineConfig{ Bootstrap: true, StateServingInfo: stateServingInfo, MachineId: "99", Tools: newSimpleTools("9.9.9-quantal-arble"), AuthorizedKeys: "sshkey1", Series: "quantal", AgentEnvironment: map[string]string{agent.ProviderType: "dummy"}, MongoInfo: &mongo.MongoInfo{ Info: mongo.Info{ Addrs: []string{"host:98765"}, CACert: testing.CACert, }, Password: "******", }, APIInfo: &api.Info{ Addrs: []string{"host:9999"}, CACert: testing.CACert, }, Config: minimalConfig(c), DataDir: environs.DataDir, LogDir: agent.DefaultLogDir, Jobs: normalMachineJobs, CloudInitOutputLog: cloudInitOutputLog, InstanceId: "i-bootstrap", MachineNonce: "FAKE_NONCE", MachineAgentServiceName: "jujud-machine-99", } // check that the base configuration does not give an error ci := coreCloudinit.New() for i, test := range verifyTests { // check that the base configuration does not give an error // and that a previous test hasn't mutated it accidentially. udata, err := cloudinit.NewUserdataConfig(cfg, ci) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) c.Logf("test %d. %s", i, test.err) cfg1 := *cfg test.mutate(&cfg1) udata, err = cloudinit.NewUserdataConfig(&cfg1, ci) c.Assert(err, gc.IsNil) err = udata.Configure() c.Check(err, gc.ErrorMatches, "invalid machine configuration: "+test.err) } }
func (s *configureSuite) getCloudConfig(c *gc.C, stateServer bool, vers version.Binary) *cloudinit.Config { var mcfg *envcloudinit.MachineConfig var err error if stateServer { mcfg, err = environs.NewBootstrapMachineConfig(constraints.Value{}, vers.Series) c.Assert(err, gc.IsNil) mcfg.InstanceId = "instance-id" mcfg.Jobs = []params.MachineJob{params.JobManageEnviron, params.JobHostUnits} } else { mcfg, err = environs.NewMachineConfig("0", "ya", imagemetadata.ReleasedStream, vers.Series, nil, nil, nil) c.Assert(err, gc.IsNil) mcfg.Jobs = []params.MachineJob{params.JobHostUnits} } mcfg.Tools = &tools.Tools{ Version: vers, URL: "http://testing.invalid/tools.tar.gz", } environConfig := testConfig(c, stateServer, vers) err = environs.FinishMachineConfig(mcfg, environConfig) c.Assert(err, gc.IsNil) cloudcfg := cloudinit.New() udata, err := envcloudinit.NewUserdataConfig(mcfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) return cloudcfg }
func ConfigureMachine(ctx environs.BootstrapContext, client ssh.Client, host string, machineConfig *cloudinit.MachineConfig) error { // Bootstrap is synchronous, and will spawn a subprocess // to complete the procedure. If the user hits Ctrl-C, // SIGINT is sent to the foreground process attached to // the terminal, which will be the ssh subprocess at this // point. For that reason, we do not call StopInterruptNotify // until this function completes. cloudcfg := coreCloudinit.New() cloudcfg.SetAptUpdate(machineConfig.EnableOSRefreshUpdate) cloudcfg.SetAptUpgrade(machineConfig.EnableOSUpgrade) udata, err := cloudinit.NewUserdataConfig(machineConfig, cloudcfg) if err != nil { return err } if err := udata.ConfigureJuju(); err != nil { return err } configScript, err := sshinit.ConfigureScript(cloudcfg) if err != nil { return err } script := shell.DumpFileOnErrorScript(machineConfig.CloudInitOutputLog) + configScript return sshinit.RunConfigureScript(script, sshinit.ConfigureParams{ Host: "ubuntu@" + host, Client: client, Config: cloudcfg, ProgressWriter: ctx.GetStderr(), }) }
// ProvisioningScript generates a bash script that can be // executed on a remote host to carry out the cloud-init // configuration. func ProvisioningScript(mcfg *cloudinit.MachineConfig) (string, error) { cloudcfg := coreCloudinit.New() cloudcfg.SetAptUpdate(mcfg.EnableOSRefreshUpdate) cloudcfg.SetAptUpgrade(mcfg.EnableOSUpgrade) udata, err := cloudinit.NewUserdataConfig(mcfg, cloudcfg) if err != nil { return "", errors.Annotate(err, "error generating cloud-config") } if err := udata.ConfigureJuju(); err != nil { return "", errors.Annotate(err, "error generating cloud-config") } configScript, err := sshinit.ConfigureScript(cloudcfg) if err != nil { return "", errors.Annotate(err, "error converting cloud-config to script") } var buf bytes.Buffer // Always remove the cloud-init-output.log file first, if it exists. fmt.Fprintf(&buf, "rm -f %s\n", utils.ShQuote(mcfg.CloudInitOutputLog)) // If something goes wrong, dump cloud-init-output.log to stderr. buf.WriteString(shell.DumpFileOnErrorScript(mcfg.CloudInitOutputLog)) buf.WriteString(configScript) return buf.String(), nil }
func (*cloudinitSuite) TestWindowsCloudInit(c *gc.C) { for i, test := range windowsCloudinitTests { c.Logf("test %d", i) dataDir, err := paths.DataDir(test.cfg.Series) c.Assert(err, gc.IsNil) logDir, err := paths.LogDir(test.cfg.Series) c.Assert(err, gc.IsNil) test.cfg.DataDir = dataDir test.cfg.LogDir = path.Join(logDir, "juju") ci := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(&test.cfg, ci) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) c.Check(ci, gc.NotNil) data, err := udata.Render() c.Assert(err, gc.IsNil) stringData := strings.Replace(string(data), "\r\n", "\n", -1) stringData = strings.Replace(stringData, "\t", " ", -1) stringData = strings.TrimSpace(stringData) compareString := strings.Replace(string(test.expectScripts), "\r\n", "\n", -1) compareString = strings.Replace(compareString, "\t", " ", -1) compareString = strings.TrimSpace(compareString) c.Assert(stringData, gc.Equals, compareString) } }
func cloudInitUserData(machineConfig *cloudinit.MachineConfig) ([]byte, error) { cloudConfig := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(machineConfig, cloudConfig) if err != nil { return nil, err } err = udata.Configure() if err != nil { return nil, err } // Run ifconfig to get the addresses of the internal container at least // logged in the host. cloudConfig.AddRunCmd("ifconfig") renderer, err := coreCloudinit.NewRenderer(machineConfig.Series) if err != nil { return nil, err } data, err := renderer.Render(cloudConfig) if err != nil { return nil, err } return data, nil }
// TestCloudInit checks that the output from the various tests // in cloudinitTests is well formed. func (*cloudinitSuite) TestCloudInit(c *gc.C) { for i, test := range cloudinitTests { c.Logf("test %d", i) if test.setEnvConfig { test.cfg.Config = minimalConfig(c) } ci := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(&test.cfg, ci) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) c.Check(ci, gc.NotNil) // render the cloudinit config to bytes, and then // back to a map so we can introspect it without // worrying about internal details of the cloudinit // package. data, err := udata.Render() c.Assert(err, gc.IsNil) configKeyValues := make(map[interface{}]interface{}) err = goyaml.Unmarshal(data, &configKeyValues) c.Assert(err, gc.IsNil) c.Check(configKeyValues["apt_get_wrapper"], gc.DeepEquals, map[interface{}]interface{}{ "command": "eatmydata", "enabled": "auto", }) if test.cfg.EnableOSRefreshUpdate { c.Check(configKeyValues["apt_update"], gc.Equals, true) } else { c.Check(configKeyValues["apt_update"], gc.IsNil) } if test.cfg.EnableOSUpgrade { c.Check(configKeyValues["apt_upgrade"], gc.Equals, true) } else { c.Check(configKeyValues["apt_upgrade"], gc.IsNil) } scripts := getScripts(configKeyValues) assertScriptMatch(c, scripts, test.expectScripts, !test.inexactMatch) if test.cfg.Config != nil { checkEnvConfig(c, test.cfg.Config, configKeyValues, scripts) } checkPackage(c, configKeyValues, "curl", test.cfg.EnableOSRefreshUpdate) tag := names.NewMachineTag(test.cfg.MachineId).String() acfg := getAgentConfig(c, tag, scripts) c.Assert(acfg, jc.Contains, "AGENT_SERVICE_NAME: jujud-"+tag) c.Assert(acfg, jc.Contains, "upgradedToVersion: 1.2.3\n") source := "deb http://ubuntu-cloud.archive.canonical.com/ubuntu precise-updates/cloud-tools main" needCloudArchive := test.cfg.Series == "precise" checkAptSource(c, configKeyValues, source, cloudinit.CanonicalCloudArchiveSigningKey, needCloudArchive) } }
func (*cloudinitSuite) TestCloudInitConfigure(c *gc.C) { for i, test := range cloudinitTests { test.cfg.Config = minimalConfig(c) c.Logf("test %d (Configure)", i) cloudcfg := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(&test.cfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) } }
func (s *cloudinitSuite) TestAptProxyNotWrittenIfNotSet(c *gc.C) { environConfig := minimalConfig(c) machineCfg := s.createMachineConfig(c, environConfig) cloudcfg := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(machineCfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) cmds := cloudcfg.BootCmds() c.Assert(cmds, jc.DeepEquals, []interface{}{}) }
func (s *cloudinitSuite) TestAptProxyWritten(c *gc.C) { environConfig := minimalConfig(c) environConfig, err := environConfig.Apply(map[string]interface{}{ "apt-http-proxy": "http://[email protected]", }) c.Assert(err, gc.IsNil) machineCfg := s.createMachineConfig(c, environConfig) cloudcfg := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(machineCfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) cmds := cloudcfg.BootCmds() expected := "[ -f /etc/apt/apt.conf.d/42-juju-proxy-settings ] || (printf '%s\\n' 'Acquire::http::Proxy \"http://[email protected]\";' > /etc/apt/apt.conf.d/42-juju-proxy-settings)" c.Assert(cmds, jc.DeepEquals, []interface{}{expected}) }
func configureCloudinit(mcfg *cloudinit.MachineConfig, cloudcfg *coreCloudinit.Config) (cloudinit.UserdataConfig, error) { // When bootstrapping, we only want to apt-get update/upgrade // and setup the SSH keys. The rest we leave to cloudinit/sshinit. udata, err := cloudinit.NewUserdataConfig(mcfg, cloudcfg) if err != nil { return nil, err } if mcfg.Bootstrap { err = udata.ConfigureBasic() if err != nil { return nil, err } return udata, nil } err = udata.Configure() if err != nil { return nil, err } return udata, nil }
func (*cloudinitSuite) TestCloudInitConfigureUsesGivenConfig(c *gc.C) { // Create a simple cloudinit config with a 'runcmd' statement. cloudcfg := coreCloudinit.New() script := "test script" cloudcfg.AddRunCmd(script) cloudinitTests[0].cfg.Config = minimalConfig(c) udata, err := cloudinit.NewUserdataConfig(&cloudinitTests[0].cfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) data, err := udata.Render() c.Assert(err, gc.IsNil) ciContent := make(map[interface{}]interface{}) err = goyaml.Unmarshal(data, &ciContent) c.Assert(err, gc.IsNil) // The 'runcmd' statement is at the beginning of the list // of 'runcmd' statements. runCmd := ciContent["runcmd"].([]interface{}) c.Check(runCmd[0], gc.Equals, script) }
func (s *provisionerSuite) TestProvisioningScript(c *gc.C) { const series = coretesting.FakeDefaultSeries const arch = "amd64" defer fakeSSH{ Series: series, Arch: arch, InitUbuntuUser: true, }.install(c).Restore() machineId, err := manual.ProvisionMachine(s.getArgs(c)) c.Assert(err, gc.IsNil) err = s.State.UpdateEnvironConfig( map[string]interface{}{ "enable-os-upgrade": false, }, nil, nil) c.Assert(err, gc.IsNil) mcfg, err := client.MachineConfig(s.State, machineId, agent.BootstrapNonce, "/var/lib/juju") c.Assert(err, gc.IsNil) script, err := manual.ProvisioningScript(mcfg) c.Assert(err, gc.IsNil) cloudcfg := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(mcfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.ConfigureJuju() c.Assert(err, gc.IsNil) cloudcfg.SetAptUpgrade(false) sshinitScript, err := sshinit.ConfigureScript(cloudcfg) c.Assert(err, gc.IsNil) removeLogFile := "rm -f '/var/log/cloud-init-output.log'\n" expectedScript := removeLogFile + shell.DumpFileOnErrorScript("/var/log/cloud-init-output.log") + sshinitScript c.Assert(script, gc.Equals, expectedScript) }
func (s *cloudinitSuite) TestProxyWritten(c *gc.C) { environConfig := minimalConfig(c) environConfig, err := environConfig.Apply(map[string]interface{}{ "http-proxy": "http://[email protected]", "no-proxy": "localhost,10.0.3.1", }) c.Assert(err, gc.IsNil) machineCfg := s.createMachineConfig(c, environConfig) cloudcfg := coreCloudinit.New() udata, err := cloudinit.NewUserdataConfig(machineCfg, cloudcfg) c.Assert(err, gc.IsNil) err = udata.Configure() c.Assert(err, gc.IsNil) cmds := cloudcfg.RunCmds() first := `([ ! -e /home/ubuntu/.profile ] || grep -q '.juju-proxy' /home/ubuntu/.profile) || printf '\n# Added by juju\n[ -f "$HOME/.juju-proxy" ] && . "$HOME/.juju-proxy"\n' >> /home/ubuntu/.profile` expected := []interface{}{ `export http_proxy=http://[email protected]`, `export HTTP_PROXY=http://[email protected]`, `export no_proxy=localhost,10.0.3.1`, `export NO_PROXY=localhost,10.0.3.1`, `[ -e /home/ubuntu ] && (printf '%s\n' 'export http_proxy=http://[email protected] export HTTP_PROXY=http://[email protected] export no_proxy=localhost,10.0.3.1 export NO_PROXY=localhost,10.0.3.1' > /home/ubuntu/.juju-proxy && chown ubuntu:ubuntu /home/ubuntu/.juju-proxy)`, } found := false for i, cmd := range cmds { if cmd == first { c.Assert(cmds[i+1:i+6], jc.DeepEquals, expected) found = true break } } c.Assert(found, jc.IsTrue) }