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) }