func (s *machineConfigSuite) TestSecureConnectionDisallowed(c *gc.C) {
// StateServingInfo without CAPrivateKey will not allow secure connections.
servingInfo := state.StateServingInfo{
PrivateKey: jujutesting.ServerKey,
Cert: jujutesting.ServerCert,
SharedSecret: "really, really secret",
APIPort: 4321,
StatePort: 1234,
}
s.State.SetStateServingInfo(servingInfo)
hc := instance.MustParseHardware("mem=4G arch=amd64")
apiParams := params.AddMachineParams{
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: hc,
}
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
instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "")
c.Assert(err, jc.ErrorIsNil)
c.Assert(instanceConfig.AgentEnvironment[agent.AllowsSecureConnection], gc.Equals, "false")
}
func (s *machineConfigSuite) TestMachineConfig(c *gc.C) {
addrs := network.NewAddresses("1.2.3.4")
hc := instance.MustParseHardware("mem=4G arch=amd64")
apiParams := params.AddMachineParams{
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: hc,
Addrs: params.FromNetworkAddresses(addrs),
}
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
instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "")
c.Assert(err, jc.ErrorIsNil)
envConfig, err := s.State.EnvironConfig()
c.Assert(err, jc.ErrorIsNil)
mongoAddrs := s.State.MongoConnectionInfo().Addrs
apiAddrs := []string{net.JoinHostPort("localhost", strconv.Itoa(envConfig.APIPort()))}
c.Check(instanceConfig.MongoInfo.Addrs, gc.DeepEquals, mongoAddrs)
c.Check(instanceConfig.APIInfo.Addrs, gc.DeepEquals, apiAddrs)
toolsURL := fmt.Sprintf("https://%s/environment/%s/tools/%s",
apiAddrs[0], jujutesting.EnvironmentTag.Id(), instanceConfig.Tools.Version)
c.Assert(instanceConfig.Tools.URL, gc.Equals, toolsURL)
c.Assert(instanceConfig.AgentEnvironment[agent.AllowsSecureConnection], gc.Equals, "true")
}
func (s *machineConfigSuite) TestMachineConfig(c *gc.C) {
addrs := network.NewAddresses("1.2.3.4")
hc := instance.MustParseHardware("mem=4G arch=amd64")
apiParams := params.AddMachineParams{
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: hc,
Addrs: params.FromNetworkAddresses(addrs...),
}
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
instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "")
c.Assert(err, jc.ErrorIsNil)
cfg, err := s.State.ControllerConfig()
c.Assert(err, jc.ErrorIsNil)
apiAddrs := []string{net.JoinHostPort("localhost", strconv.Itoa(cfg.APIPort()))}
c.Check(instanceConfig.APIInfo.Addrs, gc.DeepEquals, apiAddrs)
toolsURL := fmt.Sprintf("https://%s/model/%s/tools/%s",
apiAddrs[0], jujutesting.ModelTag.Id(), instanceConfig.AgentVersion())
c.Assert(instanceConfig.ToolsList().URLs(), jc.DeepEquals, map[version.Binary][]string{
instanceConfig.AgentVersion(): []string{toolsURL},
})
}
func (s *machineConfigSuite) TestMachineConfigNoArch(c *gc.C) {
apiParams := params.AddMachineParams{
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
}
machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
c.Assert(err, jc.ErrorIsNil)
c.Assert(len(machines), gc.Equals, 1)
_, err = client.InstanceConfig(s.State, machines[0].Machine, apiParams.Nonce, "")
c.Assert(err, gc.ErrorMatches, fmt.Sprintf("arch is not set for %q", "machine-"+machines[0].Machine))
}
func (s *machineConfigSuite) TestMachineConfigNoTools(c *gc.C) {
s.PatchValue(&envtools.DefaultBaseURL, "")
addrs := network.NewAddresses("1.2.3.4")
hc := instance.MustParseHardware("mem=4G arch=amd64")
apiParams := params.AddMachineParams{
Series: "quantal",
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id("1234"),
Nonce: "foo",
HardwareCharacteristics: hc,
Addrs: params.FromNetworkAddresses(addrs),
}
machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams})
c.Assert(err, jc.ErrorIsNil)
_, err = client.InstanceConfig(s.State, machines[0].Machine, apiParams.Nonce, "")
c.Assert(err, gc.ErrorMatches, coretools.ErrNoMatches.Error())
}
func (s *provisionerSuite) TestFinishInstancConfig(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)
// Now check what we would've configured it with.
icfg, err := client.InstanceConfig(s.State, machineId, agent.BootstrapNonce, "/var/lib/juju")
c.Assert(err, jc.ErrorIsNil)
c.Check(icfg, gc.NotNil)
c.Check(icfg.APIInfo, gc.NotNil)
apiInfo := s.APIInfo(c)
c.Check(icfg.APIInfo.Addrs, gc.DeepEquals, apiInfo.Addrs)
}
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])
}
}
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)
}