From 477298ddcd89fd75236b04e091a2223691d280ab Mon Sep 17 00:00:00 2001 From: Simon Richardson Date: Fri, 18 Aug 2023 17:15:47 +0100 Subject: [PATCH] Make controller-config a dependency in state This is another follow up PR that removes controller config from being called directly inside of state. This should nearly clean up the last of the controller config call sites from inside state. Once this is done, and after the peergrouper has removed it controller config dependency, then we should be able to remove controller config from state. --- .../facades/agent/deployer/deployer_test.go | 13 +- apiserver/facades/agent/machine/machiner.go | 6 +- .../facades/agent/uniter/networkinfo_test.go | 99 +++++++++-- apiserver/facades/agent/uniter/uniter_test.go | 41 ++++- .../highavailability/highavailability_test.go | 30 +++- .../instancepoller/instancepoller.go | 19 ++- .../instancepoller/instancepoller_test.go | 22 +-- .../controller/instancepoller/mock_test.go | 10 +- .../controller/instancepoller/state.go | 9 +- cmd/jujud/agent/util_test.go | 5 +- juju/testing/utils.go | 6 +- state/allwatcher_internal_test.go | 11 +- state/controller_test.go | 17 +- state/machine.go | 21 +-- state/machine_test.go | 158 +++++++++++++----- state/relationunit_test.go | 4 +- state/state_test.go | 3 + state/unit_test.go | 42 +++-- testing/factory/factory.go | 4 +- 19 files changed, 386 insertions(+), 134 deletions(-) diff --git a/apiserver/facades/agent/deployer/deployer_test.go b/apiserver/facades/agent/deployer/deployer_test.go index 4d53532f157..d9b80515cc2 100644 --- a/apiserver/facades/agent/deployer/deployer_test.go +++ b/apiserver/facades/agent/deployer/deployer_test.go @@ -334,17 +334,20 @@ func (s *deployerSuite) TestRemove(c *gc.C) { } func (s *deployerSuite) TestConnectionInfo(c *gc.C) { - err := s.machine0.SetProviderAddresses(network.NewSpaceAddress("0.1.2.3", network.WithScope(network.ScopePublic)), - network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal))) + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = s.machine0.SetProviderAddresses(controllerConfig, + network.NewSpaceAddress("0.1.2.3", network.WithScope(network.ScopePublic)), + network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), + ) c.Assert(err, jc.ErrorIsNil) // Default host port scope is public, so change the cloud-local one hostPorts := network.NewSpaceHostPorts(1234, "0.1.2.3", "1.2.3.4") hostPorts[1].Scope = network.ScopeCloudLocal - st := s.ControllerModel(c).State() - controllerConfig, err := st.ControllerConfig() - c.Assert(err, jc.ErrorIsNil) err = st.SetAPIHostPorts(controllerConfig, []network.SpaceHostPorts{hostPorts}) c.Assert(err, jc.ErrorIsNil) diff --git a/apiserver/facades/agent/machine/machiner.go b/apiserver/facades/agent/machine/machiner.go index 2a680e111e1..1837e8f7dfb 100644 --- a/apiserver/facades/agent/machine/machiner.go +++ b/apiserver/facades/agent/machine/machiner.go @@ -85,6 +85,10 @@ func (api *MachinerAPI) SetMachineAddresses(ctx context.Context, args params.Set if err != nil { return results, err } + controllerConfig, err := api.st.ControllerConfig() + if err != nil { + return results, err + } for i, arg := range args.MachineAddresses { m, err := api.getMachine(arg.Tag, canModify) if err != nil { @@ -96,7 +100,7 @@ func (api *MachinerAPI) SetMachineAddresses(ctx context.Context, args params.Set results.Results[i].Error = apiservererrors.ServerError(err) continue } - if err := m.SetMachineAddresses(addresses...); err != nil { + if err := m.SetMachineAddresses(controllerConfig, addresses...); err != nil { results.Results[i].Error = apiservererrors.ServerError(err) } } diff --git a/apiserver/facades/agent/uniter/networkinfo_test.go b/apiserver/facades/agent/uniter/networkinfo_test.go index 2c9f58b01b0..47cd350140d 100644 --- a/apiserver/facades/agent/uniter/networkinfo_test.go +++ b/apiserver/facades/agent/uniter/networkinfo_test.go @@ -55,10 +55,16 @@ func (s *networkInfoSuite) TestNetworksForRelation(c *gc.C) { c.Assert(err, jc.ErrorIsNil) id, err := prr.pu0.AssignedMachineId() c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().Machine(id) + + st := s.ControllerModel(c).State() + machine, err := st.Machine(id) + c.Assert(err, jc.ErrorIsNil) + + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) err = machine.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("10.2.3.4", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopePublic)), ) @@ -135,10 +141,13 @@ func (s *networkInfoSuite) TestProcessAPIRequestForBinding(c *gc.C) { machine, err := st.Machine(id) c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // We need at least one address on the machine itself, because these are // retrieved up-front to use as a fallback when we fail to locate addresses // on link-layer devices. - err = machine.SetProviderAddresses(network.NewSpaceAddress("10.2.3.4/16")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("10.2.3.4/16")) c.Assert(err, jc.ErrorIsNil) s.addDevicesWithAddresses(c, machine, "10.2.3.4/16", "100.2.3.4/24") @@ -194,10 +203,13 @@ func (s *networkInfoSuite) TestProcessAPIRequestBridgeWithSameIPOverNIC(c *gc.C) ip := "10.2.3.4/16" + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // We need at least one address on the machine itself, because these are // retrieved up-front to use as a fallback when we fail to locate addresses // on link-layer devices. - err = machine.SetProviderAddresses(network.NewSpaceAddress(ip)) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress(ip)) c.Assert(err, jc.ErrorIsNil) // Create a NIC and bridge, but also add the IP to the NIC to simulate @@ -244,8 +256,13 @@ func (s *networkInfoSuite) TestAPIRequestForRelationIAASHostNameIngressNoEgress( host := "host.at.somewhere" ip := "100.2.3.4" + st := s.ControllerModel(c).State() + + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + addr := network.NewSpaceAddress(host) - err = machine.SetProviderAddresses(addr) + err = machine.SetProviderAddresses(controllerConfig, addr) c.Assert(err, jc.ErrorIsNil) lookup := func(addr string) ([]string, error) { @@ -356,7 +373,12 @@ func (s *networkInfoSuite) TestNetworksForRelationWithSpaces(c *gc.C) { c.Assert(err, jc.ErrorIsNil) id, err := prr.pu0.AssignedMachineId() c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().Machine(id) + + st := s.ControllerModel(c).State() + machine, err := st.Machine(id) + c.Assert(err, jc.ErrorIsNil) + + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) addresses := []network.SpaceAddress{ @@ -365,7 +387,7 @@ func (s *networkInfoSuite) TestNetworksForRelationWithSpaces(c *gc.C) { network.NewSpaceAddress("10.2.3.4", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopePublic)), } - err = machine.SetProviderAddresses(addresses...) + err = machine.SetProviderAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) s.addDevicesWithAddresses(c, machine, "1.2.3.4/16", "2.2.3.4/16", "10.2.3.4/16", "4.3.2.1/16") @@ -393,10 +415,16 @@ func (s *networkInfoSuite) TestNetworksForRelationRemoteRelation(c *gc.C) { c.Assert(err, jc.ErrorIsNil) id, err := prr.ru0.AssignedMachineId() c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().Machine(id) + + st := s.ControllerModel(c).State() + machine, err := st.Machine(id) + c.Assert(err, jc.ErrorIsNil) + + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) err = machine.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopePublic)), ) @@ -418,10 +446,16 @@ func (s *networkInfoSuite) TestNetworksForRelationRemoteRelationNoPublicAddr(c * c.Assert(err, jc.ErrorIsNil) id, err := prr.ru0.AssignedMachineId() c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().Machine(id) + + st := s.ControllerModel(c).State() + machine, err := st.Machine(id) + c.Assert(err, jc.ErrorIsNil) + + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) err = machine.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), ) c.Assert(err, jc.ErrorIsNil) @@ -442,7 +476,12 @@ func (s *networkInfoSuite) TestNetworksForRelationRemoteRelationDelayedPublicAdd c.Assert(err, jc.ErrorIsNil) id, err := prr.ru0.AssignedMachineId() c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().Machine(id) + + st := s.ControllerModel(c).State() + machine, err := st.Machine(id) + c.Assert(err, jc.ErrorIsNil) + + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) retryFactory := func() retry.CallArgs { @@ -454,7 +493,9 @@ func (s *networkInfoSuite) TestNetworksForRelationRemoteRelationDelayedPublicAdd // Set the address after one failed retrieval attempt. if attempt == 1 { err := machine.SetProviderAddresses( - network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopePublic))) + controllerConfig, + network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopePublic)), + ) c.Assert(err, jc.ErrorIsNil) } }, @@ -477,7 +518,12 @@ func (s *networkInfoSuite) TestNetworksForRelationRemoteRelationDelayedPrivateAd c.Assert(err, jc.ErrorIsNil) id, err := prr.ru0.AssignedMachineId() c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().Machine(id) + + st := s.ControllerModel(c).State() + machine, err := st.Machine(id) + c.Assert(err, jc.ErrorIsNil) + + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) // The first attempt is for the public address. @@ -502,7 +548,10 @@ func (s *networkInfoSuite) TestNetworksForRelationRemoteRelationDelayedPrivateAd NotifyFunc: func(lastError error, attempt int) { // Set the private address after one failed retrieval attempt. if attempt == 1 { - err := machine.SetProviderAddresses(network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopeCloudLocal))) + err := machine.SetProviderAddresses( + controllerConfig, + network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopeCloudLocal)), + ) c.Assert(err, jc.ErrorIsNil) } }, @@ -712,7 +761,8 @@ func (s *networkInfoSuite) TestMachineNetworkInfos(c *gc.C) { unit, err := app.AddUnit(state.AddUnitParams{}) c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().AddOneMachine(state.MachineTemplate{ + st := s.ControllerModel(c).State() + machine, err := st.AddOneMachine(state.MachineTemplate{ Base: state.UbuntuBase("12.10"), Jobs: []state.MachineJob{state.JobHostUnits}, }) @@ -725,10 +775,16 @@ func (s *networkInfoSuite) TestMachineNetworkInfos(c *gc.C) { s.createNICWithIP(c, machine, network.EthernetDevice, "eth1", "10.10.0.20/24") s.createNICWithIP(c, machine, network.EthernetDevice, "eth2", "10.20.0.20/24") - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.20", network.WithScope(network.ScopePublic)), + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses( + controllerConfig, + network.NewSpaceAddress("10.0.0.20", network.WithScope(network.ScopePublic)), network.NewSpaceAddress("10.10.0.20", network.WithScope(network.ScopePublic)), network.NewSpaceAddress("10.10.0.30", network.WithScope(network.ScopePublic)), - network.NewSpaceAddress("10.20.0.20", network.WithScope(network.ScopeCloudLocal))) + network.NewSpaceAddress("10.20.0.20", network.WithScope(network.ScopeCloudLocal)), + ) c.Assert(err, jc.ErrorIsNil) ni := s.newNetworkInfo(c, unit.UnitTag(), nil, nil) @@ -777,7 +833,8 @@ func (s *networkInfoSuite) TestMachineNetworkInfosAlphaNoSubnets(c *gc.C) { unit, err := app.AddUnit(state.AddUnitParams{}) c.Assert(err, jc.ErrorIsNil) - machine, err := s.ControllerModel(c).State().AddOneMachine(state.MachineTemplate{ + st := s.ControllerModel(c).State() + machine, err := st.AddOneMachine(state.MachineTemplate{ Base: state.UbuntuBase("12.10"), Jobs: []state.MachineJob{state.JobHostUnits}, }) @@ -790,10 +847,16 @@ func (s *networkInfoSuite) TestMachineNetworkInfosAlphaNoSubnets(c *gc.C) { s.createNICWithIP(c, machine, network.EthernetDevice, "eth1", "10.10.0.20/24") s.createNICWithIP(c, machine, network.EthernetDevice, "eth2", "10.20.0.20/24") - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.20", network.WithScope(network.ScopePublic)), + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses( + controllerConfig, + network.NewSpaceAddress("10.0.0.20", network.WithScope(network.ScopePublic)), network.NewSpaceAddress("10.10.0.20", network.WithScope(network.ScopePublic)), network.NewSpaceAddress("10.10.0.30", network.WithScope(network.ScopePublic)), - network.NewSpaceAddress("10.20.0.20", network.WithScope(network.ScopeCloudLocal))) + network.NewSpaceAddress("10.20.0.20", network.WithScope(network.ScopeCloudLocal)), + ) c.Assert(err, jc.ErrorIsNil) ni := s.newNetworkInfo(c, unit.UnitTag(), nil, nil) diff --git a/apiserver/facades/agent/uniter/uniter_test.go b/apiserver/facades/agent/uniter/uniter_test.go index 08d6c11845d..66aa47024df 100644 --- a/apiserver/facades/agent/uniter/uniter_test.go +++ b/apiserver/facades/agent/uniter/uniter_test.go @@ -567,7 +567,11 @@ func (s *uniterSuite) TestPublicAddress(c *gc.C) { }) // Now set it an try again. + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) err = s.machine0.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopePublic)), ) c.Assert(err, jc.ErrorIsNil) @@ -607,7 +611,11 @@ func (s *uniterSuite) TestPrivateAddress(c *gc.C) { }) // Now set it and try again. + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) err = s.machine0.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), ) c.Assert(err, jc.ErrorIsNil) @@ -629,7 +637,11 @@ func (s *uniterSuite) TestPrivateAddress(c *gc.C) { // TestNetworkInfoSpaceless is in uniterSuite and not uniterNetworkInfoSuite since we don't want // all the spaces set up. func (s *uniterSuite) TestNetworkInfoSpaceless(c *gc.C) { - err := s.machine0.SetProviderAddresses( + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + err = s.machine0.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), ) c.Assert(err, jc.ErrorIsNil) @@ -1971,7 +1983,11 @@ func (s *uniterSuite) TestProviderType(c *gc.C) { func (s *uniterSuite) TestEnterScope(c *gc.C) { // Set wordpressUnit's private address first. - err := s.machine0.SetProviderAddresses( + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + err = s.machine0.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), ) c.Assert(err, jc.ErrorIsNil) @@ -3376,14 +3392,18 @@ func (s *uniterSuite) TestSLALevel(c *gc.C) { func (s *uniterSuite) setupRemoteRelationScenario(c *gc.C) (names.Tag, *state.RelationUnit) { s.makeRemoteWordpress(c) + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // Set mysql's addresses first. - err := s.machine1.SetProviderAddresses( + err = s.machine1.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("4.3.2.1", network.WithScope(network.ScopePublic)), ) c.Assert(err, jc.ErrorIsNil) - st := s.ControllerModel(c).State() eps, err := st.InferEndpoints("mysql", "remote-wordpress") c.Assert(err, jc.ErrorIsNil) rel, err := st.AddRelation(eps...) @@ -3423,8 +3443,14 @@ func (s *uniterSuite) TestPrivateAddressWithRemoteRelationNoPublic(c *gc.C) { relTag, relUnit := s.setupRemoteRelationScenario(c) thisUniter := s.makeMysqlUniter(c) + + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // Set mysql's addresses - no public address. - err := s.machine1.SetProviderAddresses( + err = s.machine1.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("1.2.3.4", network.WithScope(network.ScopeCloudLocal)), ) c.Assert(err, jc.ErrorIsNil) @@ -3914,7 +3940,10 @@ func (s *uniterNetworkInfoSuite) addProvisionedMachineWithDevicesAndAddresses(c for i, addr := range machineAddrs { netAddrs[i] = network.NewSpaceAddress(addr.Value()) } - err = machine.SetProviderAddresses(netAddrs...) + st := s.ControllerModel(c).State() + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + err = machine.SetProviderAddresses(controllerConfig, netAddrs...) c.Assert(err, jc.ErrorIsNil) return machine diff --git a/apiserver/facades/client/highavailability/highavailability_test.go b/apiserver/facades/client/highavailability/highavailability_test.go index 2cac197577c..808c4a2b1ce 100644 --- a/apiserver/facades/client/highavailability/highavailability_test.go +++ b/apiserver/facades/client/highavailability/highavailability_test.go @@ -83,9 +83,13 @@ func (s *clientSuite) SetUpTest(c *gc.C) { } func (s *clientSuite) setMachineAddresses(c *gc.C, machineId string) { - m, err := s.ControllerModel(c).State().Machine(machineId) + st := s.ControllerModel(c).State() + m, err := st.Machine(machineId) + c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) err = m.SetMachineAddresses( + controllerConfig, network.NewSpaceAddress("127.0.0.1", network.WithScope(network.ScopeMachineLocal)), network.NewSpaceAddress(fmt.Sprintf("cloud-local%s.internal", machineId), network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress(fmt.Sprintf("fc0%s::1", machineId), network.WithScope(network.ScopePublic)), @@ -126,12 +130,16 @@ func enableHA( } func (s *clientSuite) TestEnableHAErrorForMultiCloudLocal(c *gc.C) { - machines, err := s.ControllerModel(c).State().AllMachines() + st := s.ControllerModel(c).State() + machines, err := st.AllMachines() c.Assert(err, jc.ErrorIsNil) c.Assert(machines, gc.HasLen, 1) c.Assert(machines[0].Base().DisplayString(), gc.Equals, "ubuntu@12.10") + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) err = machines[0].SetMachineAddresses( + controllerConfig, network.NewSpaceAddress("cloud-local2.internal", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("cloud-local22.internal", network.WithScope(network.ScopeCloudLocal)), ) @@ -144,12 +152,17 @@ func (s *clientSuite) TestEnableHAErrorForMultiCloudLocal(c *gc.C) { } func (s *clientSuite) TestEnableHAErrorForNoCloudLocal(c *gc.C) { - m0, err := s.ControllerModel(c).State().Machine("0") + st := s.ControllerModel(c).State() + m0, err := st.Machine("0") c.Assert(err, jc.ErrorIsNil) c.Assert(m0.Base().DisplayString(), gc.Equals, "ubuntu@12.10") + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // remove the extra provider addresses, so we have no valid CloudLocal addresses c.Assert(m0.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("127.0.0.1", network.WithScope(network.ScopeMachineLocal)), ), jc.ErrorIsNil) @@ -188,9 +201,13 @@ func (s *clientSuite) TestEnableHAAddMachinesErrorForMultiCloudLocal(c *gc.C) { s.setMachineAddresses(c, "1") + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + m, err := st.Machine("2") c.Assert(err, jc.ErrorIsNil) err = m.SetMachineAddresses( + controllerConfig, network.NewSpaceAddress("cloud-local2.internal", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("cloud-local22.internal", network.WithScope(network.ScopeCloudLocal)), ) @@ -362,18 +379,21 @@ func (s *clientSuite) TestEnableHAPlacementToWithAddressInSpace(c *gc.C) { _, err = controllerSettings.Write() c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + m1, err := st.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) a1 := network.NewSpaceAddress("192.168.6.6") a1.SpaceID = sp.Id() - err = m1.SetProviderAddresses(a1) + err = m1.SetProviderAddresses(controllerConfig, a1) c.Assert(err, jc.ErrorIsNil) m2, err := st.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) a2 := network.NewSpaceAddress("192.168.6.7") a2.SpaceID = sp.Id() - err = m2.SetProviderAddresses(a1) + err = m2.SetProviderAddresses(controllerConfig, a1) c.Assert(err, jc.ErrorIsNil) placement := []string{"1", "2"} diff --git a/apiserver/facades/controller/instancepoller/instancepoller.go b/apiserver/facades/controller/instancepoller/instancepoller.go index fbd52d6f7e5..609def399f2 100644 --- a/apiserver/facades/controller/instancepoller/instancepoller.go +++ b/apiserver/facades/controller/instancepoller/instancepoller.go @@ -164,7 +164,7 @@ func (a *InstancePollerAPI) SetProviderNetworkConfig( continue } - modified, err := maybeUpdateMachineProviderAddresses(machine, newSpaceAddrs) + modified, err := maybeUpdateMachineProviderAddresses(a.st, machine, newSpaceAddrs) if err != nil { result.Results[i].Error = apiservererrors.ServerError(err) continue @@ -184,13 +184,18 @@ func (a *InstancePollerAPI) SetProviderNetworkConfig( return result, nil } -func maybeUpdateMachineProviderAddresses(m StateMachine, newSpaceAddrs network.SpaceAddresses) (bool, error) { +func maybeUpdateMachineProviderAddresses(st StateInterface, m StateMachine, newSpaceAddrs network.SpaceAddresses) (bool, error) { curSpaceAddrs := m.ProviderAddresses() if curSpaceAddrs.EqualTo(newSpaceAddrs) { return false, nil } - return true, m.SetProviderAddresses(newSpaceAddrs...) + controllerConfig, err := st.ControllerConfig() + if err != nil { + return false, errors.Trace(err) + } + + return true, m.SetProviderAddresses(controllerConfig, newSpaceAddrs...) } func (a *InstancePollerAPI) mergeLinkLayer(m StateMachine, devs network.InterfaceInfos) error { @@ -310,6 +315,12 @@ func (a *InstancePollerAPI) SetProviderAddresses(ctx context.Context, args param if err != nil { return result, err } + + controllerConfig, err := a.st.ControllerConfig() + if err != nil { + return result, err + } + for i, arg := range args.MachineAddresses { machine, err := a.getOneMachine(arg.Tag, canAccess) if err != nil { @@ -322,7 +333,7 @@ func (a *InstancePollerAPI) SetProviderAddresses(ctx context.Context, args param result.Results[i].Error = apiservererrors.ServerError(err) continue } - if err := machine.SetProviderAddresses(addrsToSet...); err != nil { + if err := machine.SetProviderAddresses(controllerConfig, addrsToSet...); err != nil { result.Results[i].Error = apiservererrors.ServerError(err) } } diff --git a/apiserver/facades/controller/instancepoller/instancepoller_test.go b/apiserver/facades/controller/instancepoller/instancepoller_test.go index e2dc87addf7..93b29a18f83 100644 --- a/apiserver/facades/controller/instancepoller/instancepoller_test.go +++ b/apiserver/facades/controller/instancepoller/instancepoller_test.go @@ -515,12 +515,12 @@ func (s *InstancePollerSuite) TestSetProviderAddressesSuccess(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(result, jc.DeepEquals, s.mixedErrorResults) - s.st.CheckMachineCall(c, 0, "1") - s.st.CheckSetProviderAddressesCall(c, 1, []network.SpaceAddress{}) - s.st.CheckMachineCall(c, 2, "2") - s.st.CheckCall(c, 3, "AllSpaceInfos") - s.st.CheckSetProviderAddressesCall(c, 4, newAddrs) - s.st.CheckMachineCall(c, 5, "42") + s.st.CheckMachineCall(c, 1, "1") + s.st.CheckSetProviderAddressesCall(c, 2, []network.SpaceAddress{}) + s.st.CheckMachineCall(c, 3, "2") + s.st.CheckCall(c, 4, "AllSpaceInfos") + s.st.CheckSetProviderAddressesCall(c, 5, newAddrs) + s.st.CheckMachineCall(c, 6, "42") // Ensure machines were updated. machine, err := s.st.Machine("1") @@ -554,11 +554,11 @@ func (s *InstancePollerSuite) TestSetProviderAddressesFailure(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Check(result, jc.DeepEquals, s.machineErrorResults) - s.st.CheckMachineCall(c, 0, "1") - s.st.CheckMachineCall(c, 1, "2") - s.st.CheckCall(c, 2, "AllSpaceInfos") - s.st.CheckSetProviderAddressesCall(c, 3, newAddrs) - s.st.CheckMachineCall(c, 4, "3") + s.st.CheckMachineCall(c, 1, "1") + s.st.CheckMachineCall(c, 2, "2") + s.st.CheckCall(c, 3, "AllSpaceInfos") + s.st.CheckSetProviderAddressesCall(c, 4, newAddrs) + s.st.CheckMachineCall(c, 5, "3") // Ensure machine 2 wasn't updated. machine, err := s.st.Machine("2") diff --git a/apiserver/facades/controller/instancepoller/mock_test.go b/apiserver/facades/controller/instancepoller/mock_test.go index 3d7f6c56313..4f35cacd019 100644 --- a/apiserver/facades/controller/instancepoller/mock_test.go +++ b/apiserver/facades/controller/instancepoller/mock_test.go @@ -19,11 +19,13 @@ import ( "github.com/juju/juju/apiserver/common/networkingcommon" "github.com/juju/juju/apiserver/facades/controller/instancepoller" + "github.com/juju/juju/controller" "github.com/juju/juju/core/instance" "github.com/juju/juju/core/network" "github.com/juju/juju/core/status" "github.com/juju/juju/environs/config" "github.com/juju/juju/state" + jujutesting "github.com/juju/juju/testing" ) // mockState implements StateInterface and allows inspection of called @@ -258,6 +260,12 @@ func (m *mockState) ApplyOperation(op state.ModelOperation) error { return err } +func (m *mockState) ControllerConfig() (controller.Config, error) { + m.MethodCall(m, "ControllerConfig") + + return jujutesting.FakeControllerConfig(), nil +} + type machineInfo struct { id string instanceId instance.Id @@ -323,7 +331,7 @@ func (m *mockMachine) ProviderAddresses() network.SpaceAddresses { } // SetProviderAddresses implements StateMachine. -func (m *mockMachine) SetProviderAddresses(addrs ...network.SpaceAddress) error { +func (m *mockMachine) SetProviderAddresses(controllerConfig controller.Config, addrs ...network.SpaceAddress) error { m.mu.Lock() defer m.mu.Unlock() diff --git a/apiserver/facades/controller/instancepoller/state.go b/apiserver/facades/controller/instancepoller/state.go index e9080efd8e7..1079a1d6fda 100644 --- a/apiserver/facades/controller/instancepoller/state.go +++ b/apiserver/facades/controller/instancepoller/state.go @@ -5,6 +5,7 @@ package instancepoller import ( "github.com/juju/juju/apiserver/common/networkingcommon" + "github.com/juju/juju/controller" "github.com/juju/juju/core/instance" "github.com/juju/juju/core/network" "github.com/juju/juju/core/status" @@ -18,7 +19,7 @@ type StateMachine interface { InstanceId() (instance.Id, error) ProviderAddresses() network.SpaceAddresses - SetProviderAddresses(...network.SpaceAddress) error + SetProviderAddresses(controller.Config, ...network.SpaceAddress) error InstanceStatus() (status.StatusInfo, error) SetInstanceStatus(status.StatusInfo) error SetStatus(status.StatusInfo) error @@ -39,6 +40,8 @@ type StateInterface interface { // ApplyOperation applies a given ModelOperation to the model. ApplyOperation(state.ModelOperation) error + + ControllerConfig() (controller.Config, error) } type machineShim struct { @@ -86,9 +89,9 @@ func (s stateShim) Machine(id string) (StateMachine, error) { return nil, err } - return machineShim{m}, nil + return machineShim{Machine: m}, nil } var getState = func(st *state.State, m *state.Model) StateInterface { - return stateShim{st, m} + return stateShim{State: st, Model: m} } diff --git a/cmd/jujud/agent/util_test.go b/cmd/jujud/agent/util_test.go index dab9b9f92ae..ccbea7157a4 100644 --- a/cmd/jujud/agent/util_test.go +++ b/cmd/jujud/agent/util_test.go @@ -276,8 +276,11 @@ func (s *commonMachineSuite) newBufferedLogWriter() *logsender.BufferedLogWriter } func (s *commonMachineSuite) setFakeMachineAddresses(c *gc.C, machine *state.Machine) { + controllerConfig, err := s.ControllerModel(c).State().ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + addrs := network.NewSpaceAddresses("0.1.2.3") - err := machine.SetProviderAddresses(addrs...) + err = machine.SetProviderAddresses(controllerConfig, addrs...) c.Assert(err, jc.ErrorIsNil) // Set the addresses in the environ instance as well so that if the instance poller // runs it won't overwrite them. diff --git a/juju/testing/utils.go b/juju/testing/utils.go index fa18a723ab3..86f12e2f8d8 100644 --- a/juju/testing/utils.go +++ b/juju/testing/utils.go @@ -127,11 +127,11 @@ func (p lxdCharmProfiler) LXDProfile() lxdprofile.LXDProfile { func AddControllerMachine(c *gc.C, st *state.State) *state.Machine { machine, err := st.AddMachine(state.UbuntuBase("12.10"), state.JobManageModel) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("0.1.2.3")) - c.Assert(err, jc.ErrorIsNil) - controllerConfig, err := st.ControllerConfig() c.Assert(err, jc.ErrorIsNil) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("0.1.2.3")) + c.Assert(err, jc.ErrorIsNil) + hostPorts := []network.SpaceHostPorts{network.NewSpaceHostPorts(1234, "0.1.2.3")} err = st.SetAPIHostPorts(controllerConfig, hostPorts) c.Assert(err, jc.ErrorIsNil) diff --git a/state/allwatcher_internal_test.go b/state/allwatcher_internal_test.go index 7d8add8c95f..a3f294b4ecc 100644 --- a/state/allwatcher_internal_test.go +++ b/state/allwatcher_internal_test.go @@ -139,7 +139,11 @@ func (s *allWatcherBaseSuite) setUpScenario(c *gc.C, st *State, units int) (enti c.Assert(err, jc.ErrorIsNil) providerAddr := network.NewSpaceAddress("example.com") providerAddr.SpaceID = space.Id() - err = m.SetProviderAddresses(providerAddr) + + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = m.SetProviderAddresses(controllerConfig, providerAddr) c.Assert(err, jc.ErrorIsNil) var addresses []network.ProviderAddress @@ -3111,10 +3115,13 @@ func testChangeUnitsNonNilPorts(c *gc.C, owner names.UserTag, runChangeTests fun c.Assert(err, jc.ErrorIsNil) } if flag&openPorts != 0 { + controllerConfig, err := st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // Add a network to the machine and open a port. publicAddress := network.NewSpaceAddress("1.2.3.4", corenetwork.WithScope(corenetwork.ScopePublic)) privateAddress := network.NewSpaceAddress("4.3.2.1", corenetwork.WithScope(corenetwork.ScopeCloudLocal)) - err = m.SetProviderAddresses(publicAddress, privateAddress) + err = m.SetProviderAddresses(controllerConfig, publicAddress, privateAddress) c.Assert(err, jc.ErrorIsNil) unitPortRanges, err := u.OpenedPortRanges() diff --git a/state/controller_test.go b/state/controller_test.go index ed284bcd371..55b813929d1 100644 --- a/state/controller_test.go +++ b/state/controller_test.go @@ -191,7 +191,10 @@ func (s *ControllerSuite) TestUpdateControllerConfigRejectsSpaceWithoutAddresses m, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobManageModel, state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - c.Assert(m.SetMachineAddresses(network.NewSpaceAddress("192.168.9.9")), jc.ErrorIsNil) + + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + c.Assert(m.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("192.168.9.9")), jc.ErrorIsNil) err = s.State.UpdateControllerConfig(map[string]interface{}{ controller.JujuManagementSpace: "mgmt-space", @@ -210,7 +213,10 @@ func (s *ControllerSuite) TestUpdateControllerConfigAcceptsSpaceWithAddresses(c addr := network.NewSpaceAddress("192.168.9.9") addr.SpaceID = sp.Id() - c.Assert(m.SetProviderAddresses(addr), jc.ErrorIsNil) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + c.Assert(m.SetProviderAddresses(controllerConfig, addr), jc.ErrorIsNil) err = s.State.UpdateControllerConfig(map[string]interface{}{ controller.JujuManagementSpace: "mgmt-space", @@ -244,13 +250,16 @@ func (s *ControllerSuite) TestSetMachineAddressesControllerCharm(c *gc.C) { Machine: controller, }) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + addresses := network.NewSpaceAddresses("10.0.0.1") - err = controller.SetMachineAddresses(addresses...) + err = controller.SetMachineAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) // Updating a worker machine does not affect charm config. addresses = network.NewSpaceAddresses("10.0.0.2") - err = worker.SetMachineAddresses(addresses...) + err = worker.SetMachineAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) cfg, err := controllerApp.CharmConfig(model.GenerationMaster) diff --git a/state/machine.go b/state/machine.go index cfa7c496fa8..032ad8dadad 100644 --- a/state/machine.go +++ b/state/machine.go @@ -22,6 +22,7 @@ import ( "github.com/kr/pretty" "github.com/juju/juju/api" + "github.com/juju/juju/controller" "github.com/juju/juju/core/actions" "github.com/juju/juju/core/constraints" corecontainer "github.com/juju/juju/core/container" @@ -1710,8 +1711,8 @@ func (m *Machine) setPrivateAddressOps(providerAddresses []address, machineAddre // SetProviderAddresses records any addresses related to the machine, sourced // by asking the provider. -func (m *Machine) SetProviderAddresses(addresses ...network.SpaceAddress) error { - err := m.setAddresses(nil, &addresses) +func (m *Machine) SetProviderAddresses(controllerConfig controller.Config, addresses ...network.SpaceAddress) error { + err := m.setAddresses(controllerConfig, nil, &addresses) return errors.Annotatef(err, "cannot set addresses of machine %v", m) } @@ -1735,8 +1736,8 @@ func (m *Machine) MachineAddresses() (addresses network.SpaceAddresses) { // SetMachineAddresses records any addresses related to the machine, sourced // by asking the machine. -func (m *Machine) SetMachineAddresses(addresses ...network.SpaceAddress) error { - err := m.setAddresses(&addresses, nil) +func (m *Machine) SetMachineAddresses(controllerConfig controller.Config, addresses ...network.SpaceAddress) error { + err := m.setAddresses(controllerConfig, &addresses, nil) return errors.Annotatef(err, "cannot set machine addresses of machine %v", m) } @@ -1744,7 +1745,7 @@ func (m *Machine) SetMachineAddresses(addresses ...network.SpaceAddress) error { // MachineAddresses, depending on the field argument). Changes are // only predicated on the machine not being Dead; concurrent address // changes are ignored. -func (m *Machine) setAddresses(machineAddresses, providerAddresses *[]network.SpaceAddress) error { +func (m *Machine) setAddresses(controllerConfig controller.Config, machineAddresses, providerAddresses *[]network.SpaceAddress) error { var ( machineStateAddresses, providerStateAddresses []address newPrivate, newPublic *address @@ -1788,7 +1789,7 @@ func (m *Machine) setAddresses(machineAddresses, providerAddresses *[]network.Sp m.Id(), oldPublic, newPublic.networkAddress(), ) if isController(&m.doc) { - if err := m.st.maybeUpdateControllerCharm(m.doc.PreferredPublicAddress.Value); err != nil { + if err := m.st.maybeUpdateControllerCharm(controllerConfig, m.doc.PreferredPublicAddress.Value); err != nil { return errors.Trace(err) } } @@ -1796,7 +1797,7 @@ func (m *Machine) setAddresses(machineAddresses, providerAddresses *[]network.Sp return nil } -func (st *State) maybeUpdateControllerCharm(publicAddr string) error { +func (st *State) maybeUpdateControllerCharm(controllerConfig controller.Config, publicAddr string) error { controllerApp, err := st.Application(bootstrap.ControllerApplicationName) if errors.IsNotFound(err) { return nil @@ -1804,12 +1805,8 @@ func (st *State) maybeUpdateControllerCharm(publicAddr string) error { if err != nil { return errors.Trace(err) } - controllerCfg, err := st.ControllerConfig() - if err != nil { - return errors.Trace(err) - } return controllerApp.UpdateCharmConfig(model.GenerationMaster, charm.Settings{ - "controller-url": api.ControllerAPIURL(publicAddr, controllerCfg.APIPort()), + "controller-url": api.ControllerAPIURL(publicAddr, controllerConfig.APIPort()), }) } diff --git a/state/machine_test.go b/state/machine_test.go index ea5bda0f215..d4790d810c7 100644 --- a/state/machine_test.go +++ b/state/machine_test.go @@ -1822,7 +1822,9 @@ func (s *MachineSuite) TestSetProviderAddresses(c *gc.C) { SpaceID: "1", }, } - err = machine.SetProviderAddresses(addresses...) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + err = machine.SetProviderAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) err = machine.Refresh() c.Assert(err, jc.ErrorIsNil) @@ -1836,13 +1838,16 @@ func (s *MachineSuite) TestSetProviderAddressesWithContainers(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(machine.Addresses(), gc.HasLen, 0) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // When setting all addresses the subnet addresses have to be // filtered out. addresses := network.NewSpaceAddresses( "127.0.0.1", "8.8.8.8", ) - err = machine.SetProviderAddresses(addresses...) + err = machine.SetProviderAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) err = machine.Refresh() c.Assert(err, jc.ErrorIsNil) @@ -1864,9 +1869,11 @@ func (s *MachineSuite) TestSetProviderAddressesOnContainer(c *gc.C) { container, err := s.State.AddMachineInsideMachine(template, machine.Id(), instance.LXD) c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) // When setting all addresses the subnet address has to accepted. addresses := network.NewSpaceAddresses("127.0.0.1") - err = container.SetProviderAddresses(addresses...) + err = container.SetProviderAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) err = container.Refresh() c.Assert(err, jc.ErrorIsNil) @@ -1880,8 +1887,10 @@ func (s *MachineSuite) TestSetMachineAddresses(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(machine.Addresses(), gc.HasLen, 0) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) addresses := network.NewSpaceAddresses("127.0.0.1", "8.8.8.8") - err = machine.SetMachineAddresses(addresses...) + err = machine.SetMachineAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) err = machine.Refresh() c.Assert(err, jc.ErrorIsNil) @@ -1895,16 +1904,18 @@ func (s *MachineSuite) TestSetEmptyMachineAddresses(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(machine.Addresses(), gc.HasLen, 0) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) // Add some machine addresses initially to make sure they're removed. addresses := network.NewSpaceAddresses("127.0.0.1", "8.8.8.8") - err = machine.SetMachineAddresses(addresses...) + err = machine.SetMachineAddresses(controllerConfig, addresses...) c.Assert(err, jc.ErrorIsNil) err = machine.Refresh() c.Assert(err, jc.ErrorIsNil) c.Assert(machine.MachineAddresses(), gc.HasLen, 2) // Make call with empty address list. - err = machine.SetMachineAddresses() + err = machine.SetMachineAddresses(controllerConfig) c.Assert(err, jc.ErrorIsNil) err = machine.Refresh() c.Assert(err, jc.ErrorIsNil) @@ -1916,7 +1927,8 @@ func (s *MachineSuite) TestMergedAddresses(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) c.Assert(machine.Addresses(), gc.HasLen, 0) - + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) providerAddresses := network.NewSpaceAddresses( "127.0.0.2", "8.8.8.8", @@ -1927,7 +1939,7 @@ func (s *MachineSuite) TestMergedAddresses(c *gc.C) { "127.0.0.2", "example.org", ) - err = machine.SetProviderAddresses(providerAddresses...) + err = machine.SetProviderAddresses(controllerConfig, providerAddresses...) c.Assert(err, jc.ErrorIsNil) machineAddresses := network.NewSpaceAddresses( @@ -1939,7 +1951,7 @@ func (s *MachineSuite) TestMergedAddresses(c *gc.C) { "::1", "fd00::1", ) - err = machine.SetMachineAddresses(machineAddresses...) + err = machine.SetMachineAddresses(controllerConfig, machineAddresses...) c.Assert(err, jc.ErrorIsNil) err = machine.Refresh() c.Assert(err, jc.ErrorIsNil) @@ -1973,14 +1985,17 @@ func (s *MachineSuite) TestSetProviderAddressesConcurrentChangeDifferent(c *gc.C addr0 := network.NewSpaceAddress("127.0.0.1") addr1 := network.NewSpaceAddress("8.8.8.8") + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + defer state.SetBeforeHooks(c, s.State, func() { machine, err := s.State.Machine(machine.Id()) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(addr1, addr0) + err = machine.SetProviderAddresses(controllerConfig, addr1, addr0) c.Assert(err, jc.ErrorIsNil) }).Check() - err = machine.SetProviderAddresses(addr0, addr1) + err = machine.SetProviderAddresses(controllerConfig, addr0, addr1) c.Assert(err, jc.ErrorIsNil) c.Assert(machine.Addresses(), jc.SameContents, network.SpaceAddresses{addr0, addr1}) } @@ -1996,18 +2011,21 @@ func (s *MachineSuite) TestSetProviderAddressesConcurrentChangeEqual(c *gc.C) { addr0 := network.NewSpaceAddress("127.0.0.1") addr1 := network.NewSpaceAddress("8.8.8.8") + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + var revno1 int64 defer state.SetBeforeHooks(c, s.State, func() { machine, err := s.State.Machine(machine.Id()) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(addr0, addr1) + err = machine.SetProviderAddresses(controllerConfig, addr0, addr1) c.Assert(err, jc.ErrorIsNil) revno1, err = state.TxnRevno(s.State, "machines", machineDocID) c.Assert(err, jc.ErrorIsNil) c.Assert(revno1, jc.GreaterThan, revno0) }).Check() - err = machine.SetProviderAddresses(addr0, addr1) + err = machine.SetProviderAddresses(controllerConfig, addr0, addr1) c.Assert(err, jc.ErrorIsNil) // Doc will be updated; concurrent changes are explicitly ignored. @@ -2026,18 +2044,21 @@ func (s *MachineSuite) TestSetProviderAddressesInvalidateMemory(c *gc.C) { addr0 := network.NewSpaceAddress("127.0.0.1") addr1 := network.NewSpaceAddress("8.8.8.8") + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // Set addresses to [addr0] initially. We'll get a separate Machine // object to update addresses, to ensure that the in-memory cache of // addresses does not prevent the initial Machine from updating // addresses back to the original value. - err = machine.SetProviderAddresses(addr0) + err = machine.SetProviderAddresses(controllerConfig, addr0) c.Assert(err, jc.ErrorIsNil) revno0, err := state.TxnRevno(s.State, "machines", machineDocID) c.Assert(err, jc.ErrorIsNil) machine2, err := s.State.Machine(machine.Id()) c.Assert(err, jc.ErrorIsNil) - err = machine2.SetProviderAddresses(addr1) + err = machine2.SetProviderAddresses(controllerConfig, addr1) c.Assert(err, jc.ErrorIsNil) revno1, err := state.TxnRevno(s.State, "machines", machineDocID) c.Assert(err, jc.ErrorIsNil) @@ -2045,7 +2066,7 @@ func (s *MachineSuite) TestSetProviderAddressesInvalidateMemory(c *gc.C) { c.Assert(machine.Addresses(), jc.SameContents, network.SpaceAddresses{addr0}) c.Assert(machine2.Addresses(), jc.SameContents, network.SpaceAddresses{addr1}) - err = machine.SetProviderAddresses(addr0) + err = machine.SetProviderAddresses(controllerConfig, addr0) c.Assert(err, jc.ErrorIsNil) revno2, err := state.TxnRevno(s.State, "machines", machineDocID) c.Assert(err, jc.ErrorIsNil) @@ -2101,7 +2122,10 @@ func (s *MachineSuite) TestPublicAddress(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() @@ -2113,7 +2137,10 @@ func (s *MachineSuite) TestPrivateAddress(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.1")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PrivateAddress() @@ -2125,14 +2152,17 @@ func (s *MachineSuite) TestPublicAddressBetterMatch(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.1")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "10.0.0.1") - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PublicAddress() @@ -2144,14 +2174,17 @@ func (s *MachineSuite) TestPrivateAddressBetterMatch(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PrivateAddress() c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "8.8.8.8") - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.1")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PrivateAddress() @@ -2163,14 +2196,17 @@ func (s *MachineSuite) TestPublicAddressChanges(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "8.8.8.8") - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.4.4")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PublicAddress() @@ -2182,14 +2218,17 @@ func (s *MachineSuite) TestPrivateAddressChanges(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.2")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PrivateAddress() c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "10.0.0.2") - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.1")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PrivateAddress() @@ -2201,7 +2240,10 @@ func (s *MachineSuite) TestAddressesDeadMachine(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("10.0.0.2"), network.NewSpaceAddress("8.8.4.4")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.2"), network.NewSpaceAddress("8.8.4.4")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PrivateAddress() @@ -2229,7 +2271,10 @@ func (s *MachineSuite) TestStablePrivateAddress(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.2")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PrivateAddress() @@ -2238,7 +2283,7 @@ func (s *MachineSuite) TestStablePrivateAddress(c *gc.C) { // Now add an address that would previously have sorted before the // default. - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.1"), network.NewSpaceAddress("10.0.0.2")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1"), network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) // Assert the address is unchanged. @@ -2251,7 +2296,10 @@ func (s *MachineSuite) TestStablePublicAddress(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() @@ -2260,7 +2308,7 @@ func (s *MachineSuite) TestStablePublicAddress(c *gc.C) { // Now add an address that would previously have sorted before the // default. - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.4.4"), network.NewSpaceAddress("8.8.8.8")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4"), network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) // Assert the address is unchanged. @@ -2273,9 +2321,12 @@ func (s *MachineSuite) TestAddressesRaceMachineFirst(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + changeAddresses := jujutxn.TestHook{ Before: func() { - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) address, err := machine.PublicAddress() c.Assert(err, jc.ErrorIsNil) @@ -2287,7 +2338,7 @@ func (s *MachineSuite) TestAddressesRaceMachineFirst(c *gc.C) { } defer state.SetTestHooks(c, s.State, changeAddresses).Check() - err = machine.SetMachineAddresses(network.NewSpaceAddress("8.8.4.4")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4")) c.Assert(err, jc.ErrorIsNil) machine, err = s.State.Machine(machine.Id()) @@ -2304,9 +2355,12 @@ func (s *MachineSuite) TestAddressesRaceProviderFirst(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + changeAddresses := jujutxn.TestHook{ Before: func() { - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.1")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) address, err := machine.PublicAddress() c.Assert(err, jc.ErrorIsNil) @@ -2318,7 +2372,7 @@ func (s *MachineSuite) TestAddressesRaceProviderFirst(c *gc.C) { } defer state.SetTestHooks(c, s.State, changeAddresses).Check() - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.4.4")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4")) c.Assert(err, jc.ErrorIsNil) machine, err = s.State.Machine(machine.Id()) @@ -2335,7 +2389,10 @@ func (s *MachineSuite) TestPrivateAddressPrefersProvider(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.2")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() @@ -2345,7 +2402,7 @@ func (s *MachineSuite) TestPrivateAddressPrefersProvider(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "10.0.0.2") - err = machine.SetProviderAddresses(network.NewSpaceAddress("10.0.0.1")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PublicAddress() @@ -2360,7 +2417,10 @@ func (s *MachineSuite) TestPublicAddressPrefersProvider(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.2")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() @@ -2370,7 +2430,7 @@ func (s *MachineSuite) TestPublicAddressPrefersProvider(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "10.0.0.2") - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.4.4")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PublicAddress() @@ -2385,7 +2445,10 @@ func (s *MachineSuite) TestAddressesPrefersProviderBoth(c *gc.C) { machine, err := s.State.AddMachine(state.UbuntuBase("12.10"), state.JobHostUnits) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.1")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8"), network.NewSpaceAddress("10.0.0.1")) c.Assert(err, jc.ErrorIsNil) addr, err := machine.PublicAddress() @@ -2395,7 +2458,7 @@ func (s *MachineSuite) TestAddressesPrefersProviderBoth(c *gc.C) { c.Assert(err, jc.ErrorIsNil) c.Assert(addr.Value, gc.Equals, "10.0.0.1") - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.4.4"), network.NewSpaceAddress("10.0.0.2")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4"), network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) addr, err = machine.PublicAddress() @@ -2821,28 +2884,31 @@ func (s *MachineSuite) TestWatchAddresses(c *gc.C) { c.Assert(err, jc.ErrorIsNil) wc.AssertNoChange() + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + // Set machine addresses: reported. - err = machine.SetMachineAddresses(network.NewSpaceAddress("abc")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("abc")) c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() // Set provider addresses eclipsing machine addresses: reported. - err = machine.SetProviderAddresses(network.NewSpaceAddress("abc", network.WithScope(network.ScopePublic))) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("abc", network.WithScope(network.ScopePublic))) c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() // Set same machine eclipsed by provider addresses: not reported. - err = machine.SetMachineAddresses(network.NewSpaceAddress("abc", network.WithScope(network.ScopeCloudLocal))) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("abc", network.WithScope(network.ScopeCloudLocal))) c.Assert(err, jc.ErrorIsNil) wc.AssertNoChange() // Set different machine addresses: reported. - err = machine.SetMachineAddresses(network.NewSpaceAddress("def")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("def")) c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() // Set different provider addresses: reported. - err = machine.SetMachineAddresses(network.NewSpaceAddress("def", network.WithScope(network.ScopePublic))) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("def", network.WithScope(network.ScopePublic))) c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() diff --git a/state/relationunit_test.go b/state/relationunit_test.go index 6848e8ca4a5..dc4d4b40204 100644 --- a/state/relationunit_test.go +++ b/state/relationunit_test.go @@ -1201,7 +1201,9 @@ func (s *WatchRelationUnitsSuite) TestPeer(c *gc.C) { fmt.Sprintf("riak%d.example.com", i), network.WithScope(network.ScopeCloudLocal), ) - err = machine.SetProviderAddresses(privateAddr) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + err = machine.SetProviderAddresses(controllerConfig, privateAddr) c.Assert(err, jc.ErrorIsNil) ru, err := rel.Unit(unit) c.Assert(err, jc.ErrorIsNil) diff --git a/state/state_test.go b/state/state_test.go index 56b9121e028..2349e281f85 100644 --- a/state/state_test.go +++ b/state/state_test.go @@ -777,8 +777,11 @@ func (s *StateSuite) TestAddresses(c *gc.C) { machines[3], err = s.State.Machine("3") c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) for i, m := range machines { err := m.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress(fmt.Sprintf("10.0.0.%d", i), network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("::1", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("127.0.0.1", network.WithScope(network.ScopeMachineLocal)), diff --git a/state/unit_test.go b/state/unit_test.go index 158f170f97e..5234fcd9322 100644 --- a/state/unit_test.go +++ b/state/unit_test.go @@ -800,7 +800,10 @@ func (s *UnitSuite) setAssignedMachineAddresses(c *gc.C, u *state.Unit) { c.Assert(err, jc.ErrorIsNil) err = machine.SetProvisioned("i-exist", "", "fake_nonce", nil) c.Assert(err, jc.ErrorIsNil) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) err = machine.SetProviderAddresses( + controllerConfig, network.NewSpaceAddress("private.address.example.com", network.WithScope(network.ScopeCloudLocal)), network.NewSpaceAddress("public.address.example.com", network.WithScope(network.ScopePublic)), ) @@ -836,7 +839,10 @@ func (s *UnitSuite) TestPublicAddress(c *gc.C) { public := network.NewSpaceAddress("8.8.8.8", network.WithScope(network.ScopePublic)) private := network.NewSpaceAddress("127.0.0.1", network.WithScope(network.ScopeCloudLocal)) - err = machine.SetProviderAddresses(public, private) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, public, private) c.Assert(err, jc.ErrorIsNil) address, err := s.unit.PublicAddress() @@ -850,12 +856,15 @@ func (s *UnitSuite) TestStablePrivateAddress(c *gc.C) { err = s.unit.AssignToMachine(machine) c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.2")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) // Now add an address that would previously have sorted before the // default. - err = machine.SetMachineAddresses(network.NewSpaceAddress("10.0.0.1"), network.NewSpaceAddress("10.0.0.2")) + err = machine.SetMachineAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.1"), network.NewSpaceAddress("10.0.0.2")) c.Assert(err, jc.ErrorIsNil) // Assert the address is unchanged. @@ -870,12 +879,15 @@ func (s *UnitSuite) TestStablePublicAddress(c *gc.C) { err = s.unit.AssignToMachine(machine) c.Assert(err, jc.ErrorIsNil) - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.8.8")) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) // Now add an address that would previously have sorted before the // default. - err = machine.SetProviderAddresses(network.NewSpaceAddress("8.8.4.4"), network.NewSpaceAddress("8.8.8.8")) + err = machine.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("8.8.4.4"), network.NewSpaceAddress("8.8.8.8")) c.Assert(err, jc.ErrorIsNil) // Assert the address is unchanged. @@ -894,15 +906,18 @@ func (s *UnitSuite) TestPublicAddressMachineAddresses(c *gc.C) { privateProvider := network.NewSpaceAddress("127.0.0.1", network.WithScope(network.ScopeCloudLocal)) privateMachine := network.NewSpaceAddress("127.0.0.2") - err = machine.SetProviderAddresses(privateProvider) + controllerConfig, err := s.State.ControllerConfig() c.Assert(err, jc.ErrorIsNil) - err = machine.SetMachineAddresses(privateMachine) + + err = machine.SetProviderAddresses(controllerConfig, privateProvider) + c.Assert(err, jc.ErrorIsNil) + err = machine.SetMachineAddresses(controllerConfig, privateMachine) c.Assert(err, jc.ErrorIsNil) address, err := s.unit.PublicAddress() c.Assert(err, jc.ErrorIsNil) c.Check(address.Value, gc.Equals, "127.0.0.1") - err = machine.SetProviderAddresses(publicProvider, privateProvider) + err = machine.SetProviderAddresses(controllerConfig, publicProvider, privateProvider) c.Assert(err, jc.ErrorIsNil) address, err = s.unit.PublicAddress() c.Assert(err, jc.ErrorIsNil) @@ -931,7 +946,10 @@ func (s *UnitSuite) TestPrivateAddress(c *gc.C) { public := network.NewSpaceAddress("8.8.8.8", network.WithScope(network.ScopePublic)) private := network.NewSpaceAddress("127.0.0.1", network.WithScope(network.ScopeCloudLocal)) - err = machine.SetProviderAddresses(public, private) + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = machine.SetProviderAddresses(controllerConfig, public, private) c.Assert(err, jc.ErrorIsNil) address, err := s.unit.PrivateAddress() @@ -2902,7 +2920,11 @@ func (s *UnitSuite) TestWatchMachineAndEndpointAddressesHash(c *gc.C) { ConfigMethod: network.ConfigStatic, }) c.Assert(err, gc.IsNil) - err = m1.SetProviderAddresses(network.NewSpaceAddress("10.0.0.100")) + + controllerConfig, err := s.State.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + + err = m1.SetProviderAddresses(controllerConfig, network.NewSpaceAddress("10.0.0.100")) c.Assert(err, gc.IsNil) wc.AssertChange("46ed851765a963e100161210a7b4fbb28d59b24edb580a60f86dbbaebea14d37") diff --git a/testing/factory/factory.go b/testing/factory/factory.go index 762523e28fe..0c68239b02e 100644 --- a/testing/factory/factory.go +++ b/testing/factory/factory.go @@ -379,7 +379,9 @@ func (factory *Factory) makeMachineReturningPassword(c *gc.C, params *MachinePar err = machine.SetPassword(params.Password) c.Assert(err, jc.ErrorIsNil) if len(params.Addresses) > 0 { - err := machine.SetProviderAddresses(params.Addresses...) + controllerConfig, err := factory.st.ControllerConfig() + c.Assert(err, jc.ErrorIsNil) + err = machine.SetProviderAddresses(controllerConfig, params.Addresses...) c.Assert(err, jc.ErrorIsNil) } current := testing.CurrentVersion()