func mockedAPIState(flags mockedStateFlags) *mockAPIState { hasHostPort := flags&mockedHostPort == mockedHostPort hasEnvironTag := flags&mockedEnvironTag == mockedEnvironTag preferIPv6 := flags&mockedPreferIPv6 == mockedPreferIPv6 apiHostPorts := [][]network.HostPort{} if hasHostPort { ipv4Address := network.NewAddress("0.1.2.3", network.ScopeUnknown) ipv6Address := network.NewAddress("fc00::1", network.ScopeUnknown) if preferIPv6 { apiHostPorts = [][]network.HostPort{ network.AddressesWithPort([]network.Address{ipv6Address, ipv4Address}, 1234), } } else { apiHostPorts = [][]network.HostPort{ network.AddressesWithPort([]network.Address{ipv4Address, ipv6Address}, 1234), } } } environTag := "" if hasEnvironTag { environTag = "environment-fake-uuid" } return &mockAPIState{ apiHostPorts: apiHostPorts, environTag: environTag, } }
func (s *unitSuite) TestWatchAddresses(c *gc.C) { w, err := s.apiUnit.WatchAddresses() defer statetesting.AssertStop(c, w) wc := statetesting.NewNotifyWatcherC(c, s.BackingState, w) // Initial event. wc.AssertOneChange() // Update config a couple of times, check a single event. err = s.wordpressMachine.SetAddresses(network.NewAddress("0.1.2.3", network.ScopeUnknown)) c.Assert(err, gc.IsNil) err = s.wordpressMachine.SetAddresses(network.NewAddress("0.1.2.4", network.ScopeUnknown)) c.Assert(err, gc.IsNil) wc.AssertOneChange() // Non-change is not reported. err = s.wordpressMachine.SetAddresses(network.NewAddress("0.1.2.4", network.ScopeUnknown)) c.Assert(err, gc.IsNil) wc.AssertNoChange() // NOTE: This test is not as exhaustive as the one in state, // because the watcher is already tested there. Here we just // ensure we get the events when we expect them and don't get // them when they're not expected. statetesting.AssertStop(c, w) wc.AssertClosed() }
func (s *SubnetSuite) TestSubnetRemoveKillsAddresses(c *gc.C) { subnetInfo := state.SubnetInfo{CIDR: "192.168.1.0/24"} subnet, err := s.State.AddSubnet(subnetInfo) c.Assert(err, jc.ErrorIsNil) _, err = s.State.AddIPAddress( network.NewAddress("192.168.1.0"), subnet.ID(), ) c.Assert(err, jc.ErrorIsNil) _, err = s.State.AddIPAddress( network.NewAddress("192.168.1.1"), subnet.ID(), ) c.Assert(err, jc.ErrorIsNil) err = subnet.EnsureDead() c.Assert(err, jc.ErrorIsNil) err = subnet.Remove() c.Assert(err, jc.ErrorIsNil) _, err = s.State.IPAddress("192.168.1.0") c.Assert(err, jc.Satisfies, errors.IsNotFound) _, err = s.State.IPAddress("192.168.1.1") c.Assert(err, jc.Satisfies, errors.IsNotFound) }
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.Address{ network.NewAddress("127.0.0.1", network.ScopeUnknown), network.NewAddress("8.8.8.8", network.ScopeUnknown), } args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{ {Tag: "machine-1", Addresses: addresses}, {Tag: "machine-0", Addresses: addresses}, {Tag: "machine-42", Addresses: addresses}, }} result, err := s.machiner.SetMachineAddresses(args) c.Assert(err, gc.IsNil) c.Assert(result, gc.DeepEquals, params.ErrorResults{ Results: []params.ErrorResult{ {nil}, {apiservertesting.ErrUnauthorized}, {apiservertesting.ErrUnauthorized}, }, }) err = s.machine1.Refresh() c.Assert(err, gc.IsNil) c.Assert(s.machine1.MachineAddresses(), gc.DeepEquals, addresses) err = s.machine0.Refresh() c.Assert(err, gc.IsNil) c.Assert(s.machine0.MachineAddresses(), gc.HasLen, 0) }
func (s *lxcBrokerSuite) TestSetupRoutesAndIPTablesAddsRuleIfMissing(c *gc.C) { // Isolate the test from the host machine. Because PatchExecutable // does not allow us to assert on subsequent executions of the // same binary, we need to replace the iptables commands with // separate ones. The check returns code=1 to trigger calling // add. fakeptablesRules := map[string]provisioner.IptablesRule{ "IPTablesSNAT": { "nat", "POSTROUTING", "{{.HostIF}} {{.HostIP}}", }, } s.PatchValue(provisioner.IptablesRules, fakeptablesRules) gitjujutesting.PatchExecutableAsEchoArgs(c, s, "iptables", 1, 0) gitjujutesting.PatchExecutableAsEchoArgs(c, s, "ip") ifaceInfo := []network.InterfaceInfo{{ Address: network.NewAddress("0.1.2.3"), }} addr := network.NewAddress("0.1.2.1") err := provisioner.SetupRoutesAndIPTables("nic", addr, "bridge", ifaceInfo, false) c.Assert(err, jc.ErrorIsNil) // Now verify the expected commands - since check returns 1, add // will be called before ip route add. gitjujutesting.AssertEchoArgs(c, "iptables", "-t", "nat", "-C", "POSTROUTING", "nic", "0.1.2.1") gitjujutesting.AssertEchoArgs(c, "iptables", "-t", "nat", "-I", "POSTROUTING", "1", "nic", "0.1.2.1") gitjujutesting.AssertEchoArgs(c, "ip", "route", "add", "0.1.2.3", "dev", "bridge") }
func mockedAPIState(flags mockedStateFlags) *mockAPIState { hasHostPort := flags&mockedHostPort == mockedHostPort hasEnvironTag := flags&mockedEnvironTag == mockedEnvironTag preferIPv6 := flags&mockedPreferIPv6 == mockedPreferIPv6 addr := "" apiHostPorts := [][]network.HostPort{} if hasHostPort { var apiAddrs []network.Address ipv4Address := network.NewAddress("0.1.2.3") ipv6Address := network.NewAddress("2001:db8::1") if preferIPv6 { addr = net.JoinHostPort(ipv6Address.Value, "1234") apiAddrs = append(apiAddrs, ipv6Address, ipv4Address) } else { addr = net.JoinHostPort(ipv4Address.Value, "1234") apiAddrs = append(apiAddrs, ipv4Address, ipv6Address) } apiHostPorts = [][]network.HostPort{ network.AddressesWithPort(apiAddrs, 1234), } } environTag := "" if hasEnvironTag { environTag = "environment-df136476-12e9-11e4-8a70-b2227cce2b54" } return &mockAPIState{ apiHostPorts: apiHostPorts, environTag: environTag, addr: addr, } }
func (*HostPortSuite) TestParseHostPortsSuccess(c *gc.C) { for i, test := range []struct { args []string expect []network.HostPort }{{ args: nil, expect: []network.HostPort{}, }, { args: []string{"1.2.3.4:42"}, expect: network.NewHostPorts(42, "1.2.3.4"), }, { args: []string{"[fc00::1]:1234"}, expect: network.NewHostPorts(1234, "fc00::1"), }, { args: []string{"[fc00::1]:1234", "127.0.0.1:4321", "example.com:42"}, expect: []network.HostPort{ {network.NewAddress("fc00::1"), 1234}, {network.NewAddress("127.0.0.1"), 4321}, {network.NewAddress("example.com"), 42}, }, }} { c.Logf("test %d: args %v", i, test.args) hps, err := network.ParseHostPorts(test.args...) c.Check(err, jc.ErrorIsNil) c.Check(hps, jc.DeepEquals, test.expect) } }
func (s *suite) TestAllocateAddress(c *gc.C) { e := s.bootstrapTestEnviron(c, false) defer func() { err := e.Destroy() c.Assert(err, gc.IsNil) }() inst, _ := jujutesting.AssertStartInstance(c, e, "0") c.Assert(inst, gc.NotNil) netId := network.Id("net1") opc := make(chan dummy.Operation, 200) dummy.Listen(opc) expectAddress := network.NewAddress("0.1.2.1", network.ScopeCloudLocal) address, err := e.AllocateAddress(inst.Id(), netId) c.Assert(err, gc.IsNil) c.Assert(address, gc.DeepEquals, expectAddress) assertAllocateAddress(c, e, opc, inst.Id(), netId, expectAddress) expectAddress = network.NewAddress("0.1.2.2", network.ScopeCloudLocal) address, err = e.AllocateAddress(inst.Id(), netId) c.Assert(err, gc.IsNil) c.Assert(address, gc.DeepEquals, expectAddress) assertAllocateAddress(c, e, opc, inst.Id(), netId, expectAddress) }
func (s *MachinerSuite) TestMachineAddresses(c *gc.C) { s.PatchValue(machiner.InterfaceAddrs, func() ([]net.Addr, error) { addrs := []net.Addr{ &net.IPAddr{IP: net.IPv4(10, 0, 0, 1)}, &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}, &net.IPAddr{IP: net.IPv6loopback}, &net.UnixAddr{}, // not IP, ignored &net.IPNet{IP: net.ParseIP("2001:db8::1")}, &net.IPAddr{IP: net.IPv4(169, 254, 1, 20)}, // LinkLocal Ignored &net.IPNet{IP: net.ParseIP("fe80::1")}, // LinkLocal Ignored } return addrs, nil }) mr := s.makeMachiner() defer worker.Stop(mr) c.Assert(s.machine.Destroy(), gc.IsNil) s.State.StartSync() c.Assert(mr.Wait(), gc.Equals, worker.ErrTerminateAgent) c.Assert(s.machine.Refresh(), gc.IsNil) c.Assert(s.machine.MachineAddresses(), jc.DeepEquals, []network.Address{ network.NewAddress("2001:db8::1", network.ScopeUnknown), network.NewAddress("::1", network.ScopeMachineLocal), network.NewAddress("10.0.0.1", network.ScopeCloudLocal), network.NewAddress("127.0.0.1", network.ScopeMachineLocal), }) }
// mockedAPIState returns a mocked-up implementation // of api.Connection. The logical OR of the flags specifies // whether to include a fake host port and model tag // in the result. func mockedAPIState(flags mockedStateFlags) *mockAPIState { hasHostPort := flags&mockedHostPort == mockedHostPort hasModelTag := flags&mockedModelTag == mockedModelTag addr := "" apiHostPorts := [][]network.HostPort{} if hasHostPort { var apiAddrs []network.Address ipv4Address := network.NewAddress("0.1.2.3") ipv6Address := network.NewAddress("2001:db8::1") addr = net.JoinHostPort(ipv4Address.Value, "1234") apiAddrs = append(apiAddrs, ipv4Address, ipv6Address) apiHostPorts = [][]network.HostPort{ network.AddressesWithPort(apiAddrs, 1234), } } modelTag := "" if hasModelTag { modelTag = "model-df136476-12e9-11e4-8a70-b2227cce2b54" } return &mockAPIState{ apiHostPorts: apiHostPorts, modelTag: modelTag, controllerTag: testing.ControllerTag.Id(), addr: addr, } }
func (s *unitSuite) TestWatchAddresses(c *gc.C) { w, err := s.apiUnit.WatchAddresses() c.Assert(err, jc.ErrorIsNil) wc := watchertest.NewNotifyWatcherC(c, w, s.BackingState.StartSync) defer wc.AssertStops() // Initial event. wc.AssertOneChange() // Update config a couple of times, check a single event. err = s.wordpressMachine.SetProviderAddresses(network.NewAddress("0.1.2.3")) c.Assert(err, jc.ErrorIsNil) err = s.wordpressMachine.SetProviderAddresses(network.NewAddress("0.1.2.4")) c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() // Non-change is not reported. err = s.wordpressMachine.SetProviderAddresses(network.NewAddress("0.1.2.4")) c.Assert(err, jc.ErrorIsNil) wc.AssertNoChange() // Change is reported for machine addresses. err = s.wordpressMachine.SetMachineAddresses(network.NewAddress("0.1.2.5")) c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() // Set machine addresses to empty is reported. err = s.wordpressMachine.SetMachineAddresses() c.Assert(err, jc.ErrorIsNil) wc.AssertOneChange() }
func (s *FilterSuite) TestConfigEvents(c *gc.C) { f, err := filter.NewFilter(s.uniter, s.unit.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) defer statetesting.AssertStop(c, f) err = s.machine.SetProviderAddresses(network.NewAddress("0.1.2.3")) c.Assert(err, jc.ErrorIsNil) // Test no changes before the charm URL is set. configC := s.notifyAsserterC(c, f.ConfigEvents()) configC.AssertNoReceive() // Set the charm URL to trigger config events. err = f.SetCharm(s.wpcharm.URL()) c.Assert(err, jc.ErrorIsNil) s.EvilSync() configC.AssertOneReceive() // Change the config; new event received. changeConfig := func(title interface{}) { err := s.wordpress.UpdateConfigSettings(charm.Settings{ "blog-title": title, }) c.Assert(err, jc.ErrorIsNil) } changeConfig("20,000 leagues in the cloud") configC.AssertOneReceive() // Change the config a few more times, then reset the events. We sync to // make sure the events have arrived in the watcher -- and then wait a // little longer, to allow for the delay while the events are coalesced // -- before we tell it to discard all received events. This would be // much better tested by controlling a mocked-out watcher directly, but // that's a bit inconvenient for this change. changeConfig(nil) changeConfig("the curious incident of the dog in the cloud") s.EvilSync() f.DiscardConfigEvent() configC.AssertNoReceive() // Change the addresses of the unit's assigned machine; new event received. err = s.machine.SetProviderAddresses(network.NewAddress("0.1.2.4")) c.Assert(err, jc.ErrorIsNil) s.BackingState.StartSync() configC.AssertOneReceive() // Check that a filter's initial event works with DiscardConfigEvent // as expected. f, err = filter.NewFilter(s.uniter, s.unit.Tag().(names.UnitTag)) c.Assert(err, jc.ErrorIsNil) defer statetesting.AssertStop(c, f) s.BackingState.StartSync() f.DiscardConfigEvent() configC.AssertNoReceive() // Further changes are still collapsed as appropriate. changeConfig("forsooth") changeConfig("imagination failure") configC.AssertOneReceive() }
func (s *lxcBrokerSuite) TestSetupRoutesAndIPTablesIPTablesAddError(c *gc.C) { // Isolate the test from the host machine. Patch iptables with a // script which returns code=1 for the check but fails when adding // the rule. script := `if [[ "$3" == "-C" ]]; then exit 1; else exit 42; fi` gitjujutesting.PatchExecutable(c, s, "iptables", script) gitjujutesting.PatchExecutableThrowError(c, s, "ip", 123) fakeptablesRules := map[string]provisioner.IptablesRule{ "IPTablesSNAT": { "nat", "POSTROUTING", "{{.HostIF}} {{.HostIP}}", }, } s.PatchValue(provisioner.IptablesRules, fakeptablesRules) ifaceInfo := []network.InterfaceInfo{{ Address: network.NewAddress("0.1.2.3"), }} addr := network.NewAddress("0.1.2.1") err := provisioner.SetupRoutesAndIPTables("nic", addr, "bridge", ifaceInfo, false) c.Assert(err, gc.ErrorMatches, `command "iptables -t nat -I .*" failed with exit code 42`) }
func (s *kvmProvisionerSuite) SetUpTest(c *gc.C) { s.CommonProvisionerSuite.SetUpTest(c) s.kvmSuite.SetUpTest(c) // The kvm provisioner actually needs the machine it is being created on // to be in state, in order to get the watcher. m, err := s.State.AddMachine(coretesting.FakeDefaultSeries, state.JobHostUnits, state.JobManageEnviron) c.Assert(err, gc.IsNil) err = m.SetAddresses(network.NewAddress("0.1.2.3", network.ScopeUnknown)) c.Assert(err, gc.IsNil) hostPorts := [][]network.HostPort{{{ Address: network.NewAddress("0.1.2.3", network.ScopeUnknown), Port: 1234, }}} err = s.State.SetAPIHostPorts(hostPorts) c.Assert(err, gc.IsNil) s.machineId = m.Id() s.APILogin(c, m) err = m.SetAgentVersion(version.Current) c.Assert(err, gc.IsNil) s.events = make(chan mock.Event, 25) s.ContainerFactory.AddListener(s.events) }
func (s *InterfaceInfoSuite) TestAdditionalFields(c *gc.C) { c.Check(s.info[3].ConfigType, gc.Equals, network.ConfigDHCP) c.Check(s.info[3].NoAutoStart, jc.IsTrue) c.Check(s.info[4].Address, jc.DeepEquals, network.NewAddress("0.1.2.3")) c.Check(s.info[5].DNSServers, jc.DeepEquals, network.NewAddresses("1.1.1.1", "2.2.2.2")) c.Check(s.info[6].GatewayAddress, jc.DeepEquals, network.NewAddress("4.3.2.1")) c.Check(s.info[7].AvailabilityZones, jc.DeepEquals, []string{"foo", "bar"}) }
func (fakeAddresses) APIHostPorts() ([][]network.HostPort, error) { return [][]network.HostPort{{{ Address: network.NewAddress("apiaddresses", network.ScopeUnknown), Port: 1, }}, {{ Address: network.NewAddress("apiaddresses", network.ScopeUnknown), Port: 2, }}}, nil }
func (s *AddressSuite) TestNewAddressHostname(c *gc.C) { addr := network.NewAddress("localhost", network.ScopeUnknown) c.Check(addr.Value, gc.Equals, "localhost") c.Check(addr.Type, gc.Equals, network.HostName) c.Check(addr.Scope, gc.Equals, network.ScopeUnknown) addr = network.NewAddress("example.com", network.ScopeUnknown) c.Check(addr.Value, gc.Equals, "example.com") c.Check(addr.Type, gc.Equals, network.HostName) c.Check(addr.Scope, gc.Equals, network.ScopeUnknown) }
func (s *APIEndpointForEnvSuite) TestAPIEndpointNotMachineLocal(c *gc.C) { store := newConfigStore("env-name", dummyStoreInfo) called := 0 hostPorts := [][]network.HostPort{ network.AddressesWithPort([]network.Address{ network.NewAddress("1.0.0.1", network.ScopePublic), network.NewAddress("192.0.0.1", network.ScopeCloudLocal), network.NewAddress("127.0.0.1", network.ScopeMachineLocal), network.NewAddress("localhost", network.ScopeMachineLocal), }, 1234), network.AddressesWithPort([]network.Address{ network.NewAddress("1.0.0.2", network.ScopeUnknown), network.NewAddress("2002:0:0:0:0:0:100:2", network.ScopeUnknown), network.NewAddress("::1", network.ScopeMachineLocal), network.NewAddress("127.0.0.1", network.ScopeMachineLocal), network.NewAddress("localhost", network.ScopeMachineLocal), }, 1235), } expectState := &mockAPIState{apiHostPorts: hostPorts} apiOpen := func(_ *api.Info, _ api.DialOpts) (juju.APIState, error) { called++ return expectState, nil } endpoint, err := juju.APIEndpointInStore("env-name", true, store, apiOpen) c.Assert(err, gc.IsNil) c.Check(called, gc.Equals, 1) c.Check(endpoint.Addresses, gc.DeepEquals, []string{ "1.0.0.1:1234", "192.0.0.1:1234", "1.0.0.2:1235", }) }
func (s *InterfaceInfoSuite) TestAdditionalFields(c *gc.C) { c.Check(s.info[3].ConfigType, gc.Equals, network.ConfigDHCP) c.Check(s.info[3].NoAutoStart, jc.IsTrue) c.Check(s.info[4].Address, jc.DeepEquals, network.NewAddress("0.1.2.3")) c.Check(s.info[5].DNSServers, jc.DeepEquals, network.NewAddresses("1.1.1.1", "2.2.2.2")) c.Check(s.info[6].GatewayAddress, jc.DeepEquals, network.NewAddress("4.3.2.1")) c.Check(s.info[7].ExtraConfig, jc.DeepEquals, map[string]string{ "foo": "bar", "baz": "nonsense", }) }
func (*PortSuite) TestAddressesWithPort(c *gc.C) { addrs := network.NewAddresses("0.1.2.3", "0.2.4.6") hps := network.AddressesWithPort(addrs, 999) c.Assert(hps, jc.DeepEquals, []network.HostPort{{ Address: network.NewAddress("0.1.2.3", network.ScopeUnknown), Port: 999, }, { Address: network.NewAddress("0.2.4.6", network.ScopeUnknown), Port: 999, }}) }
func (s *AddressSuite) TestNewAddressIpv6(c *gc.C) { addr := network.NewAddress("::1", network.ScopeUnknown) c.Check(addr.Value, gc.Equals, "::1") c.Check(addr.Type, gc.Equals, network.IPv6Address) c.Check(addr.Scope, gc.Equals, network.ScopeMachineLocal) addr = network.NewAddress("2001:DB8::1", network.ScopeUnknown) c.Check(addr.Value, gc.Equals, "2001:DB8::1") c.Check(addr.Type, gc.Equals, network.IPv6Address) c.Check(addr.Scope, gc.Equals, network.ScopeUnknown) }
func (*HostPortSuite) TestAddressesWithPortAndHostsWithoutPort(c *gc.C) { addrs := network.NewAddresses("0.1.2.3", "0.2.4.6") hps := network.AddressesWithPort(addrs, 999) c.Assert(hps, jc.DeepEquals, []network.HostPort{{ Address: network.NewAddress("0.1.2.3"), Port: 999, }, { Address: network.NewAddress("0.2.4.6"), Port: 999, }}) c.Assert(network.HostsWithoutPort(hps), jc.DeepEquals, addrs) }
func (s *InterfaceInfoSuite) SetUpTest(c *gc.C) { s.info = []network.InterfaceInfo{ {VLANTag: 1, DeviceIndex: 0, InterfaceName: "eth0"}, {VLANTag: 0, DeviceIndex: 1, InterfaceName: "eth1"}, {VLANTag: 42, DeviceIndex: 2, InterfaceName: "br2"}, {ConfigType: network.ConfigDHCP, NoAutoStart: true}, {Address: network.NewAddress("0.1.2.3")}, {DNSServers: network.NewAddresses("1.1.1.1", "2.2.2.2")}, {GatewayAddress: network.NewAddress("4.3.2.1")}, {AvailabilityZones: []string{"foo", "bar"}}, } }
func (s *lxcBrokerSuite) TestSetupRoutesAndIPTablesIPTablesCheckError(c *gc.C) { // Isolate the test from the host machine. gitjujutesting.PatchExecutableThrowError(c, s, "iptables", 42) gitjujutesting.PatchExecutableThrowError(c, s, "ip", 123) ifaceInfo := []network.InterfaceInfo{{ Address: network.NewAddress("0.1.2.3"), }} addr := network.NewAddress("0.1.2.1") err := provisioner.SetupRoutesAndIPTables("nic", addr, "bridge", ifaceInfo, false) c.Assert(err, gc.ErrorMatches, "iptables failed with unexpected exit code 42") }
// prepareOrGetContainerInterfaceInfo returns the necessary information to // configure network interfaces of a container with allocated static // IP addresses. // // TODO(dimitern): Before we start using this, we need to rename both // the method and the network.InterfaceInfo type to be called // InterfaceConfig. func (st *State) prepareOrGetContainerInterfaceInfo( containerTag names.MachineTag, allocateNewAddress bool) ( []network.InterfaceInfo, error) { var result params.MachineNetworkConfigResults args := params.Entities{ Entities: []params.Entity{{Tag: containerTag.String()}}, } facadeName := "" if allocateNewAddress { facadeName = "PrepareContainerInterfaceInfo" } else { facadeName = "GetContainerInterfaceInfo" } if err := st.facade.FacadeCall(facadeName, args, &result); err != nil { return nil, err } if len(result.Results) != 1 { return nil, errors.Errorf("expected 1 result, got %d", len(result.Results)) } if err := result.Results[0].Error; err != nil { return nil, err } ifaceInfo := make([]network.InterfaceInfo, len(result.Results[0].Config)) for i, cfg := range result.Results[0].Config { ifaceInfo[i] = network.InterfaceInfo{ DeviceIndex: cfg.DeviceIndex, MACAddress: cfg.MACAddress, CIDR: cfg.CIDR, MTU: cfg.MTU, ProviderId: network.Id(cfg.ProviderId), ProviderSubnetId: network.Id(cfg.ProviderSubnetId), ProviderSpaceId: network.Id(cfg.ProviderSpaceId), ProviderVLANId: network.Id(cfg.ProviderVLANId), ProviderAddressId: network.Id(cfg.ProviderAddressId), VLANTag: cfg.VLANTag, InterfaceName: cfg.InterfaceName, ParentInterfaceName: cfg.ParentInterfaceName, InterfaceType: network.InterfaceType(cfg.InterfaceType), Disabled: cfg.Disabled, NoAutoStart: cfg.NoAutoStart, ConfigType: network.InterfaceConfigType(cfg.ConfigType), Address: network.NewAddress(cfg.Address), DNSServers: network.NewAddresses(cfg.DNSServers...), DNSSearchDomains: cfg.DNSSearchDomains, GatewayAddress: network.NewAddress(cfg.GatewayAddress), } } return ifaceInfo, nil }
// AddStateServerMachine adds a "state server" machine to the state so // that State.Addresses and State.APIAddresses will work. It returns the // added machine. The addresses that those methods will return bear no // relation to the addresses actually used by the state and API servers. // It returns the addresses that will be returned by the State.Addresses // and State.APIAddresses methods, which will not bear any relation to // the be the addresses used by the state servers. func AddStateServerMachine(c *gc.C, st *state.State) *state.Machine { machine, err := st.AddMachine("quantal", state.JobManageEnviron) c.Assert(err, gc.IsNil) err = machine.SetAddresses(network.NewAddress("0.1.2.3", network.ScopeUnknown)) c.Assert(err, gc.IsNil) hostPorts := [][]network.HostPort{{{ Address: network.NewAddress("0.1.2.3", network.ScopeUnknown), Port: 1234, }}} err = st.SetAPIHostPorts(hostPorts) c.Assert(err, gc.IsNil) return machine }
func (s *maas2InstanceSuite) TestAddresses(c *gc.C) { instance := &maas2Instance{machine: &fakeMachine{ipAddresses: []string{ "0.0.0.0", "1.2.3.4", "127.0.0.1", }}} expectedAddresses := []network.Address{ network.NewAddress("0.0.0.0"), network.NewAddress("1.2.3.4"), network.NewAddress("127.0.0.1"), } addresses, err := instance.Addresses() c.Assert(err, jc.ErrorIsNil) c.Assert(addresses, jc.SameContents, expectedAddresses) }
func (s *provisionerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) // We're testing with address allocation on by default. There are // separate tests to check the behavior when the flag is not // enabled. s.SetFeatureFlags(feature.AddressAllocation) var err error s.machine, err = s.State.AddMachine("quantal", state.JobManageModel) c.Assert(err, jc.ErrorIsNil) password, err := utils.RandomPassword() c.Assert(err, jc.ErrorIsNil) err = s.machine.SetPassword(password) c.Assert(err, jc.ErrorIsNil) err = s.machine.SetInstanceInfo("i-manager", "fake_nonce", nil, nil, nil, nil, nil) c.Assert(err, jc.ErrorIsNil) s.st = s.OpenAPIAsMachine(c, s.machine.Tag(), password, "fake_nonce") c.Assert(s.st, gc.NotNil) err = s.machine.SetProviderAddresses(network.NewAddress("0.1.2.3")) c.Assert(err, jc.ErrorIsNil) // Create the provisioner API facade. s.provisioner = s.st.Provisioner() c.Assert(s.provisioner, gc.NotNil) s.ModelWatcherTests = apitesting.NewModelWatcherTests(s.provisioner, s.BackingState, apitesting.HasSecrets) s.APIAddresserTests = apitesting.NewAPIAddresserTests(s.provisioner, s.BackingState) }
// AllocateAddress requests a new address to be allocated for the // given instance on the given network. func (env *environ) AllocateAddress(instId instance.Id, netId network.Id) (network.Address, error) { if err := env.checkBroken("AllocateAddress"); err != nil { return network.Address{}, err } estate, err := env.state() if err != nil { return network.Address{}, err } estate.mu.Lock() defer estate.mu.Unlock() estate.maxAddr++ // TODO(dimitern) Once we have integrated networks // and addresses, make sure we return a valid address // for the given network, and we also have the network // already registered. newAddress := network.NewAddress( fmt.Sprintf("0.1.2.%d", estate.maxAddr), network.ScopeCloudLocal, ) estate.ops <- OpAllocateAddress{ Env: env.name, InstanceId: instId, NetworkId: netId, Address: newAddress, } return newAddress, nil }
func (ac *addressesChange) Addresses() ([]network.Address, error) { var addrs []network.Address for _, addr := range ac.addrs[0] { addrs = append(addrs, network.NewAddress(addr, network.ScopeUnknown)) } return addrs, nil }