func (suite *StateSuite) TestGetAddressesReturnsNames(c *gc.C) { instances := []instance.Instance{ &mockInstance{addresses: network.NewAddresses("foo")}, &mockInstance{addresses: network.NewAddresses("bar")}, } c.Check(common.GetAddresses(instances), gc.DeepEquals, []string{"foo", "bar"}) }
func (*AddressSuite) TestSortAddresses(c *gc.C) { addrs := network.NewAddresses( "127.0.0.1", "localhost", "example.com", "::1", "fc00::1", "fe80::2", "172.16.0.1", "8.8.8.8", ) network.SortAddresses(addrs, false) c.Assert(addrs, jc.DeepEquals, network.NewAddresses( "example.com", "localhost", "127.0.0.1", "172.16.0.1", "8.8.8.8", "::1", "fe80::2", "fc00::1", )) network.SortAddresses(addrs, true) c.Assert(addrs, jc.DeepEquals, network.NewAddresses( "example.com", "localhost", "fe80::2", "::1", "fc00::1", "127.0.0.1", "172.16.0.1", "8.8.8.8", )) }
func (mi *maasInstance) Addresses() ([]network.Address, error) { name, err := mi.hostname() if err != nil { return nil, err } // MAAS prefers to use the dns name for intra-node communication. // When Juju looks up the address to use for communicating between // nodes, it looks up the address by scope. So we add a cloud // local address for that purpose. addrs := network.NewAddresses(name, name) addrs[0].Scope = network.ScopePublic addrs[1].Scope = network.ScopeCloudLocal // Append any remaining IP addresses after the preferred ones. ips, err := mi.ipAddresses() if err != nil { return nil, err } addrs = append(addrs, network.NewAddresses(ips...)...) // Although we would prefer a DNS name there's no point // returning unresolvable names because activities like 'juju // ssh 0' will instantly fail. return resolveHostnames(addrs), nil }
func (*suite) TestSetAPIHostPorts(c *gc.C) { conf, err := agent.NewAgentConfig(attributeParams) c.Assert(err, jc.ErrorIsNil) addrs, err := conf.APIAddresses() c.Assert(err, jc.ErrorIsNil) c.Assert(addrs, gc.DeepEquals, attributeParams.APIAddresses) // The first cloud-local address for each server is used, // else if there are none then the first public- or unknown- // scope address. // // If a server has only machine-local addresses, or none // at all, then it will be excluded. server1 := network.NewAddresses("0.1.2.3", "0.1.2.4", "zeroonetwothree") server1[0].Scope = network.ScopeCloudLocal server1[1].Scope = network.ScopeCloudLocal server1[2].Scope = network.ScopePublic server2 := network.NewAddresses("127.0.0.1") server2[0].Scope = network.ScopeMachineLocal server3 := network.NewAddresses("0.1.2.5", "zeroonetwofive") server3[0].Scope = network.ScopeUnknown server3[1].Scope = network.ScopeUnknown conf.SetAPIHostPorts([][]network.HostPort{ network.AddressesWithPort(server1, 123), network.AddressesWithPort(server2, 124), network.AddressesWithPort(server3, 125), }) addrs, err = conf.APIAddresses() c.Assert(err, jc.ErrorIsNil) c.Assert(addrs, gc.DeepEquals, []string{"0.1.2.3:123", "0.1.2.5:125"}) }
func (s *instanceSuite) TestMultipleInstanceAddresses(c *gc.C) { nic0IPConfiguration := makeIPConfiguration("10.0.0.4") nic1IPConfiguration := makeIPConfiguration("10.0.0.5") s.networkInterfaces = []network.Interface{ makeNetworkInterface("nic-0", "machine-0", nic0IPConfiguration), makeNetworkInterface("nic-1", "machine-1", nic1IPConfiguration), } s.publicIPAddresses = []network.PublicIPAddress{ makePublicIPAddress("pip-0", "machine-0", "1.2.3.4"), makePublicIPAddress("pip-1", "machine-1", "1.2.3.5"), } instances := s.getInstances(c, "machine-0", "machine-1") c.Assert(instances, gc.HasLen, 2) inst0Addresses, err := instances[0].Addresses() c.Assert(err, jc.ErrorIsNil) c.Assert(inst0Addresses, jc.DeepEquals, jujunetwork.NewAddresses( "10.0.0.4", "1.2.3.4", )) inst1Addresses, err := instances[1].Addresses() c.Assert(err, jc.ErrorIsNil) c.Assert(inst1Addresses, jc.DeepEquals, jujunetwork.NewAddresses( "10.0.0.5", "1.2.3.5", )) }
func (s *machinerSuite) TestSetMachineAddresses(c *gc.C) { c.Assert(s.machine0.Addresses(), gc.HasLen, 0) c.Assert(s.machine1.Addresses(), gc.HasLen, 0) addresses := network.NewAddresses("127.0.0.1", "8.8.8.8") args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{ {Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)}, {Tag: "machine-0", Addresses: params.FromNetworkAddresses(addresses)}, {Tag: "machine-42", Addresses: params.FromNetworkAddresses(addresses)}, }} result, err := s.machiner.SetMachineAddresses(args) c.Assert(err, jc.ErrorIsNil) c.Assert(result, gc.DeepEquals, params.ErrorResults{ Results: []params.ErrorResult{ {nil}, {apiservertesting.ErrUnauthorized}, {apiservertesting.ErrUnauthorized}, }, }) err = s.machine1.Refresh() c.Assert(err, jc.ErrorIsNil) expectedAddresses := network.NewAddresses("8.8.8.8", "127.0.0.1") c.Assert(s.machine1.MachineAddresses(), gc.DeepEquals, expectedAddresses) err = s.machine0.Refresh() c.Assert(err, jc.ErrorIsNil) c.Assert(s.machine0.MachineAddresses(), gc.HasLen, 0) }
func (s *InstancePollerSuite) TestSetProviderAddressesFailure(c *gc.C) { s.st.SetErrors( errors.New("pow!"), // m1 := FindEntity("1") nil, // m2 := FindEntity("2") errors.New("FAIL"), // m2.SetProviderAddresses() errors.NotProvisionedf("machine 42"), // FindEntity("3") (ensure wrapping is preserved) ) oldAddrs := network.NewAddresses("0.1.2.3", "127.0.0.1", "8.8.8.8") newAddrs := network.NewAddresses("1.2.3.4", "8.4.4.8", "2001:db8::") s.st.SetMachineInfo(c, machineInfo{id: "1", providerAddresses: oldAddrs}) s.st.SetMachineInfo(c, machineInfo{id: "2", providerAddresses: nil}) result, err := s.api.SetProviderAddresses(params.SetMachinesAddresses{ MachineAddresses: []params.MachineAddresses{ {Tag: "machine-1"}, {Tag: "machine-2", Addresses: params.FromNetworkAddresses(newAddrs...)}, {Tag: "machine-3"}, }}, ) c.Assert(err, jc.ErrorIsNil) c.Assert(result, jc.DeepEquals, s.machineErrorResults) s.st.CheckFindEntityCall(c, 0, "1") s.st.CheckFindEntityCall(c, 1, "2") s.st.CheckSetProviderAddressesCall(c, 2, newAddrs) s.st.CheckFindEntityCall(c, 3, "3") // Ensure machine 2 wasn't updated. machine, err := s.st.Machine("2") c.Assert(err, jc.ErrorIsNil) c.Assert(machine.ProviderAddresses(), gc.HasLen, 0) }
func (s *publishSuite) TestPublisherSetsAPIHostPortsOnce(c *gc.C) { var mock mockAPIHostPortsSetter statePublish := newPublisher(&mock) hostPorts1 := network.AddressesWithPort(network.NewAddresses("testing1.invalid", "127.0.0.1"), 1234) hostPorts2 := network.AddressesWithPort(network.NewAddresses("testing2.invalid", "127.0.0.2"), 1234) // statePublish.publishAPIServers should not update state a second time. apiServers := [][]network.HostPort{hostPorts1} for i := 0; i < 2; i++ { err := statePublish.publishAPIServers(apiServers, nil) c.Assert(err, gc.IsNil) } c.Assert(mock.calls, gc.Equals, 1) c.Assert(mock.apiHostPorts, gc.DeepEquals, apiServers) apiServers = append(apiServers, hostPorts2) for i := 0; i < 2; i++ { err := statePublish.publishAPIServers(apiServers, nil) c.Assert(err, gc.IsNil) } c.Assert(mock.calls, gc.Equals, 2) c.Assert(mock.apiHostPorts, gc.DeepEquals, apiServers) }
func (s *machinerSuite) TestSetMachineAddresses(c *gc.C) { machine, err := s.machiner.Machine(names.NewMachineTag("1")) c.Assert(err, jc.ErrorIsNil) addr := s.machine.Addresses() c.Assert(addr, gc.HasLen, 0) setAddresses := network.NewAddresses( "8.8.8.8", "127.0.0.1", "10.0.0.1", ) // Before setting, the addresses are sorted to put public on top, // cloud-local next, machine-local last. expectAddresses := network.NewAddresses( "8.8.8.8", "10.0.0.1", "127.0.0.1", ) err = machine.SetMachineAddresses(setAddresses) c.Assert(err, jc.ErrorIsNil) err = s.machine.Refresh() c.Assert(err, jc.ErrorIsNil) c.Assert(s.machine.MachineAddresses(), jc.DeepEquals, expectAddresses) }
func (s *NetworkSuite) TestFilterBridgeAddresses(c *gc.C) { lxcFakeNetConfig := filepath.Join(c.MkDir(), "lxc-net") // We create an LXC bridge named "foobar", and then put 10.0.3.1, // 10.0.3.4 and 10.0.3.5/24 on that bridge. // We also put 10.0.4.1 and 10.0.5.1/24 onto whatever bridge LXD is // configured to use. netConf := []byte(` # comments ignored LXC_BR= ignored LXC_ADDR = "fooo" LXC_BRIDGE = " foobar " # detected, spaces stripped anything else ignored LXC_BRIDGE="ignored"`[1:]) err := ioutil.WriteFile(lxcFakeNetConfig, netConf, 0644) c.Assert(err, jc.ErrorIsNil) s.PatchValue(&network.InterfaceByNameAddrs, func(name string) ([]net.Addr, error) { if name == "foobar" { return []net.Addr{ &net.IPAddr{IP: net.IPv4(10, 0, 3, 1)}, &net.IPAddr{IP: net.IPv4(10, 0, 3, 4)}, // Try a CIDR 10.0.3.5/24 as well. &net.IPNet{IP: net.IPv4(10, 0, 3, 5), Mask: net.IPv4Mask(255, 255, 255, 0)}, }, nil } else if name == network.DefaultLXDBridge { return []net.Addr{ &net.IPAddr{IP: net.IPv4(10, 0, 4, 1)}, // Try a CIDR 10.0.5.1/24 as well. &net.IPNet{IP: net.IPv4(10, 0, 5, 1), Mask: net.IPv4Mask(255, 255, 255, 0)}, }, nil } c.Fatalf("unknown bridge name: %q", name) return nil, nil }) s.PatchValue(&network.LXCNetDefaultConfig, lxcFakeNetConfig) inputAddresses := network.NewAddresses( "127.0.0.1", "2001:db8::1", "10.0.0.1", "10.0.3.1", // filtered (directly as IP) "10.0.3.3", // filtered (by the 10.0.3.5/24 CIDR) "10.0.3.5", // filtered (directly) "10.0.3.4", // filtered (directly) "10.0.4.1", // filtered (directly from LXD bridge) "10.0.5.10", // filtered (from LXD bridge, 10.0.5.1/24) "10.0.6.10", // unfiltered "192.168.123.42", ) filteredAddresses := network.NewAddresses( "127.0.0.1", "2001:db8::1", "10.0.0.1", "10.0.6.10", "192.168.123.42", ) c.Assert(network.FilterBridgeAddresses(inputAddresses), jc.DeepEquals, filteredAddresses) }
func (suite *StateSuite) TestGetAddressesIgnoresAddressesErrors(c *gc.C) { instances := []instance.Instance{ &mockInstance{ addresses: network.NewAddresses("one"), addressesErr: errors.New("ignored"), }, &mockInstance{addresses: network.NewAddresses("two", "three")}, } c.Check(common.GetAddresses(instances), gc.DeepEquals, []string{"two", "three"}) }
func (suite *StateSuite) TestGetAddressesIgnoresNils(c *gc.C) { instances := []instance.Instance{ nil, &mockInstance{addresses: network.NewAddresses("foo")}, nil, &mockInstance{addresses: network.NewAddresses("bar")}, nil, } c.Check(common.GetAddresses(instances), gc.DeepEquals, []string{"foo", "bar"}) c.Check(common.GetAddresses(nil), gc.DeepEquals, []string{}) }
func (*suite) TestSetAPIHostPorts(c *gc.C) { conf, err := agent.NewAgentConfig(attributeParams) c.Assert(err, jc.ErrorIsNil) addrs, err := conf.APIAddresses() c.Assert(err, jc.ErrorIsNil) c.Assert(addrs, gc.DeepEquals, attributeParams.APIAddresses) // All the best candidate addresses for each server are // used. Cloud-local addresses are preferred. Otherwise, public // or unknown scope addresses are used. // // If a server has only machine-local addresses, or none // at all, then it will be excluded. server1 := network.NewAddresses("0.1.0.1", "0.1.0.2", "host.com") server1[0].Scope = network.ScopeCloudLocal server1[1].Scope = network.ScopeCloudLocal server1[2].Scope = network.ScopePublic server2 := network.NewAddresses("0.2.0.1", "0.2.0.2") server2[0].Scope = network.ScopePublic server2[1].Scope = network.ScopePublic server3 := network.NewAddresses("127.0.0.1") server3[0].Scope = network.ScopeMachineLocal server4 := network.NewAddresses("0.4.0.1", "elsewhere.net") server4[0].Scope = network.ScopeUnknown server4[1].Scope = network.ScopeUnknown conf.SetAPIHostPorts([][]network.HostPort{ network.AddressesWithPort(server1, 1111), network.AddressesWithPort(server2, 2222), network.AddressesWithPort(server3, 3333), network.AddressesWithPort(server4, 4444), }) addrs, err = conf.APIAddresses() c.Assert(err, jc.ErrorIsNil) c.Assert(addrs, gc.DeepEquals, []string{ "0.1.0.1:1111", "0.1.0.2:1111", "host.com:1111", "0.2.0.1:2222", "0.2.0.2:2222", "0.4.0.1:4444", "elsewhere.net:4444", }) }
func (s *machineConfigSuite) TestMachineConfig(c *gc.C) { addrs := network.NewAddresses("1.2.3.4") hc := instance.MustParseHardware("mem=4G arch=amd64") apiParams := params.AddMachineParams{ Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}, InstanceId: instance.Id("1234"), Nonce: "foo", HardwareCharacteristics: hc, Addrs: params.FromNetworkAddresses(addrs...), } machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams}) c.Assert(err, jc.ErrorIsNil) c.Assert(len(machines), gc.Equals, 1) machineId := machines[0].Machine instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "") c.Assert(err, jc.ErrorIsNil) cfg, err := s.State.ControllerConfig() c.Assert(err, jc.ErrorIsNil) apiAddrs := []string{net.JoinHostPort("localhost", strconv.Itoa(cfg.APIPort()))} c.Check(instanceConfig.APIInfo.Addrs, gc.DeepEquals, apiAddrs) toolsURL := fmt.Sprintf("https://%s/model/%s/tools/%s", apiAddrs[0], jujutesting.ModelTag.Id(), instanceConfig.AgentVersion()) c.Assert(instanceConfig.ToolsList().URLs(), jc.DeepEquals, map[version.Binary][]string{ instanceConfig.AgentVersion(): []string{toolsURL}, }) }
func (s *machinerSuite) TestSetEmptyMachineAddresses(c *gc.C) { // Set some addresses so we can ensure they are removed. addresses := network.NewAddresses("127.0.0.1", "8.8.8.8") args := params.SetMachinesAddresses{MachineAddresses: []params.MachineAddresses{ {Tag: "machine-1", Addresses: params.FromNetworkAddresses(addresses)}, }} result, err := s.machiner.SetMachineAddresses(args) c.Assert(err, jc.ErrorIsNil) c.Assert(result, gc.DeepEquals, params.ErrorResults{ Results: []params.ErrorResult{ {nil}, }, }) err = s.machine1.Refresh() c.Assert(err, jc.ErrorIsNil) c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 2) args.MachineAddresses[0].Addresses = nil result, err = s.machiner.SetMachineAddresses(args) c.Assert(err, jc.ErrorIsNil) c.Assert(result, gc.DeepEquals, params.ErrorResults{ Results: []params.ErrorResult{ {nil}, }, }) err = s.machine1.Refresh() c.Assert(err, jc.ErrorIsNil) c.Assert(s.machine1.MachineAddresses(), gc.HasLen, 0) }
func (s *InstancePollerSuite) TestProviderAddressesSuccess(c *gc.C) { addrs := network.NewAddresses("0.1.2.3", "127.0.0.1", "8.8.8.8") expectedAddresses := params.FromNetworkAddresses(addrs...) s.st.SetMachineInfo(c, machineInfo{id: "1", providerAddresses: addrs}) s.st.SetMachineInfo(c, machineInfo{id: "2", providerAddresses: nil}) result, err := s.api.ProviderAddresses(s.mixedEntities) c.Assert(err, jc.ErrorIsNil) c.Assert(result, jc.DeepEquals, params.MachineAddressesResults{ Results: []params.MachineAddressesResult{ {Addresses: expectedAddresses}, {Addresses: nil}, {Error: apiservertesting.NotFoundError("machine 42")}, {Error: apiservertesting.ServerError(`"application-unknown" is not a valid machine tag`)}, {Error: apiservertesting.ServerError(`"invalid-tag" is not a valid tag`)}, {Error: apiservertesting.ServerError(`"unit-missing-1" is not a valid machine tag`)}, {Error: apiservertesting.ServerError(`"" is not a valid tag`)}, {Error: apiservertesting.ServerError(`"42" is not a valid tag`)}, }}, ) s.st.CheckFindEntityCall(c, 0, "1") s.st.CheckCall(c, 1, "ProviderAddresses") s.st.CheckFindEntityCall(c, 2, "2") s.st.CheckCall(c, 3, "ProviderAddresses") s.st.CheckFindEntityCall(c, 4, "42") }
func (s *instanceSuite) TestInstanceAddresses(c *gc.C) { nic0IPConfigurations := []network.InterfaceIPConfiguration{ makeIPConfiguration("10.0.0.4"), makeIPConfiguration("10.0.0.5"), } nic1IPConfigurations := []network.InterfaceIPConfiguration{ makeIPConfiguration(""), } s.networkInterfaces = []network.Interface{ makeNetworkInterface("nic-0", "machine-0", nic0IPConfigurations...), makeNetworkInterface("nic-1", "machine-0", nic1IPConfigurations...), makeNetworkInterface("nic-2", "machine-0"), // unrelated NIC makeNetworkInterface("nic-3", "machine-1"), } s.publicIPAddresses = []network.PublicIPAddress{ makePublicIPAddress("pip-0", "machine-0", "1.2.3.4"), makePublicIPAddress("pip-1", "machine-0", "1.2.3.5"), // unrelated PIP makePublicIPAddress("pip-2", "machine-1", "1.2.3.6"), } addresses, err := s.getInstance(c).Addresses() c.Assert(err, jc.ErrorIsNil) c.Assert(addresses, jc.DeepEquals, jujunetwork.NewAddresses( "10.0.0.4", "10.0.0.5", "1.2.3.4", "1.2.3.5", )) }
func (s *machineConfigSuite) TestMachineConfig(c *gc.C) { addrs := network.NewAddresses("1.2.3.4") hc := instance.MustParseHardware("mem=4G arch=amd64") apiParams := params.AddMachineParams{ Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}, InstanceId: instance.Id("1234"), Nonce: "foo", HardwareCharacteristics: hc, Addrs: params.FromNetworkAddresses(addrs), } machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{apiParams}) c.Assert(err, jc.ErrorIsNil) c.Assert(len(machines), gc.Equals, 1) machineId := machines[0].Machine instanceConfig, err := client.InstanceConfig(s.State, machineId, apiParams.Nonce, "") c.Assert(err, jc.ErrorIsNil) envConfig, err := s.State.EnvironConfig() c.Assert(err, jc.ErrorIsNil) mongoAddrs := s.State.MongoConnectionInfo().Addrs apiAddrs := []string{net.JoinHostPort("localhost", strconv.Itoa(envConfig.APIPort()))} c.Check(instanceConfig.MongoInfo.Addrs, gc.DeepEquals, mongoAddrs) c.Check(instanceConfig.APIInfo.Addrs, gc.DeepEquals, apiAddrs) toolsURL := fmt.Sprintf("https://%s/environment/%s/tools/%s", apiAddrs[0], jujutesting.EnvironmentTag.Id(), instanceConfig.Tools.Version) c.Assert(instanceConfig.Tools.URL, gc.Equals, toolsURL) c.Assert(instanceConfig.AgentEnvironment[agent.AllowsSecureConnection], gc.Equals, "true") }
func (s *MachinerSuite) TestMachinerStorageAttached(c *gc.C) { // Machine is dying. We'll respond to "EnsureDead" by // saying that there are still storage attachments; // this should not cause an error. s.accessor.machine.life = params.Dying s.accessor.machine.SetErrors( nil, // SetMachineAddresses nil, // SetStatus nil, // Watch nil, // Refresh nil, // SetStatus ¶ms.Error{Code: params.CodeMachineHasAttachedStorage}, ) worker := machiner.NewMachiner(s.accessor, s.agentConfig, false) s.accessor.machine.watcher.changes <- struct{}{} worker.Kill() c.Check(worker.Wait(), jc.ErrorIsNil) s.accessor.CheckCalls(c, []gitjujutesting.StubCall{{ FuncName: "Machine", Args: []interface{}{s.agentConfig.Tag()}, }}) s.accessor.machine.watcher.CheckCalls(c, []gitjujutesting.StubCall{ {FuncName: "Changes"}, {FuncName: "Changes"}, {FuncName: "Stop"}, }) s.accessor.machine.CheckCalls(c, []gitjujutesting.StubCall{{ FuncName: "SetMachineAddresses", Args: []interface{}{ network.NewAddresses( "255.255.255.255", "0.0.0.0", ), }, }, { FuncName: "SetStatus", Args: []interface{}{ params.StatusStarted, "", map[string]interface{}(nil), }, }, { FuncName: "Watch", }, { FuncName: "Refresh", }, { FuncName: "Life", }, { FuncName: "SetStatus", Args: []interface{}{ params.StatusStopped, "", map[string]interface{}(nil), }, }, { FuncName: "EnsureDead", }}) }
// testNamespace starts a worker and ensures that // the rsyslog config file has the expected filename, // and the appropriate log dir is used. func (s *RsyslogSuite) testNamespace(c *gc.C, st *api.State, tag names.Tag, namespace, expectedFilename, expectedLogDir string) { restarted := make(chan struct{}, 2) // once for create, once for teardown s.PatchValue(rsyslog.RestartRsyslog, func() error { restarted <- struct{}{} return nil }) err := os.MkdirAll(expectedLogDir, 0755) c.Assert(err, gc.IsNil) worker, err := rsyslog.NewRsyslogConfigWorker(st.Rsyslog(), rsyslog.RsyslogModeAccumulate, tag, namespace, []string{"0.1.2.3"}) c.Assert(err, gc.IsNil) defer func() { c.Assert(worker.Wait(), gc.IsNil) }() defer worker.Kill() // change the API HostPorts to trigger an rsyslog restart newHostPorts := network.AddressesWithPort(network.NewAddresses("127.0.0.1"), 6541) err = s.State.SetAPIHostPorts([][]network.HostPort{newHostPorts}) c.Assert(err, gc.IsNil) // Wait for rsyslog to be restarted, so we can check to see // what the name of the config file is. waitForRestart(c, restarted) // Ensure that ca-cert.pem gets written to the expected log dir. waitForFile(c, filepath.Join(expectedLogDir, "ca-cert.pem")) dir, err := os.Open(*rsyslog.RsyslogConfDir) c.Assert(err, gc.IsNil) names, err := dir.Readdirnames(-1) dir.Close() c.Assert(err, gc.IsNil) c.Assert(names, gc.HasLen, 1) c.Assert(names[0], gc.Equals, expectedFilename) }
func (t *localServerSuite) TestAllocateAddressWithNoFeatureFlag(c *gc.C) { t.SetFeatureFlags() // clear the flags. env := t.prepareEnviron(c) err := env.AllocateAddress("i-foo", "net1", network.NewAddresses("1.2.3.4")[0], "foo", "bar") c.Assert(err, gc.ErrorMatches, "address allocation not supported") c.Assert(err, jc.Satisfies, errors.IsNotSupported) }
func (s *APIAddressUpdaterSuite) TestAddressChange(c *gc.C) { setter := &apiAddressSetter{servers: make(chan [][]network.HostPort, 1)} st, _ := s.OpenAPIAsNewMachine(c, state.JobHostUnits) worker := apiaddressupdater.NewAPIAddressUpdater(st.Machiner(), setter) defer func() { c.Assert(worker.Wait(), gc.IsNil) }() defer worker.Kill() s.BackingState.StartSync() updatedServers := [][]network.HostPort{network.AddressesWithPort( network.NewAddresses("localhost", "127.0.0.1"), 1234, )} // SetAPIHostPorts should be called with the initial value (empty), // and then the updated value. select { case <-time.After(coretesting.LongWait): c.Fatalf("timed out waiting for SetAPIHostPorts to be called first") case servers := <-setter.servers: c.Assert(servers, gc.HasLen, 0) } err := s.State.SetAPIHostPorts(updatedServers) c.Assert(err, gc.IsNil) s.BackingState.StartSync() select { case <-time.After(coretesting.LongWait): c.Fatalf("timed out waiting for SetAPIHostPorts to be called second") case servers := <-setter.servers: c.Assert(servers, gc.DeepEquals, updatedServers) } }
func (s *clientSuite) TestClientAddMachinesWithInstanceIdSomeErrors(c *gc.C) { apiParams := make([]params.AddMachineParams, 3) addrs := network.NewAddresses("1.2.3.4") hc := instance.MustParseHardware("mem=4G") for i := 0; i < 3; i++ { apiParams[i] = params.AddMachineParams{ Jobs: []multiwatcher.MachineJob{multiwatcher.JobHostUnits}, InstanceId: instance.Id(fmt.Sprintf("1234-%d", i)), Nonce: "foo", HardwareCharacteristics: hc, Addrs: params.FromNetworkAddresses(addrs...), } } // This will cause the last add-machine to fail. apiParams[2].Nonce = "" machines, err := s.APIState.Client().AddMachines(apiParams) c.Assert(err, jc.ErrorIsNil) c.Assert(len(machines), gc.Equals, 3) for i, machineResult := range machines { if i == 2 { c.Assert(machineResult.Error, gc.NotNil) c.Assert(machineResult.Error, gc.ErrorMatches, "cannot add a new machine: cannot add a machine with an instance id and no nonce") } else { c.Assert(machineResult.Machine, gc.DeepEquals, strconv.Itoa(i)) s.checkMachine(c, machineResult.Machine, series.LatestLts(), apiParams[i].Constraints.String()) instanceId := fmt.Sprintf("1234-%d", i) s.checkInstance(c, machineResult.Machine, instanceId, "foo", hc, addrs) } } }
func (s *MachineSuite) TestMachineAgentRunsAPIAddressUpdaterWorker(c *gc.C) { // Start the machine agent. m, _, _ := s.primeAgent(c, version.Current, state.JobHostUnits) a := s.newAgent(c, m) go func() { c.Check(a.Run(nil), gc.IsNil) }() defer func() { c.Check(a.Stop(), gc.IsNil) }() // Update the API addresses. updatedServers := [][]network.HostPort{network.AddressesWithPort( network.NewAddresses("localhost"), 1234, )} err := s.BackingState.SetAPIHostPorts(updatedServers) c.Assert(err, gc.IsNil) // Wait for config to be updated. s.BackingState.StartSync() for attempt := coretesting.LongAttempt.Start(); attempt.Next(); { addrs, err := a.CurrentConfig().APIAddresses() c.Assert(err, gc.IsNil) if reflect.DeepEqual(addrs, []string{"localhost:1234"}) { return } } c.Fatalf("timeout while waiting for agent config to change") }
func (s *lxcBrokerSuite) TestLocalDNSServers(c *gc.C) { fakeConf := filepath.Join(c.MkDir(), "resolv.conf") s.PatchValue(provisioner.ResolvConf, fakeConf) // If config is missing, that's OK. dnses, dnsSearch, err := provisioner.LocalDNSServers() c.Assert(err, jc.ErrorIsNil) c.Assert(dnses, gc.HasLen, 0) c.Assert(dnsSearch, gc.Equals, "") // Enter some data in fakeConf. data := ` anything else is ignored # comments are ignored nameserver 0.1.2.3 # that's parsed search foo.baz # comment ignored # nameserver 42.42.42.42 - ignored as well nameserver 8.8.8.8 nameserver example.com # comment after is ok ` err = ioutil.WriteFile(fakeConf, []byte(data), 0644) c.Assert(err, jc.ErrorIsNil) dnses, dnsSearch, err = provisioner.LocalDNSServers() c.Assert(err, jc.ErrorIsNil) c.Assert(dnses, jc.DeepEquals, network.NewAddresses( "0.1.2.3", "8.8.8.8", "example.com", )) c.Assert(dnsSearch, gc.Equals, "foo.baz") }
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 (*HostPortSuite) TestNewHostPorts(c *gc.C) { addrs := []string{"0.1.2.3", "fc00::1", "::1", "example.com"} expected := network.AddressesWithPort( network.NewAddresses(addrs...), 42, ) result := network.NewHostPorts(42, addrs...) c.Assert(result, gc.HasLen, len(addrs)) c.Assert(result, jc.DeepEquals, expected) }
func (i *interruptOnDial) Addresses() ([]network.Address, error) { // kill the tomb the second time Addresses is called if !i.returned { i.returned = true } else { i.interrupted <- os.Interrupt } return network.NewAddresses(i.name), nil }
func (*PortSuite) TestSortHostPorts(c *gc.C) { hps := network.AddressesWithPort( network.NewAddresses( "127.0.0.1", "localhost", "example.com", "::1", "fc00::1", "fe80::2", "172.16.0.1", "8.8.8.8", ), 1234, ) network.SortHostPorts(hps, false) c.Assert(hps, jc.DeepEquals, network.AddressesWithPort( network.NewAddresses( "localhost", "example.com", "127.0.0.1", "172.16.0.1", "8.8.8.8", "::1", "fc00::1", "fe80::2", ), 1234, )) network.SortHostPorts(hps, true) c.Assert(hps, jc.DeepEquals, network.AddressesWithPort( network.NewAddresses( "localhost", "example.com", "::1", "fc00::1", "fe80::2", "127.0.0.1", "172.16.0.1", "8.8.8.8", ), 1234, )) }
func (s *AddressSuite) TestNewAddresses(c *gc.C) { addresses := network.NewAddresses("127.0.0.1", "192.168.1.1", "192.168.178.255") c.Assert(len(addresses), gc.Equals, 3) c.Assert(addresses[0].Value, gc.Equals, "127.0.0.1") c.Assert(addresses[0].Scope, gc.Equals, network.ScopeMachineLocal) c.Assert(addresses[1].Value, gc.Equals, "192.168.1.1") c.Assert(addresses[1].Scope, gc.Equals, network.ScopeCloudLocal) c.Assert(addresses[2].Value, gc.Equals, "192.168.178.255") c.Assert(addresses[2].Scope, gc.Equals, network.ScopeCloudLocal) }