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
}
