func (s *machinerSuite) TestSetMachineAddresses(c *gc.C) {
c.Assert(s.machine0.Addresses(), gc.HasLen, 0)
c.Assert(s.machine1.Addresses(), gc.HasLen, 0)
addresses := network.NewAddresses("127.0.0.1", "8.8.8.8")
args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{
{Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)},
{Tag: "machine-0", Addresses: params.FromNetworkAddresses(addresses)},
{Tag: "machine-42", Addresses: params.FromNetworkAddresses(addresses)},
}}
result, err := s.machiner.SetMachineAddresses(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{nil},
{apiservertesting.ErrUnauthorized},
{apiservertesting.ErrUnauthorized},
},
})
err = s.machine1.Refresh()
c.Assert(err, jc.ErrorIsNil)
expectedAddresses := network.NewAddresses("8.8.8.8", "127.0.0.1")
c.Assert(s.machine1.MachineAddresses(), gc.DeepEquals, expectedAddresses)
err = s.machine0.Refresh()
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.machine0.MachineAddresses(), gc.HasLen, 0)
}
func (s *InstancePollerSuite) TestSetProviderAddressesFailure(c *gc.C) {
s.st.SetErrors(
errors.New("pow!"), // m1 := FindEntity("1")
nil, // m2 := FindEntity("2")
errors.New("FAIL"), // m2.SetProviderAddresses()
errors.NotProvisionedf("machine 42"), // FindEntity("3") (ensure wrapping is preserved)
)
oldAddrs := network.NewAddresses("0.1.2.3", "127.0.0.1", "8.8.8.8")
newAddrs := network.NewAddresses("1.2.3.4", "8.4.4.8", "2001:db8::")
s.st.SetMachineInfo(c, machineInfo{id: "1", providerAddresses: oldAddrs})
s.st.SetMachineInfo(c, machineInfo{id: "2", providerAddresses: nil})
result, err := s.api.SetProviderAddresses(params.SetMachinesAddresses{
MachineAddresses: []params.MachineAddresses{
{Tag: "machine-1"},
{Tag: "machine-2", Addresses: params.FromNetworkAddresses(newAddrs...)},
{Tag: "machine-3"},
}},
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, s.machineErrorResults)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckFindEntityCall(c, 1, "2")
s.st.CheckSetProviderAddressesCall(c, 2, newAddrs)
s.st.CheckFindEntityCall(c, 3, "3")
// Ensure machine 2 wasn't updated.
machine, err := s.st.Machine("2")
c.Assert(err, jc.ErrorIsNil)
c.Assert(machine.ProviderAddresses(), gc.HasLen, 0)
}
func (s *InstancePollerSuite) TestProviderAddressesSuccess(c *gc.C) {
addrs := network.NewAddresses("0.1.2.3", "127.0.0.1", "8.8.8.8")
expectedAddresses := params.FromNetworkAddresses(addrs...)
s.st.SetMachineInfo(c, machineInfo{id: "1", providerAddresses: addrs})
s.st.SetMachineInfo(c, machineInfo{id: "2", providerAddresses: nil})
result, err := s.api.ProviderAddresses(s.mixedEntities)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, params.MachineAddressesResults{
Results: []params.MachineAddressesResult{
{Addresses: expectedAddresses},
{Addresses: nil},
{Error: apiservertesting.NotFoundError("machine 42")},
{Error: apiservertesting.ServerError(`"application-unknown" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"unit-missing-1" is not a valid machine tag`)},
{Error: apiservertesting.ServerError(`"" is not a valid tag`)},
{Error: apiservertesting.ServerError(`"42" is not a valid tag`)},
}},
)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckCall(c, 1, "ProviderAddresses")
s.st.CheckFindEntityCall(c, 2, "2")
s.st.CheckCall(c, 3, "ProviderAddresses")
s.st.CheckFindEntityCall(c, 4, "42")
}
func (s *clientSuite) TestClientAddMachinesWithInstanceIdSomeErrors(c *gc.C) {
apiParams := make([]params.AddMachineParams, 3)
addrs := network.NewAddresses("1.2.3.4")
hc := instance.MustParseHardware("mem=4G")
for i := 0; i < 3; i++ {
apiParams[i] = params.AddMachineParams{
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
InstanceId: instance.Id(fmt.Sprintf("1234-%d", i)),
Nonce: "foo",
HardwareCharacteristics: hc,
Addrs: params.FromNetworkAddresses(addrs...),
}
}
// This will cause the last add-machine to fail.
apiParams[2].Nonce = ""
machines, err := s.APIState.Client().AddMachines(apiParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(len(machines), gc.Equals, 3)
for i, machineResult := range machines {
if i == 2 {
c.Assert(machineResult.Error, gc.NotNil)
c.Assert(machineResult.Error, gc.ErrorMatches, "cannot add a new machine: cannot add a machine with an instance id and no nonce")
} else {
c.Assert(machineResult.Machine, gc.DeepEquals, strconv.Itoa(i))
s.checkMachine(c, machineResult.Machine, series.LatestLts(), apiParams[i].Constraints.String())
instanceId := fmt.Sprintf("1234-%d", i)
s.checkInstance(c, machineResult.Machine, instanceId, "foo", hc, addrs)
}
}
}
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 *machinerSuite) TestSetEmptyMachineAddresses(c *gc.C) {
// Set some addresses so we can ensure they are removed.
addresses := network.NewAddresses("127.0.0.1", "8.8.8.8")
args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{
{Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)},
}}
result, err := s.machiner.SetMachineAddresses(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{nil},
},
})
err = s.machine1.Refresh()
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 2)
args.MachineAddresses[0].Addresses = nil
result, err = s.machiner.SetMachineAddresses(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.DeepEquals, params.ErrorResults{
Results: []params.ErrorResult{
{nil},
},
})
err = s.machine1.Refresh()
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 0)
}
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},
})
}
// gatherMachineParams collects all the information we know about the machine
// we are about to provision. It will SSH into that machine as the ubuntu user.
// The hostname supplied should not include a username.
// If we can, we will reverse lookup the hostname by its IP address, and use
// the DNS resolved name, rather than the name that was supplied
func gatherMachineParams(hostname string) (*params.AddMachineParams, error) {
// Generate a unique nonce for the machine.
uuid, err := utils.NewUUID()
if err != nil {
return nil, err
}
var addrs []network.Address
if addr, err := HostAddress(hostname); err != nil {
logger.Warningf("failed to compute public address for %q: %v", hostname, err)
} else {
addrs = append(addrs, addr)
}
provisioned, err := checkProvisioned(hostname)
if err != nil {
err = fmt.Errorf("error checking if provisioned: %v", err)
return nil, err
}
if provisioned {
return nil, ErrProvisioned
}
hc, series, err := DetectSeriesAndHardwareCharacteristics(hostname)
if err != nil {
err = fmt.Errorf("error detecting hardware characteristics: %v", err)
return nil, err
}
// There will never be a corresponding "instance" that any provider
// knows about. This is fine, and works well with the provisioner
// task. The provisioner task will happily remove any and all dead
// machines from state, but will ignore the associated instance ID
// if it isn't one that the environment provider knows about.
// Also, manually provisioned machines don't have the JobManageNetworking.
// This ensures that the networker is running in non-intrusive mode
// and never touches the network configuration files.
// No JobManageNetworking here due to manual provisioning.
instanceId := instance.Id(manualInstancePrefix + hostname)
nonce := fmt.Sprintf("%s:%s", instanceId, uuid.String())
machineParams := ¶ms.AddMachineParams{
Series: series,
HardwareCharacteristics: hc,
InstanceId: instanceId,
Nonce: nonce,
Addrs: params.FromNetworkAddresses(addrs),
Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits},
}
return machineParams, nil
}
// SetMachineAddresses sets the machine determined addresses of the machine.
func (m *Machine) SetMachineAddresses(addresses []network.Address) error {
var result params.ErrorResults
args := params.SetMachinesAddresses{
MachineAddresses: []params.MachineAddresses{
{Tag: m.Tag().String(), Addresses: params.FromNetworkAddresses(addresses...)},
},
}
err := m.st.facade.FacadeCall("SetMachineAddresses", args, &result)
if err != nil {
return err
}
return result.OneError()
}
func (s *MachineSuite) TestProviderAddressesSuccess(c *gc.C) {
var called int
addresses := network.NewAddresses("2001:db8::1", "0.1.2.3")
results := params.MachineAddressesResults{
Results: []params.MachineAddressesResult{{
Addresses: params.FromNetworkAddresses(addresses),
}}}
apiCaller := successAPICaller(c, "ProviderAddresses", entitiesArgs, results, &called)
machine := instancepoller.NewMachine(apiCaller, s.tag, params.Alive)
addrs, err := machine.ProviderAddresses()
c.Check(err, jc.ErrorIsNil)
c.Check(addrs, jc.DeepEquals, addresses)
c.Check(called, gc.Equals, 1)
}
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 *MachineSuite) TestSetProviderAddressesSuccess(c *gc.C) {
var called int
addresses := network.NewAddresses("2001:db8::1", "0.1.2.3")
expectArgs := params.SetMachinesAddresses{
MachineAddresses: []params.MachineAddresses{{
Tag: "machine-42",
Addresses: params.FromNetworkAddresses(addresses),
}}}
results := params.ErrorResults{
Results: []params.ErrorResult{{Error: nil}},
}
apiCaller := successAPICaller(c, "SetProviderAddresses", expectArgs, results, &called)
machine := instancepoller.NewMachine(apiCaller, s.tag, params.Alive)
err := machine.SetProviderAddresses(addresses...)
c.Check(err, jc.ErrorIsNil)
c.Check(called, gc.Equals, 1)
}
// ProviderAddresses returns the list of all known provider addresses
// for each given entity. Only machine tags are accepted.
func (a *InstancePollerAPI) ProviderAddresses(args params.Entities) (params.MachineAddressesResults, error) {
result := params.MachineAddressesResults{
Results: make([]params.MachineAddressesResult, len(args.Entities)),
}
canAccess, err := a.accessMachine()
if err != nil {
return result, err
}
for i, arg := range args.Entities {
machine, err := a.getOneMachine(arg.Tag, canAccess)
if err == nil {
addrs := machine.ProviderAddresses()
result.Results[i].Addresses = params.FromNetworkAddresses(addrs)
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (s *InstancePollerSuite) TestSetProviderAddressesSuccess(c *gc.C) {
oldAddrs := network.NewAddresses("0.1.2.3", "127.0.0.1", "8.8.8.8")
newAddrs := network.NewAddresses("1.2.3.4", "8.4.4.8", "2001:db8::")
s.st.SetMachineInfo(c, machineInfo{id: "1", providerAddresses: oldAddrs})
s.st.SetMachineInfo(c, machineInfo{id: "2", providerAddresses: nil})
result, err := s.api.SetProviderAddresses(params.SetMachinesAddresses{
MachineAddresses: []params.MachineAddresses{
{Tag: "machine-1", Addresses: nil},
{Tag: "machine-2", Addresses: params.FromNetworkAddresses(newAddrs...)},
{Tag: "machine-42"},
{Tag: "application-unknown"},
{Tag: "invalid-tag"},
{Tag: "unit-missing-1"},
{Tag: ""},
{Tag: "42"},
}},
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, s.mixedErrorResults)
s.st.CheckFindEntityCall(c, 0, "1")
s.st.CheckSetProviderAddressesCall(c, 1, []network.Address{})
s.st.CheckFindEntityCall(c, 2, "2")
s.st.CheckSetProviderAddressesCall(c, 3, newAddrs)
s.st.CheckFindEntityCall(c, 4, "42")
// Ensure machines were updated.
machine, err := s.st.Machine("1")
c.Assert(err, jc.ErrorIsNil)
c.Assert(machine.ProviderAddresses(), gc.HasLen, 0)
machine, err = s.st.Machine("2")
c.Assert(err, jc.ErrorIsNil)
c.Assert(machine.ProviderAddresses(), jc.DeepEquals, newAddrs)
}