// 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-linux-arble"), AuthorizedKeys: "sshkey1", AgentEnvironment: map[string]string{agent.ProviderType: "dummy"}, StateInfo: &state.Info{ 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: environs.CloudInitOutputLog, InstanceId: "i-bootstrap", MachineNonce: "FAKE_NONCE", SystemPrivateSSHKey: "private rsa key", 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. err := cloudinit.Configure(cfg, ci) c.Assert(err, gc.IsNil) c.Logf("test %d. %s", i, test.err) cfg1 := *cfg test.mutate(&cfg1) err = cloudinit.Configure(&cfg1, ci) c.Assert(err, gc.ErrorMatches, "invalid machine configuration: "+test.err) } }
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() err = cloudinit.Configure(machineCfg, cloudcfg) 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) }
func configureCloudinit(mcfg *cloudinit.MachineConfig, cloudcfg *coreCloudinit.Config) error { // When bootstrapping, we only want to apt-get update/upgrade // and setup the SSH keys. The rest we leave to cloudinit/sshinit. if mcfg.Bootstrap { return cloudinit.ConfigureBasic(mcfg, cloudcfg) } return cloudinit.Configure(mcfg, cloudcfg) }
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() err := cloudinit.Configure(&test.cfg, cloudcfg) c.Assert(err, gc.IsNil) } }
func (s *cloudinitSuite) TestAptProxyNotWrittenIfNotSet(c *gc.C) { environConfig := minimalConfig(c) machineCfg := s.createMachineConfig(c, environConfig) cloudcfg := coreCloudinit.New() err := cloudinit.Configure(machineCfg, cloudcfg) 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() err = cloudinit.Configure(machineCfg, cloudcfg) 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 cloudInitUserData(machineConfig *cloudinit.MachineConfig) ([]byte, error) { cloudConfig := coreCloudinit.New() err := cloudinit.Configure(machineConfig, cloudConfig) 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") data, err := cloudConfig.Render() if err != nil { return nil, err } return data, 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) err := cloudinit.Configure(&cloudinitTests[0].cfg, cloudcfg) c.Assert(err, gc.IsNil) data, err := cloudcfg.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) }
// 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() err := cloudinit.Configure(&test.cfg, ci) 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 := ci.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", }) c.Check(configKeyValues["apt_upgrade"], gc.Equals, true) c.Check(configKeyValues["apt_update"], gc.Equals, true) 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", true) tag := names.NewMachineTag(test.cfg.MachineId).String() acfg := getAgentConfig(c, tag, scripts) c.Assert(acfg, jc.Contains, "AGENT_SERVICE_NAME: jujud-"+tag) source := "deb http://ubuntu-cloud.archive.canonical.com/ubuntu precise-updates/cloud-tools main" needCloudArchive := test.cfg.Tools.Version.Series == "precise" checkAptSource(c, configKeyValues, source, cloudinit.CanonicalCloudArchiveSigningKey, needCloudArchive) } }
func (s *configureSuite) getCloudConfig(c *gc.C, stateServer bool, vers version.Binary) *cloudinit.Config { var mcfg *envcloudinit.MachineConfig if stateServer { mcfg = environs.NewBootstrapMachineConfig("private-key") mcfg.InstanceId = "instance-id" mcfg.Jobs = []params.MachineJob{params.JobManageEnviron, params.JobHostUnits} } else { mcfg = environs.NewMachineConfig("0", "ya", nil, nil, nil) mcfg.Jobs = []params.MachineJob{params.JobHostUnits} } mcfg.Tools = &tools.Tools{ Version: vers, URL: "file:///var/lib/juju/storage/" + envtools.StorageName(vers), } environConfig := testConfig(c, stateServer, vers) err := environs.FinishMachineConfig(mcfg, environConfig, constraints.Value{}) c.Assert(err, gc.IsNil) cloudcfg := cloudinit.New() err = envcloudinit.Configure(mcfg, cloudcfg) c.Assert(err, gc.IsNil) return cloudcfg }