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, state.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 *provisionerSuite) TestFinishMachineConfig(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)
// Now check what we would've configured it with.
mcfg, err := client.MachineConfig(s.State, machineId, state.BootstrapNonce, "/var/lib/juju")
c.Assert(err, gc.IsNil)
c.Check(mcfg, gc.NotNil)
c.Check(mcfg.APIInfo, gc.NotNil)
c.Check(mcfg.StateInfo, gc.NotNil)
stateInfo, apiInfo, err := s.APIConn.Environ.StateInfo()
c.Assert(err, gc.IsNil)
c.Check(mcfg.APIInfo.Addrs, gc.DeepEquals, apiInfo.Addrs)
c.Check(mcfg.StateInfo.Addrs, gc.DeepEquals, stateInfo.Addrs)
}
func (s *provisionerSuite) TestProvisionMachine(c *gc.C) {
const series = "precise"
const arch = "amd64"
args := s.getArgs(c)
hostname := args.Host
args.Host = "ubuntu@" + args.Host
envtesting.RemoveTools(c, s.Conn.Environ.Storage())
defer fakeSSH{
Series: series,
Arch: arch,
InitUbuntuUser: true,
SkipProvisionAgent: true,
}.install(c).Restore()
// Attempt to provision a machine with no tools available, expect it to fail.
machineId, err := manual.ProvisionMachine(args)
c.Assert(err, jc.Satisfies, params.IsCodeNotFound)
c.Assert(machineId, gc.Equals, "")
cfg := s.Conn.Environ.Config()
number, ok := cfg.AgentVersion()
c.Assert(ok, jc.IsTrue)
binVersion := version.Binary{number, series, arch}
envtesting.AssertUploadFakeToolsVersions(c, s.Conn.Environ.Storage(), binVersion)
for i, errorCode := range []int{255, 0} {
c.Logf("test %d: code %d", i, errorCode)
defer fakeSSH{
Series: series,
Arch: arch,
InitUbuntuUser: true,
ProvisionAgentExitCode: errorCode,
}.install(c).Restore()
machineId, err = manual.ProvisionMachine(args)
if errorCode != 0 {
c.Assert(err, gc.ErrorMatches, fmt.Sprintf("subprocess encountered error code %d", errorCode))
c.Assert(machineId, gc.Equals, "")
} else {
c.Assert(err, gc.IsNil)
c.Assert(machineId, gc.Not(gc.Equals), "")
// machine ID will be incremented. Even though we failed and the
// machine is removed, the ID is not reused.
c.Assert(machineId, gc.Equals, fmt.Sprint(i+1))
m, err := s.State.Machine(machineId)
c.Assert(err, gc.IsNil)
instanceId, err := m.InstanceId()
c.Assert(err, gc.IsNil)
c.Assert(instanceId, gc.Equals, instance.Id("manual:"+hostname))
}
}
// Attempting to provision a machine twice should fail. We effect
// this by checking for existing juju upstart configurations.
defer fakeSSH{
Provisioned: true,
InitUbuntuUser: true,
SkipDetection: true,
SkipProvisionAgent: true,
}.install(c).Restore()
_, err = manual.ProvisionMachine(args)
c.Assert(err, gc.Equals, manual.ErrProvisioned)
defer fakeSSH{
Provisioned: true,
CheckProvisionedExitCode: 255,
InitUbuntuUser: true,
SkipDetection: true,
SkipProvisionAgent: true,
}.install(c).Restore()
_, err = manual.ProvisionMachine(args)
c.Assert(err, gc.ErrorMatches, "error checking if provisioned: subprocess encountered error code 255")
}
func (c *AddMachineCommand) Run(ctx *cmd.Context) error {
if c.Placement != nil && c.Placement.Scope == "ssh" {
args := manual.ProvisionMachineArgs{
Host: c.Placement.Directive,
EnvName: c.EnvName,
Stdin: ctx.Stdin,
Stdout: ctx.Stdout,
Stderr: ctx.Stderr,
}
_, err := manual.ProvisionMachine(args)
return err
}
client, err := juju.NewAPIClientFromName(c.EnvName)
if err != nil {
return err
}
defer client.Close()
if c.Placement != nil && c.Placement.Scope == instance.MachineScope {
// It does not make sense to add-machine <id>.
return fmt.Errorf("machine-id cannot be specified when adding machines")
}
machineParams := params.AddMachineParams{
Placement: c.Placement,
Series: c.Series,
Constraints: c.Constraints,
Jobs: []params.MachineJob{params.JobHostUnits},
}
results, err := client.AddMachines([]params.AddMachineParams{machineParams})
if params.IsCodeNotImplemented(err) {
if c.Placement != nil {
containerType, parseErr := instance.ParseContainerType(c.Placement.Scope)
if parseErr != nil {
// The user specified a non-container placement directive:
// return original API not implemented error.
return err
}
machineParams.ContainerType = containerType
machineParams.ParentId = c.Placement.Directive
machineParams.Placement = nil
}
logger.Infof(
"AddMachinesWithPlacement not supported by the API server, " +
"falling back to 1.18 compatibility mode",
)
results, err = client.AddMachines1dot18([]params.AddMachineParams{machineParams})
}
if err != nil {
return err
}
// Currently, only one machine is added, but in future there may be several added in one call.
machineInfo := results[0]
if machineInfo.Error != nil {
return machineInfo.Error
}
machineId := machineInfo.Machine
if names.IsContainerMachine(machineId) {
ctx.Infof("created container %v", machineId)
} else {
ctx.Infof("created machine %v", machineId)
}
return nil
}