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)
}
// ProvisioningScript returns a shell script that, when run,
// provisions a machine agent on the machine executing the script.
func (c *Client) ProvisioningScript(args params.ProvisioningScriptParams) (params.ProvisioningScriptResult, error) {
var result params.ProvisioningScriptResult
icfg, err := InstanceConfig(c.api.state, args.MachineId, args.Nonce, args.DataDir)
if err != nil {
return result, err
}
// Until DisablePackageCommands is retired, for backwards
// compatibility, we must respect the client's request and
// override any environment settings the user may have specified.
// If the client does specify this setting, it will only ever be
// true. False indicates the client doesn't care and we should use
// what's specified in the environments.yaml file.
if args.DisablePackageCommands {
icfg.EnableOSRefreshUpdate = false
icfg.EnableOSUpgrade = false
} else if cfg, err := c.api.state.EnvironConfig(); err != nil {
return result, err
} else {
icfg.EnableOSUpgrade = cfg.EnableOSUpgrade()
icfg.EnableOSRefreshUpdate = cfg.EnableOSRefreshUpdate()
}
result.Script, err = manual.ProvisioningScript(icfg)
return result, err
}
// ProvisioningScript returns a shell script that, when run,
// provisions a machine agent on the machine executing the script.
func (c *Client) ProvisioningScript(args params.ProvisioningScriptParams) (params.ProvisioningScriptResult, error) {
var result params.ProvisioningScriptResult
mcfg, err := MachineConfig(c.api.state, args.MachineId, args.Nonce, args.DataDir)
if err != nil {
return result, err
}
mcfg.DisablePackageCommands = args.DisablePackageCommands
result.Script, err = manual.ProvisioningScript(mcfg)
return result, err
}
func (s *clientSuite) TestProvisioningScript(c *gc.C) {
// Inject a machine and then call the ProvisioningScript API.
// The result should be the same as when calling MachineConfig,
// converting it to a cloudinit.MachineConfig, and disabling
// apt_upgrade.
apiParams := params.AddMachineParams{
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: instance.MustParseHardware("arch=amd64"),
}
machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
c.Assert(err, jc.ErrorIsNil)
c.Assert(len(machines), gc.Equals, 1)
machineId := machines[0].Machine
// Call ProvisioningScript. Normally ProvisioningScript and
// MachineConfig are mutually exclusive; both of them will
// allocate a api password for the machine agent.
script, err := s.APIState.Client().ProvisioningScript(params.ProvisioningScriptParams{
MachineId: machineId,
Nonce: apiParams.Nonce,
})
c.Assert(err, jc.ErrorIsNil)
icfg, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "")
c.Assert(err, jc.ErrorIsNil)
provisioningScript, err := manual.ProvisioningScript(icfg)
c.Assert(err, jc.ErrorIsNil)
// ProvisioningScript internally calls MachineConfig,
// which allocates a new, random password. Everything
// about the scripts should be the same other than
// the line containing "oldpassword" from agent.conf.
scriptLines := strings.Split(script, "\n")
provisioningScriptLines := strings.Split(provisioningScript, "\n")
c.Assert(scriptLines, gc.HasLen, len(provisioningScriptLines))
for i, line := range scriptLines {
if strings.Contains(line, "oldpassword") {
continue
}
c.Assert(line, gc.Equals, provisioningScriptLines[i])
}
}
// ProvisioningScript returns a shell script that, when run,
// provisions a machine agent on the machine executing the script.
func (c *Client) ProvisioningScript(args params.ProvisioningScriptParams) (params.ProvisioningScriptResult, error) {
if err := c.checkCanWrite(); err != nil {
return params.ProvisioningScriptResult{}, err
}
var result params.ProvisioningScriptResult
icfg, err := InstanceConfig(c.api.state(), args.MachineId, args.Nonce, args.DataDir)
if err != nil {
return result, common.ServerError(errors.Annotate(
err, "getting instance config",
))
}
// Until DisablePackageCommands is retired, for backwards
// compatibility, we must respect the client's request and
// override any model settings the user may have specified.
// If the client does specify this setting, it will only ever be
// true. False indicates the client doesn't care and we should use
// what's specified in the environment config.
if args.DisablePackageCommands {
icfg.EnableOSRefreshUpdate = false
icfg.EnableOSUpgrade = false
} else if cfg, err := c.api.stateAccessor.ModelConfig(); err != nil {
return result, common.ServerError(errors.Annotate(
err, "getting model config",
))
} else {
icfg.EnableOSUpgrade = cfg.EnableOSUpgrade()
icfg.EnableOSRefreshUpdate = cfg.EnableOSRefreshUpdate()
}
result.Script, err = manual.ProvisioningScript(icfg)
if err != nil {
return result, common.ServerError(errors.Annotate(
err, "getting provisioning script",
))
}
return result, nil
}
func (s *provisionerSuite) TestProvisioningScript(c *gc.C) {
var series = series.LatestLts()
const arch = "amd64"
defer fakeSSH{
Series: series,
Arch: arch,
InitUbuntuUser: true,
}.install(c).Restore()
machineId, err := manual.ProvisionMachine(s.getArgs(c))
c.Assert(err, jc.ErrorIsNil)
err = s.State.UpdateModelConfig(
map[string]interface{}{
"enable-os-upgrade": false,
}, nil, nil)
c.Assert(err, jc.ErrorIsNil)
icfg, err := client.InstanceConfig(s.State, machineId, agent.BootstrapNonce, "/var/lib/juju")
c.Assert(err, jc.ErrorIsNil)
script, err := manual.ProvisioningScript(icfg)
c.Assert(err, jc.ErrorIsNil)
cloudcfg, err := cloudinit.New(series)
c.Assert(err, jc.ErrorIsNil)
udata, err := cloudconfig.NewUserdataConfig(icfg, cloudcfg)
c.Assert(err, jc.ErrorIsNil)
err = udata.ConfigureJuju()
c.Assert(err, jc.ErrorIsNil)
cloudcfg.SetSystemUpgrade(false)
provisioningScript, err := cloudcfg.RenderScript()
c.Assert(err, jc.ErrorIsNil)
removeLogFile := "rm -f '/var/log/cloud-init-output.log'\n"
expectedScript := removeLogFile + shell.DumpFileOnErrorScript("/var/log/cloud-init-output.log") + provisioningScript
c.Assert(script, gc.Equals, expectedScript)
}
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)
}