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