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)
}
// templateUserData returns a minimal user data necessary for the template.
// This should have the authorized keys, base packages, the cloud archive if
// necessary, initial apt proxy config, and it should do the apt-get
// update/upgrade initially.
func templateUserData(
series string,
authorizedKeys string,
aptProxy proxy.Settings,
enablePackageUpdates bool,
enableOSUpgrades bool,
) ([]byte, error) {
config := corecloudinit.New()
config.AddScripts(
"set -xe", // ensure we run all the scripts or abort.
)
config.AddSSHAuthorizedKeys(authorizedKeys)
if enablePackageUpdates {
cloudinit.MaybeAddCloudArchiveCloudTools(config, series)
}
cloudinit.AddAptCommands(aptProxy, config, enablePackageUpdates, enableOSUpgrades)
config.AddScripts(
fmt.Sprintf(
"printf '%%s\n' %s > %s",
utils.ShQuote(templateShutdownUpstartScript),
templateShutdownUpstartFilename,
))
renderer, err := corecloudinit.NewRenderer(series)
if err != nil {
return nil, err
}
data, err := renderer.Render(config)
if err != nil {
return nil, err
}
return data, 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
}
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 (S) TestSetOutput(c *gc.C) {
type test struct {
kind cloudinit.OutputKind
stdout string
stderr string
}
tests := []test{{
cloudinit.OutAll, "a", "",
}, {
cloudinit.OutAll, "", "b",
}, {
cloudinit.OutInit, "a", "b",
}, {
cloudinit.OutAll, "a", "b",
}, {
cloudinit.OutAll, "", "",
}}
cfg := cloudinit.New()
stdout, stderr := cfg.Output(cloudinit.OutAll)
c.Assert(stdout, gc.Equals, "")
c.Assert(stderr, gc.Equals, "")
for i, t := range tests {
c.Logf("test %d: %+v", i, t)
cfg.SetOutput(t.kind, t.stdout, t.stderr)
stdout, stderr = cfg.Output(t.kind)
c.Assert(stdout, gc.Equals, t.stdout)
c.Assert(stderr, gc.Equals, t.stderr)
}
}
func (s *provisionerSuite) TestProvisioningScript(c *gc.C) {
const series = "precise"
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)
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()
err = cloudinit.ConfigureJuju(mcfg, cloudcfg)
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 *configureSuite) TestAptGetWrapper(c *gc.C) {
aptgetRegexp := "(.|\n)* $(which eatmydata || true) " + regexp.QuoteMeta(sshinit.Aptget)
cfg := cloudinit.New()
cfg.SetAptUpdate(true)
cfg.SetAptGetWrapper("eatmydata")
assertScriptMatches(c, cfg, aptgetRegexp, false)
}
// 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()
err := cloudinit.Configure(&test.cfg, cloudcfg)
c.Assert(err, gc.IsNil)
}
}
func (s *configureSuite) TestAptUpgrade(c *gc.C) {
// apt-get upgrade is only run if AptUpgrade is set.
aptGetUpgradePattern := aptgetRegexp + "upgrade(.|\n)*"
cfg := cloudinit.New()
cfg.SetAptUpdate(true)
cfg.AddAptSource("source", "key", nil)
assertScriptMatches(c, cfg, aptGetUpgradePattern, false)
cfg.SetAptUpgrade(true)
assertScriptMatches(c, cfg, aptGetUpgradePattern, true)
}
func (S) TestOutput(c *gc.C) {
for _, t := range ctests {
cfg := cloudinit.New()
t.setOption(cfg)
data, err := cfg.Render()
c.Assert(err, gc.IsNil)
c.Assert(data, gc.NotNil)
c.Assert(string(data), gc.Equals, header+t.expect, gc.Commentf("test %q output differs", t.name))
}
}
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) TestRunCmds(c *gc.C) {
cfg := cloudinit.New()
c.Assert(cfg.RunCmds(), gc.HasLen, 0)
cfg.AddScripts("a", "b")
cfg.AddRunCmdArgs("c", "d")
cfg.AddRunCmd("e")
c.Assert(cfg.RunCmds(), gc.DeepEquals, []interface{}{
"a", "b", []string{"c", "d"}, "e",
})
}
func (S) TestPackages(c *gc.C) {
cfg := cloudinit.New()
c.Assert(cfg.Packages(), gc.HasLen, 0)
cfg.AddPackage("a b c")
cfg.AddPackage("d!")
expectedPackages := []string{"a b c", "d!"}
c.Assert(cfg.Packages(), gc.DeepEquals, expectedPackages)
cfg.AddPackageFromTargetRelease("package", "series")
expectedPackages = append(expectedPackages, "--target-release 'series' 'package'")
c.Assert(cfg.Packages(), gc.DeepEquals, expectedPackages)
}
//#cloud-config
//packages:
//- juju
//- ubuntu
func ExampleConfig() {
cfg := cloudinit.New()
cfg.AddPackage("juju")
cfg.AddPackage("ubuntu")
data, err := cfg.Render()
if err != nil {
fmt.Printf("render error: %v", err)
return
}
fmt.Printf("%s", data)
}
func (S) TestWindowsRender(c *gc.C) {
compareOutput := "#ps1_sysnative\r\n\r\npowershell"
cfg := cloudinit.New()
cfg.AddRunCmd("powershell")
render, err := cloudinit.NewRenderer("win8")
c.Assert(err, gc.IsNil)
data, err := render.Render(cfg)
c.Assert(err, gc.IsNil)
c.Assert(data, gc.NotNil)
c.Assert(string(data), gc.Equals, compareOutput, gc.Commentf("test %q output differs", "windows renderer"))
}
// 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)
}
}
// ComposeUserData fills out the provided cloudinit configuration structure
// so it is suitable for initialising a machine with the given configuration,
// and then renders it and returns it as a binary (gzipped) blob of user data.
//
// If the provided cloudcfg is nil, a new one will be created internally.
func ComposeUserData(mcfg *cloudinit.MachineConfig, cloudcfg *coreCloudinit.Config) ([]byte, error) {
if cloudcfg == nil {
cloudcfg = coreCloudinit.New()
}
if err := configureCloudinit(mcfg, cloudcfg); err != nil {
return nil, err
}
data, err := cloudcfg.Render()
logger.Tracef("Generated cloud init:\n%s", string(data))
if err != nil {
return nil, err
}
return utils.Gzip(data), nil
}
func (s *configureSuite) TestAptUpdate(c *gc.C) {
// apt-get update is run if either AptUpdate is set,
// or apt sources are defined.
aptGetUpdatePattern := aptgetRegexp + "update(.|\n)*"
cfg := cloudinit.New()
c.Assert(cfg.AptUpdate(), gc.Equals, false)
c.Assert(cfg.AptSources(), gc.HasLen, 0)
assertScriptMatches(c, cfg, aptGetUpdatePattern, false)
cfg.SetAptUpdate(true)
assertScriptMatches(c, cfg, aptGetUpdatePattern, true)
cfg.SetAptUpdate(false)
cfg.AddAptSource("source", "key", nil)
assertScriptMatches(c, cfg, aptGetUpdatePattern, true)
}
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 (s *configureSuite) TestAptUpdate(c *gc.C) {
// apt-get update is run only if AptUpdate is set.
aptGetUpdatePattern := aptgetRegexp + "update(.|\n)*"
cfg := cloudinit.New()
c.Assert(cfg.AptUpdate(), gc.Equals, false)
c.Assert(cfg.AptSources(), gc.HasLen, 0)
assertScriptMatches(c, cfg, aptGetUpdatePattern, false)
cfg.SetAptUpdate(true)
assertScriptMatches(c, cfg, aptGetUpdatePattern, true)
// If we add sources, but disable updates, display an error.
cfg.SetAptUpdate(false)
cfg.AddAptSource("source", "key", nil)
_, err := sshinit.ConfigureScript(cfg)
c.Check(err, gc.ErrorMatches, "update sources were specified, but OS updates have been disabled.")
}
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)
}
// 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()
if err := cloudinit.ConfigureJuju(mcfg, cloudcfg); err != nil {
return "", err
}
// Explicitly disabling apt_upgrade so as not to trample
// the target machine's existing configuration.
cloudcfg.SetAptUpgrade(false)
configScript, err := sshinit.ConfigureScript(cloudcfg)
if err != nil {
return "", err
}
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 (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
}
// 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)
x := make(map[interface{}]interface{})
err = goyaml.Unmarshal(data, &x)
c.Assert(err, gc.IsNil)
c.Check(x["apt_upgrade"], gc.Equals, true)
c.Check(x["apt_update"], gc.Equals, true)
scripts := getScripts(x)
assertScriptMatch(c, scripts, test.expectScripts, !test.inexactMatch)
if test.cfg.Config != nil {
checkEnvConfig(c, test.cfg.Config, x, scripts)
}
checkPackage(c, x, "git", 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, x, source, cloudinit.CanonicalCloudArchiveSigningKey, needCloudArchive)
}
}
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)
}
