func (net UbuntuNetManager) writeResolvConf(networks boshsettings.Networks) error {
buffer := bytes.NewBuffer([]byte{})
const ubuntuResolvConfTemplate = `# Generated by bosh-agent
{{ range .DNSServers }}nameserver {{ . }}
{{ end }}`
t := template.Must(template.New("resolv-conf").Parse(ubuntuResolvConfTemplate))
// Keep DNS servers in the order specified by the network
dnsNetwork, _ := networks.DefaultNetworkFor("dns")
type dnsConfigArg struct {
DNSServers []string
}
dnsServersArg := dnsConfigArg{dnsNetwork.DNS}
err := t.Execute(buffer, dnsServersArg)
if err != nil {
return bosherr.WrapError(err, "Generating config from template")
}
err = net.fs.WriteFile("/etc/resolvconf/resolv.conf.d/head", buffer.Bytes())
if err != nil {
return bosherr.WrapError(err, "Writing to /etc/resolvconf/resolv.conf.d/head")
}
_, _, _, err = net.cmdRunner.RunCommand("resolvconf", "-u")
if err != nil {
return bosherr.WrapError(err, "Updating resolvconf")
}
return nil
}
func (creator interfaceConfigurationCreator) createMultipleInterfaceConfigurations(networks boshsettings.Networks, interfacesByMAC map[string]string) ([]StaticInterfaceConfiguration, []DHCPInterfaceConfiguration, error) {
if len(interfacesByMAC) < len(networks) {
return nil, nil, bosherr.Errorf("Number of network settings '%d' is greater than the number of network devices '%d'", len(networks), len(interfacesByMAC))
}
for name := range networks {
if mac := networks[name].Mac; mac != "" {
if _, ok := interfacesByMAC[mac]; !ok {
return nil, nil, bosherr.Errorf("No device found for network '%s' with MAC address '%s'", name, mac)
}
}
}
// Configure interfaces with network settings matching MAC address.
// If we cannot find a network setting with a matching MAC address, configure that interface as DHCP
var networkSettings boshsettings.Network
var err error
staticConfigs := []StaticInterfaceConfiguration{}
dhcpConfigs := []DHCPInterfaceConfiguration{}
for mac, ifaceName := range interfacesByMAC {
networkSettings, _ = networks.NetworkForMac(mac)
staticConfigs, dhcpConfigs, err = creator.createInterfaceConfiguration(staticConfigs, dhcpConfigs, ifaceName, networkSettings)
if err != nil {
return nil, nil, bosherr.WrapError(err, "Creating interface configuration")
}
}
return staticConfigs, dhcpConfigs, nil
}
func (net UbuntuNetManager) writeResolvConf(networks boshsettings.Networks) error {
buffer := bytes.NewBuffer([]byte{})
const resolvConfTemplate = `# Generated by bosh-agent
{{ range .DNSServers }}nameserver {{ . }}
{{ end }}`
t := template.Must(template.New("resolv-conf").Parse(resolvConfTemplate))
// Keep DNS servers in the order specified by the network
dnsNetwork, _ := networks.DefaultNetworkFor("dns")
type dnsConfigArg struct {
DNSServers []string
}
dnsServersArg := dnsConfigArg{dnsNetwork.DNS}
err := t.Execute(buffer, dnsServersArg)
if err != nil {
return bosherr.WrapError(err, "Generating DNS config from template")
}
if len(dnsNetwork.DNS) > 0 {
// Write out base so that releases may overwrite head
err = net.fs.WriteFile("/etc/resolvconf/resolv.conf.d/base", buffer.Bytes())
if err != nil {
return bosherr.WrapError(err, "Writing to /etc/resolvconf/resolv.conf.d/base")
}
} else {
// For the first time before resolv.conf is symlinked to /run/...
// inherit possibly configured resolv.conf
targetPath, err := net.fs.ReadLink("/etc/resolv.conf")
if err != nil {
return bosherr.WrapError(err, "Reading /etc/resolv.conf symlink")
}
if targetPath == "/etc/resolv.conf" {
err := net.fs.CopyFile("/etc/resolv.conf", "/etc/resolvconf/resolv.conf.d/base")
if err != nil {
return bosherr.WrapError(err, "Copying /etc/resolv.conf for backwards compat")
}
}
}
err = net.fs.Symlink("/run/resolvconf/resolv.conf", "/etc/resolv.conf")
if err != nil {
return bosherr.WrapError(err, "Setting up /etc/resolv.conf symlink")
}
_, _, _, err = net.cmdRunner.RunCommand("resolvconf", "-u")
if err != nil {
return bosherr.WrapError(err, "Updating resolvconf")
}
return nil
}
func (net ubuntuNetManager) SetupDhcp(networks boshsettings.Networks, errCh chan error) error {
net.logger.Debug(ubuntuNetManagerLogTag, "Configuring DHCP networking")
buffer := bytes.NewBuffer([]byte{})
t := template.Must(template.New("dhcp-config").Parse(ubuntuDHCPConfigTemplate))
// Keep DNS servers in the order specified by the network
// because they are added by a *single* DHCP's prepend command
dnsNetwork, _ := networks.DefaultNetworkFor("dns")
dnsServersList := strings.Join(dnsNetwork.DNS, ", ")
err := t.Execute(buffer, dnsServersList)
if err != nil {
return bosherr.WrapError(err, "Generating config from template")
}
dhclientConfigFile := net.dhclientConfigFile()
written, err := net.fs.ConvergeFileContents(dhclientConfigFile, buffer.Bytes())
if err != nil {
return bosherr.WrapError(err, "Writing to %s", dhclientConfigFile)
}
if written {
args := net.restartNetworkArguments()
net.logger.Debug(ubuntuNetManagerLogTag, "Restarting network interfaces")
_, _, _, err := net.cmdRunner.RunCommand("ifdown", args...)
if err != nil {
net.logger.Error(ubuntuNetManagerLogTag, "Ignoring ifdown failure: %s", err)
}
_, _, _, err = net.cmdRunner.RunCommand("ifup", args...)
if err != nil {
net.logger.Error(ubuntuNetManagerLogTag, "Ignoring ifup failure: %s", err)
}
}
addresses := []boship.InterfaceAddress{
// eth0 is hard coded in AWS and OpenStack stemcells.
// TODO: abstract hardcoded network interface name to the NetManager
boship.NewResolvingInterfaceAddress("eth0", net.ipResolver),
}
go func() {
net.addressBroadcaster.BroadcastMACAddresses(addresses)
if errCh != nil {
errCh <- nil
}
}()
return nil
}
func (net centosNetManager) SetupNetworking(networks boshsettings.Networks, errCh chan error) error {
nonVipNetworks := boshsettings.Networks{}
for networkName, networkSettings := range networks {
if networkSettings.IsVIP() {
continue
}
nonVipNetworks[networkName] = networkSettings
}
staticInterfaceConfigurations, dhcpInterfaceConfigurations, err := net.buildInterfaces(nonVipNetworks)
if err != nil {
return err
}
dnsNetwork, _ := nonVipNetworks.DefaultNetworkFor("dns")
dnsServers := dnsNetwork.DNS
interfacesChanged, err := net.writeNetworkInterfaces(dhcpInterfaceConfigurations, staticInterfaceConfigurations, dnsServers)
if err != nil {
return bosherr.WrapError(err, "Writing network configuration")
}
dhcpChanged := false
if len(dhcpInterfaceConfigurations) > 0 {
dhcpChanged, err = net.writeDHCPConfiguration(dnsServers, dhcpInterfaceConfigurations)
if err != nil {
return err
}
}
if interfacesChanged || dhcpChanged {
net.restartNetworkingInterfaces()
}
staticAddresses, dynamicAddresses := net.ifaceAddresses(staticInterfaceConfigurations, dhcpInterfaceConfigurations)
err = net.interfaceAddressesValidator.Validate(staticAddresses)
if err != nil {
return bosherr.WrapError(err, "Validating static network configuration")
}
err = net.dnsValidator.Validate(dnsServers)
if err != nil {
return bosherr.WrapError(err, "Validating dns configuration")
}
net.broadcastIps(append(staticAddresses, dynamicAddresses...), errCh)
return nil
}
func (net UbuntuNetManager) SetupNetworking(networks boshsettings.Networks, errCh chan error) error {
if networks.IsPreconfigured() {
// Note in this case IPs are not broadcasted
return net.writeResolvConf(networks)
}
staticConfigs, dhcpConfigs, dnsServers, err := net.ComputeNetworkConfig(networks)
if err != nil {
return bosherr.WrapError(err, "Computing network configuration")
}
interfacesChanged, err := net.writeNetworkInterfaces(dhcpConfigs, staticConfigs, dnsServers)
if err != nil {
return bosherr.WrapError(err, "Writing network configuration")
}
dhcpChanged := false
if len(dhcpConfigs) > 0 {
dhcpChanged, err = net.writeDHCPConfiguration(dnsServers)
if err != nil {
return err
}
}
if interfacesChanged || dhcpChanged {
err = net.removeDhcpDNSConfiguration()
if err != nil {
return err
}
net.restartNetworkingInterfaces(net.ifaceNames(dhcpConfigs, staticConfigs))
}
staticAddresses, dynamicAddresses := net.ifaceAddresses(staticConfigs, dhcpConfigs)
err = net.interfaceAddressesValidator.Validate(staticAddresses)
if err != nil {
return bosherr.WrapError(err, "Validating static network configuration")
}
err = net.dnsValidator.Validate(dnsServers)
if err != nil {
return bosherr.WrapError(err, "Validating dns configuration")
}
net.broadcastIps(append(staticAddresses, dynamicAddresses...), errCh)
return nil
}
func (net UbuntuNetManager) ComputeNetworkConfig(networks boshsettings.Networks) ([]StaticInterfaceConfiguration, []DHCPInterfaceConfiguration, []string, error) {
nonVipNetworks := boshsettings.Networks{}
for networkName, networkSettings := range networks {
if networkSettings.IsVIP() {
continue
}
nonVipNetworks[networkName] = networkSettings
}
staticConfigs, dhcpConfigs, err := net.buildInterfaces(nonVipNetworks)
if err != nil {
return nil, nil, nil, err
}
dnsNetwork, _ := nonVipNetworks.DefaultNetworkFor("dns")
dnsServers := dnsNetwork.DNS
return staticConfigs, dhcpConfigs, dnsServers, nil
}
func (net centosNetManager) writeResolvConf(networks boshsettings.Networks) error {
buffer := bytes.NewBuffer([]byte{})
t := template.Must(template.New("resolv-conf").Parse(centosResolvConfTemplate))
// Keep DNS servers in the order specified by the network
dnsNetwork, _ := networks.DefaultNetworkFor("dns")
dnsServersArg := dnsConfigArg{dnsNetwork.DNS}
err := t.Execute(buffer, dnsServersArg)
if err != nil {
return bosherr.WrapError(err, "Generating config from template")
}
err = net.fs.WriteFile("/etc/resolv.conf", buffer.Bytes())
if err != nil {
return bosherr.WrapError(err, "Writing to /etc/resolv.conf")
}
return nil
}
func (net WindowsNetManager) SetupNetworking(networks boshsettings.Networks, errCh chan error) error {
nonVipNetworks := boshsettings.Networks{}
for networkName, networkSettings := range networks {
if networkSettings.IsVIP() {
continue
}
nonVipNetworks[networkName] = networkSettings
}
err := net.setupInterfaces(nonVipNetworks)
if err != nil {
return err
}
dnsNetwork, _ := nonVipNetworks.DefaultNetworkFor("dns")
dns := net.setupDNS(dnsNetwork)
time.Sleep(5 * time.Second)
return dns
}
func (net centosNetManager) SetupDhcp(networks boshsettings.Networks, errCh chan error) error {
net.logger.Debug(centosNetManagerLogTag, "Configuring DHCP networking")
buffer := bytes.NewBuffer([]byte{})
t := template.Must(template.New("dhcp-config").Parse(centosDHCPConfigTemplate))
// Keep DNS servers in the order specified by the network
// because they are added by a *single* DHCP's prepend command
dnsNetwork, _ := networks.DefaultNetworkFor("dns")
dnsServersList := strings.Join(dnsNetwork.DNS, ", ")
err := t.Execute(buffer, dnsServersList)
if err != nil {
return bosherr.WrapError(err, "Generating config from template")
}
written, err := net.fs.ConvergeFileContents("/etc/dhcp/dhclient.conf", buffer.Bytes())
if err != nil {
return bosherr.WrapError(err, "Writing to /etc/dhcp/dhclient.conf")
}
if written {
net.restartNetwork()
}
addresses := []boship.InterfaceAddress{
// eth0 is hard coded in AWS and OpenStack stemcells.
// TODO: abstract hardcoded network interface name to the NetManager
boship.NewResolvingInterfaceAddress("eth0", net.ipResolver),
}
go func() {
net.addressBroadcaster.BroadcastMACAddresses(addresses)
if errCh != nil {
errCh <- nil
}
}()
return err
}
func describeUbuntuNetManager() {
var (
fs *fakesys.FakeFileSystem
cmdRunner *fakesys.FakeCmdRunner
ipResolver *fakeip.FakeResolver
addressBroadcaster *fakearp.FakeAddressBroadcaster
interfaceAddrsProvider *fakeip.FakeInterfaceAddressesProvider
netManager UbuntuNetManager
interfaceConfigurationCreator InterfaceConfigurationCreator
)
writeNetworkDevice := func(iface string, macAddress string, isPhysical bool) string {
interfacePath := fmt.Sprintf("/sys/class/net/%s", iface)
fs.WriteFile(interfacePath, []byte{})
if isPhysical {
fs.WriteFile(fmt.Sprintf("/sys/class/net/%s/device", iface), []byte{})
}
fs.WriteFileString(fmt.Sprintf("/sys/class/net/%s/address", iface), fmt.Sprintf("%s\n", macAddress))
return interfacePath
}
stubInterfacesWithVirtual := func(physicalInterfaces map[string]boshsettings.Network, virtualInterfaces []string) {
interfacePaths := []string{}
for iface, networkSettings := range physicalInterfaces {
interfacePaths = append(interfacePaths, writeNetworkDevice(iface, networkSettings.Mac, true))
}
for _, iface := range virtualInterfaces {
interfacePaths = append(interfacePaths, writeNetworkDevice(iface, "virtual", false))
}
fs.SetGlob("/sys/class/net/*", interfacePaths)
}
stubInterfaces := func(physicalInterfaces map[string]boshsettings.Network) {
stubInterfacesWithVirtual(physicalInterfaces, nil)
}
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cmdRunner = fakesys.NewFakeCmdRunner()
ipResolver = &fakeip.FakeResolver{}
logger := boshlog.NewLogger(boshlog.LevelNone)
interfaceConfigurationCreator = NewInterfaceConfigurationCreator(logger)
addressBroadcaster = &fakearp.FakeAddressBroadcaster{}
interfaceAddrsProvider = &fakeip.FakeInterfaceAddressesProvider{}
interfaceAddrsValidator := boship.NewInterfaceAddressesValidator(interfaceAddrsProvider)
dnsValidator := NewDNSValidator(fs)
netManager = NewUbuntuNetManager(
fs,
cmdRunner,
ipResolver,
interfaceConfigurationCreator,
interfaceAddrsValidator,
dnsValidator,
addressBroadcaster,
logger,
).(UbuntuNetManager)
})
Describe("ComputeNetworkConfig", func() {
Context("when there is one manual network and neither is marked as default for DNS", func() {
It("should use the manual network for DNS", func() {
networks := boshsettings.Networks{
"manual": factory.Network{DNS: &[]string{"8.8.8.8"}}.Build(),
}
stubInterfaces(networks)
_, _, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(dnsServers).To(Equal([]string{"8.8.8.8"}))
})
})
Context("when there is a vip network and a manual network and neither is marked as default for DNS", func() {
It("should use the manual network for DNS", func() {
networks := boshsettings.Networks{
"vip": boshsettings.Network{Type: "vip"},
"manual": factory.Network{Type: "manual", DNS: &[]string{"8.8.8.8"}}.Build(),
}
stubInterfaces(networks)
_, _, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(dnsServers).To(Equal([]string{"8.8.8.8"}))
})
})
Context("when there is a vip network and a manual network and the manual network is marked as default for DNS", func() {
It("should use the manual network for DNS", func() {
networks := boshsettings.Networks{
"vip": boshsettings.Network{Type: "vip"},
"manual": factory.Network{Type: "manual", DNS: &[]string{"8.8.8.8"}, Default: []string{"dns"}}.Build(),
}
stubInterfaces(networks)
_, _, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(dnsServers).To(Equal([]string{"8.8.8.8"}))
})
})
Context("when specified more than one DNS", func() {
It("extracts all DNS servers from the network configured as default DNS", func() {
networks := boshsettings.Networks{
"default": factory.Network{
IP: "10.10.0.32",
Netmask: "255.255.255.0",
Mac: "aa::bb::cc",
Default: []string{"dns", "gateway"},
DNS: &[]string{"54.209.78.6", "127.0.0.5"},
Gateway: "10.10.0.1",
}.Build(),
}
stubInterfaces(networks)
staticInterfaceConfigurations, dhcpInterfaceConfigurations, dnsServers, err := netManager.ComputeNetworkConfig(networks)
Expect(err).ToNot(HaveOccurred())
Expect(staticInterfaceConfigurations).To(Equal([]StaticInterfaceConfiguration{
{
Name: "default",
Address: "10.10.0.32",
Netmask: "255.255.255.0",
Network: "10.10.0.0",
IsDefaultForGateway: true,
Broadcast: "10.10.0.255",
Mac: "aa::bb::cc",
Gateway: "10.10.0.1",
},
}))
Expect(dhcpInterfaceConfigurations).To(BeEmpty())
Expect(dnsServers).To(Equal([]string{"54.209.78.6", "127.0.0.5"}))
})
})
})
Describe("SetupNetworking", func() {
var (
dhcpNetwork boshsettings.Network
staticNetwork boshsettings.Network
expectedNetworkConfigurationForStaticAndDhcp string
expectedResolvConfHead string
)
BeforeEach(func() {
dhcpNetwork = boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-dhcp-mac-address",
}
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
}
fs.WriteFileString("/etc/resolv.conf", `
nameserver 8.8.8.8
nameserver 9.9.9.9
`)
expectedNetworkConfigurationForStaticAndDhcp = `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethdhcp
iface ethdhcp inet dhcp
auto ethstatic
iface ethstatic inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
broadcast 1.2.3.255
gateway 3.4.5.6
dns-nameservers 8.8.8.8 9.9.9.9`
})
Context("networks is preconfigured", func() {
var networks boshsettings.Networks
BeforeEach(func() {
dhcpNetwork.Preconfigured = true
staticNetwork.Preconfigured = true
networks = boshsettings.Networks{
"first": dhcpNetwork,
"second": staticNetwork,
}
Expect(networks.IsPreconfigured()).To(BeTrue())
})
Context("when there are configured DNS servers", func() {
BeforeEach(func() {
networks = boshsettings.Networks{
"first": dhcpNetwork,
}
})
It("writes DNS to /etc/resolvconf/resolv.conf.d/base", func() {
err := netManager.SetupNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
resolvConfBase := fs.GetFileTestStat("/etc/resolvconf/resolv.conf.d/base")
Expect(resolvConfBase).ToNot(BeNil())
expectedResolvConfBase := `# Generated by bosh-agent
nameserver 8.8.8.8
nameserver 9.9.9.9
`
Expect(resolvConfBase.StringContents()).To(Equal(expectedResolvConfBase))
})
Context("when writing to ../resolv.conf.d/base fails", func() {
It("fails reporting the error", func() {
fs.WriteFileError = errors.New("fake-write-file-error")
err := netManager.SetupNetworking(networks, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Writing to /etc/resolvconf/resolv.conf.d/base"))
})
})
})
Context("when no DNS servers are configured", func() {
BeforeEach(func() {
dhcpNetwork.DNS = []string{}
networks = boshsettings.Networks{
"first": dhcpNetwork,
"second": staticNetwork,
}
})
Context("when could not read link /etc/resolv.conf", func() {
It("fails reporting error", func() {
fs.ReadLinkError = errors.New("fake-read-link-error")
err := netManager.SetupNetworking(networks, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Reading /etc/resolv.conf symlink"))
})
})
Context("when /etc/resolv.conf is no symlink", func() {
BeforeEach(func() {
err := fs.Symlink("/etc/resolv.conf", "/etc/resolv.conf")
Expect(err).ToNot(HaveOccurred())
err = fs.WriteFileString("/etc/resolv.conf", "fake-content")
Expect(err).ToNot(HaveOccurred())
})
It("copies /etc/resolv.conf to .../resolv.conf.d/base", func() {
err := netManager.SetupNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
contents, err := fs.ReadFile("/etc/resolvconf/resolv.conf.d/base")
Expect(err).ToNot(HaveOccurred())
Expect(string(contents)).To(Equal("fake-content"))
})
Context("when copying fails", func() {
It("fails reporting the error", func() {
fs.CopyFileError = errors.New("fake-copy-error")
err := netManager.SetupNetworking(networks, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Copying /etc/resolv.conf for backwards compat"))
})
})
})
})
It("forces /etc/resolv.conf to be a symlink", func() {
err := netManager.SetupNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
Expect(fs.ReadLink("/etc/resolv.conf")).To(Equal("/run/resolvconf/resolv.conf"))
})
Context("when symlink command fails", func() {
BeforeEach(func() {
fs.SymlinkError = errors.New("fake-symlink-error")
})
It("fails reporting error", func() {
err := netManager.SetupNetworking(networks, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Setting up /etc/resolv.conf symlink"))
})
})
It("writes dns servers in /etc/resolvconf/resolv.conf.d/base", func() {
dhcpNetwork.Preconfigured = true
staticNetwork.Preconfigured = true
networks := boshsettings.Networks{
"first": dhcpNetwork,
"second": staticNetwork,
}
Expect(networks.IsPreconfigured()).To(BeTrue())
err := netManager.SetupNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
resolvConfHead := fs.GetFileTestStat("/etc/resolvconf/resolv.conf.d/base")
Expect(resolvConfHead).ToNot(BeNil())
expectedResolvConfHead = `# Generated by bosh-agent
nameserver 8.8.8.8
nameserver 9.9.9.9
`
Expect(resolvConfHead.StringContents()).To(Equal(expectedResolvConfHead))
})
It("run resolvconf -u to update resolv.conf", func() {
dhcpNetwork.Preconfigured = true
staticNetwork.Preconfigured = true
networks := boshsettings.Networks{
"first": dhcpNetwork,
"second": staticNetwork,
}
err := netManager.SetupNetworking(networks, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(1))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"resolvconf", "-u"}))
})
})
It("writes interfaces in /etc/network/interfaces in alphabetic order", func() {
anotherDHCPNetwork := boshsettings.Network{
Type: "dynamic",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-another-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
"ethdhcp1": dhcpNetwork,
"ethdhcp0": anotherDHCPNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{
"dhcp-network-1": dhcpNetwork,
"dhcp-network-2": anotherDHCPNetwork,
"static-network": staticNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
expectedNetworkConfigurationForStaticAndDhcp = `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethdhcp0
iface ethdhcp0 inet dhcp
auto ethdhcp1
iface ethdhcp1 inet dhcp
auto ethstatic
iface ethstatic inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
broadcast 1.2.3.255
gateway 3.4.5.6
dns-nameservers 8.8.8.8 9.9.9.9`
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
})
It("configures gateway, broadcast and dns for default network only", func() {
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
secondStaticNetwork := boshsettings.Network{
Type: "manual",
IP: "5.6.7.8",
Netmask: "255.255.255.0",
Gateway: "6.7.8.9",
Mac: "second-fake-static-mac-address",
DNS: []string{"8.8.8.8"},
Default: []string{"gateway", "dns"},
}
stubInterfaces(map[string]boshsettings.Network{
"eth0": staticNetwork,
"eth1": secondStaticNetwork,
})
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("eth0", "1.2.3.4"),
boship.NewSimpleInterfaceAddress("eth1", "5.6.7.8"),
}
err := netManager.SetupNetworking(boshsettings.Networks{
"static-1": staticNetwork,
"static-2": secondStaticNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(`# Generated by bosh-agent
auto lo
iface lo inet loopback
auto eth0
iface eth0 inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
auto eth1
iface eth1 inet static
address 5.6.7.8
network 5.6.7.0
netmask 255.255.255.0
broadcast 5.6.7.255
gateway 6.7.8.9
dns-nameservers 8.8.8.8`))
})
It("writes /etc/network/interfaces without dns-namservers if there are no dns servers", func() {
staticNetworkWithoutDNS := boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetworkWithoutDNS,
})
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetworkWithoutDNS}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(`# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethstatic
iface ethstatic inet static
address 1.2.3.4
network 1.2.3.0
netmask 255.255.255.0
broadcast 1.2.3.255
gateway 3.4.5.6
`))
})
It("returns errors from glob /sys/class/net/", func() {
fs.GlobErr = errors.New("fs-glob-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-glob-error"))
})
It("returns errors from writing the network configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"dhcp": dhcpNetwork,
"static": staticNetwork,
})
fs.WriteFileError = errors.New("fs-write-file-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-write-file-error"))
})
It("returns errors when it can't creating network interface configurations", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
staticNetwork.Netmask = "not an ip" //will cause InterfaceConfigurationCreator to fail
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Creating interface configurations"))
})
It("writes a dhcp configuration if there are dhcp networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(`# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers 8.8.8.8, 9.9.9.9;
`))
})
It("writes a dhcp configuration without prepended dns servers if there are no dns servers specified", func() {
dhcpNetworkWithoutDNS := boshsettings.Network{
Type: "dynamic",
Mac: "fake-dhcp-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetworkWithoutDNS}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).ToNot(BeNil())
Expect(dhcpConfig.StringContents()).To(Equal(`# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
`))
})
It("returns an error if it can't write a dhcp configuration", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileErrors["/etc/dhcp/dhclient.conf"] = errors.New("dhclient.conf-write-error")
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("dhclient.conf-write-error"))
})
It("doesn't write a dhcp configuration if there are no dhcp networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig).To(BeNil())
})
It("restarts the networks if /etc/network/interfaces changes", func() {
initialDhcpConfig := `# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers 8.8.8.8, 9.9.9.9;
`
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/dhcp/dhclient.conf", initialDhcpConfig)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
Expect(len(cmdRunner.RunCommands)).To(Equal(5))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"pkill", "dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethdhcp.dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethstatic.dhclient"}))
Expect(cmdRunner.RunCommands[3]).To(Equal([]string{"ifdown", "--force", "ethdhcp", "ethstatic"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"ifup", "--force", "ethdhcp", "ethstatic"}))
})
It("doesn't restart the networks if /etc/network/interfaces and /etc/dhcp/dhclient.conf don't change", func() {
initialDhcpConfig := `# Generated by bosh-agent
option rfc3442-classless-static-routes code 121 = array of unsigned integer 8;
send host-name "<hostname>";
request subnet-mask, broadcast-address, time-offset, routers,
domain-name, domain-name-servers, domain-search, host-name,
netbios-name-servers, netbios-scope, interface-mtu,
rfc3442-classless-static-routes, ntp-servers;
prepend domain-name-servers 8.8.8.8, 9.9.9.9;
`
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/network/interfaces", expectedNetworkConfigurationForStaticAndDhcp)
fs.WriteFileString("/etc/dhcp/dhclient.conf", initialDhcpConfig)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf")
Expect(dhcpConfig.StringContents()).To(Equal(initialDhcpConfig))
Expect(len(cmdRunner.RunCommands)).To(Equal(0))
})
It("restarts the networks if /etc/dhcp/dhclient.conf changes", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
fs.WriteFileString("/etc/network/interfaces", expectedNetworkConfigurationForStaticAndDhcp)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
Expect(len(cmdRunner.RunCommands)).To(Equal(5))
Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"pkill", "dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethdhcp.dhclient"}))
Expect(cmdRunner.RunCommands[1:3]).To(ContainElement([]string{"resolvconf", "-d", "ethstatic.dhclient"}))
Expect(cmdRunner.RunCommands[3]).To(Equal([]string{"ifdown", "--force", "ethdhcp", "ethstatic"}))
Expect(cmdRunner.RunCommands[4]).To(Equal([]string{"ifup", "--force", "ethdhcp", "ethstatic"}))
})
It("broadcasts MAC addresses for all interfaces", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, errCh)
Expect(err).ToNot(HaveOccurred())
broadcastErr := <-errCh // wait for all arpings
Expect(broadcastErr).ToNot(HaveOccurred())
Expect(addressBroadcaster.BroadcastMACAddressesAddresses).To(Equal([]boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"),
boship.NewResolvingInterfaceAddress("ethdhcp", ipResolver),
}))
})
It("skips vip networks", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethdhcp": dhcpNetwork,
"ethstatic": staticNetwork,
})
vipNetwork := boshsettings.Network{
Type: "vip",
Default: []string{"dns"},
DNS: []string{"8.8.8.8", "9.9.9.9"},
Mac: "fake-vip-mac-address",
IP: "9.8.7.6",
}
err := netManager.SetupNetworking(boshsettings.Networks{
"dhcp-network": dhcpNetwork,
"static-network": staticNetwork,
"vip-network": vipNetwork,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStaticAndDhcp))
})
Context("when manual networks were not configured with proper IP addresses", func() {
BeforeEach(func() {
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.5"),
}
})
It("fails", func() {
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, errCh)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Validating static network configuration"))
})
})
Context("when dns is not properly configured", func() {
BeforeEach(func() {
fs.WriteFileString("/etc/resolv.conf", "")
})
It("fails", func() {
staticNetwork = boshsettings.Network{
Type: "manual",
IP: "1.2.3.4",
Default: []string{"dns"},
DNS: []string{"8.8.8.8"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
Mac: "fake-static-mac-address",
}
stubInterfaces(map[string]boshsettings.Network{
"ethstatic": staticNetwork,
})
errCh := make(chan error)
err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, errCh)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Validating dns configuration"))
})
})
Context("when no MAC address is provided in the settings", func() {
It("configures network for single device", func() {
staticNetworkWithoutMAC := boshsettings.Network{
Type: "manual",
IP: "2.2.2.2",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
stubInterfaces(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
)
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "2.2.2.2"),
}
err := netManager.SetupNetworking(boshsettings.Networks{
"static-network": staticNetworkWithoutMAC,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
expectedNetworkConfiguration := `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethstatic
iface ethstatic inet static
address 2.2.2.2
network 2.2.2.0
netmask 255.255.255.0
broadcast 2.2.2.255
gateway 3.4.5.6
`
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfiguration))
})
It("configures network for a single physical device, when a virtual device is also present", func() {
staticNetworkWithoutMAC := boshsettings.Network{
Type: "manual",
IP: "2.2.2.2",
Default: []string{"gateway"},
Netmask: "255.255.255.0",
Gateway: "3.4.5.6",
}
stubInterfacesWithVirtual(
map[string]boshsettings.Network{
"ethstatic": staticNetwork,
},
[]string{"virtual"},
)
interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{
boship.NewSimpleInterfaceAddress("ethstatic", "2.2.2.2"),
}
err := netManager.SetupNetworking(boshsettings.Networks{
"static-network": staticNetworkWithoutMAC,
}, nil)
Expect(err).ToNot(HaveOccurred())
networkConfig := fs.GetFileTestStat("/etc/network/interfaces")
Expect(networkConfig).ToNot(BeNil())
expectedNetworkConfiguration := `# Generated by bosh-agent
auto lo
iface lo inet loopback
auto ethstatic
iface ethstatic inet static
address 2.2.2.2
network 2.2.2.0
netmask 255.255.255.0
broadcast 2.2.2.255
gateway 3.4.5.6
`
Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfiguration))
})
})
})
Describe("GetConfiguredNetworkInterfaces", func() {
Context("when there are network devices", func() {
BeforeEach(func() {
interfacePaths := []string{}
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth0", "aa:bb", true))
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth1", "cc:dd", true))
interfacePaths = append(interfacePaths, writeNetworkDevice("fake-eth2", "ee:ff", true))
fs.SetGlob("/sys/class/net/*", interfacePaths)
})
It("returns networks that are defined in /etc/network/interfaces", func() {
cmdRunner.AddCmdResult("ifup --no-act fake-eth0", fakesys.FakeCmdResult{
Stdout: "",
Stderr: "ifup: interface fake-eth0 already configured",
ExitStatus: 0,
})
cmdRunner.AddCmdResult("ifup --no-act fake-eth1", fakesys.FakeCmdResult{
Stdout: "",
Stderr: "Ignoring unknown interface fake-eth1=fake-eth1.",
ExitStatus: 0,
})
cmdRunner.AddCmdResult("ifup --no-act fake-eth2", fakesys.FakeCmdResult{
Stdout: "",
Stderr: "ifup: interface fake-eth2 already configured",
ExitStatus: 0,
})
interfaces, err := netManager.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(ConsistOf("fake-eth0", "fake-eth2"))
})
})
Context("when there are no network devices", func() {
It("returns empty list", func() {
interfaces, err := netManager.GetConfiguredNetworkInterfaces()
Expect(err).ToNot(HaveOccurred())
Expect(interfaces).To(Equal([]string{}))
})
})
})
}