diff --git a/platform/cert/cert_manager.go b/platform/cert/cert_manager.go index 064b3820d..2469d247c 100644 --- a/platform/cert/cert_manager.go +++ b/platform/cert/cert_manager.go @@ -59,18 +59,6 @@ func NewUbuntuCertManager(fs boshsys.FileSystem, runner boshsys.CmdRunner, timeo } } -func NewCentOSCertManager(fs boshsys.FileSystem, runner boshsys.CmdRunner, timeout time.Duration, logger logger.Logger) Manager { - return &certManager{ - fs: fs, - runner: runner, - path: "/etc/pki/ca-trust/source/anchors/", - updateCmdPath: "/usr/bin/update-ca-trust", - logger: logger, - logTag: "CentOSCertManager", - updateTimeout: timeout, - } -} - func NewDummyCertManager(fs boshsys.FileSystem, runner boshsys.CmdRunner, timeout time.Duration, logger logger.Logger) Manager { return &certManager{ fs: fs, diff --git a/platform/cert/cert_manager_test.go b/platform/cert/cert_manager_test.go index 67a78b33d..fffd1a287 100644 --- a/platform/cert/cert_manager_test.go +++ b/platform/cert/cert_manager_test.go @@ -339,36 +339,6 @@ var _ = Describe("Certificate Management", func() { }) }) - Context("CentOS", func() { - BeforeEach(func() { - fakeFs = fakesys.NewFakeFileSystem() - fakeCmdRunner = fakesys.NewFakeCmdRunner() - fakeCmdRunner.AddCmdResult("/usr/bin/update-ca-trust", fakesys.FakeCmdResult{ - Stdout: "", - Stderr: "", - ExitStatus: 0, - Sticky: true, - }) - certManager = cert.NewCentOSCertManager(fakeFs, fakeCmdRunner, 0, log) - }) - - SharedLinuxCertManagerExamples("/etc/pki/ca-trust/source/anchors", "/usr/bin/update-ca-trust") - - It("executes update cert command", func() { - fakeCmdRunner = fakesys.NewFakeCmdRunner() - fakeCmdRunner.AddCmdResult("/usr/bin/update-ca-trust", fakesys.FakeCmdResult{ - Stdout: "", - Stderr: "", - ExitStatus: 2, - Error: errors.New("command failed"), - }) - certManager = cert.NewCentOSCertManager(fakeFs, fakeCmdRunner, 0, log) - - err := certManager.UpdateCertificates(cert1) - Expect(err).To(HaveOccurred()) - }) - }) - Context("Windows", func() { const validCerts string = `-----BEGIN CERTIFICATE----- MIIC0jCCAboCCQCuQJScK+G0WzANBgkqhkiG9w0BAQsFADArMQswCQYDVQQGEwJV diff --git a/platform/net/centos_net_manager.go b/platform/net/centos_net_manager.go deleted file mode 100644 index fdc2f6efd..000000000 --- a/platform/net/centos_net_manager.go +++ /dev/null @@ -1,344 +0,0 @@ -package net - -import ( - "bytes" - "path" - "regexp" - "strings" - "text/template" - "time" - - bosherr "github.com/cloudfoundry/bosh-utils/errors" - boshlog "github.com/cloudfoundry/bosh-utils/logger" - boshretry "github.com/cloudfoundry/bosh-utils/retrystrategy" - boshsys "github.com/cloudfoundry/bosh-utils/system" - - bosharp "github.com/cloudfoundry/bosh-agent/v2/platform/net/arp" - boshdnsresolver "github.com/cloudfoundry/bosh-agent/v2/platform/net/dnsresolver" - boship "github.com/cloudfoundry/bosh-agent/v2/platform/net/ip" - boshsettings "github.com/cloudfoundry/bosh-agent/v2/settings" -) - -const centosNetManagerLogTag = "centosNetManager" - -type centosNetManager struct { - fs boshsys.FileSystem - cmdRunner boshsys.CmdRunner - routesSearcher RoutesSearcher //nolint:unused - ipResolver boship.Resolver - macAddressDetector MACAddressDetector - interfaceConfigurationCreator InterfaceConfigurationCreator - interfaceAddrsProvider boship.InterfaceAddressesProvider - dnsResolver boshdnsresolver.DNSResolver - addressBroadcaster bosharp.AddressBroadcaster - logger boshlog.Logger -} - -func NewCentosNetManager( - fs boshsys.FileSystem, - cmdRunner boshsys.CmdRunner, - ipResolver boship.Resolver, - macAddressDetector MACAddressDetector, - interfaceConfigurationCreator InterfaceConfigurationCreator, - interfaceAddrsProvider boship.InterfaceAddressesProvider, - dnsResolver boshdnsresolver.DNSResolver, - addressBroadcaster bosharp.AddressBroadcaster, - logger boshlog.Logger, -) Manager { - return centosNetManager{ - fs: fs, - cmdRunner: cmdRunner, - ipResolver: ipResolver, - macAddressDetector: macAddressDetector, - interfaceConfigurationCreator: interfaceConfigurationCreator, - interfaceAddrsProvider: interfaceAddrsProvider, - dnsResolver: dnsResolver, - addressBroadcaster: addressBroadcaster, - logger: logger, - } -} - -func (net centosNetManager) GetConfiguredNetworkInterfaces() ([]string, error) { - interfaces := []string{} - - interfacesByMacAddress, err := net.macAddressDetector.DetectMacAddresses() - if err != nil { - return interfaces, bosherr.WrapError(err, "Getting network interfaces") - } - - for _, iface := range interfacesByMacAddress { - if net.fs.FileExists(interfaceConfigurationFileCentos(iface)) { - interfaces = append(interfaces, iface) - } - } - - return interfaces, nil -} - -func (net centosNetManager) SetupIPv6(_ boshsettings.IPv6, _ <-chan struct{}) error { return nil } - -func (net centosNetManager) SetupNetworking(networks boshsettings.Networks, mbus []string, errCh chan error) error { - // NOTE: Do not overwrite `/etc/resolv.conf` here, as it is controlled by Network Manager - // This is an intentional asymmetry vs `ubuntu_net_manager.go`. - // See commit 63548d43c69180b761d96b8e42a699e0762779e2. - // See https://ma.ttias.be/centos-7-networkmanager-keeps-overwriting-etcresolv-conf/ - // See https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8/html/configuring_and_managing_networking/manually-configuring-the-etc-resolv-conf-file_configuring-and-managing-networking - // See https://wiseindy.com/blog/linux/how-to-set-dns-in-centos-rhel-7-prevent-network-manager-from-overwriting-etc-resolv-conf/ - - 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 err - } - - dnsNetwork, _ := nonVipNetworks.DefaultNetworkFor("dns") - dnsServers := dnsNetwork.DNS - - 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, dhcpConfigs) - if err != nil { - return err - } - } - - if interfacesChanged || dhcpChanged { - net.restartNetworkingInterfaces() - } - - staticAddresses, dynamicAddresses := net.ifaceAddresses(staticConfigs, dhcpConfigs) - - var staticAddressesWithoutVirtual []boship.InterfaceAddress - r, err := regexp.Compile(`:\d+`) - if err != nil { - return bosherr.WrapError(err, "There is a problem with your regexp: ':\\d+'. That is used to skip validation of virtual interfaces(e.g., eth0:0, eth0:1)") - } - for _, addr := range staticAddresses { - if r.MatchString(addr.GetInterfaceName()) { - continue - } else { - staticAddressesWithoutVirtual = append(staticAddressesWithoutVirtual, addr) - } - } - - interfaceAddressesValidator := boship.NewInterfaceAddressesValidator(net.interfaceAddrsProvider, staticAddressesWithoutVirtual) - retryIPValidator := boshretry.NewAttemptRetryStrategy( - 10, - time.Second, - interfaceAddressesValidator, - net.logger, - ) - err = retryIPValidator.Try() - if err != nil { - return bosherr.WrapError(err, "Validating static network configuration") - } - - // NOTE: Do not overwrite `/etc/resolv.conf` here, as it is controlled by Network Manager - // This is an intentional asymmetry vs `ubuntu_net_manager.go`. - // See the comments at the top of this function for details. - - err = net.dnsResolver.Validate(dnsServers) - if err != nil { - return bosherr.WrapError(err, "Validating dns configuration") - } - - go net.addressBroadcaster.BroadcastMACAddresses(append(staticAddressesWithoutVirtual, dynamicAddresses...)) - err = net.setupFirewall(mbus) - if err != nil { - return bosherr.WrapError(err, "Setting up Nats Firewall") - } - return nil -} - -func (net centosNetManager) setupFirewall(mbus []string) error { - if len(mbus) == 0 { - net.logger.Info("NetworkSetup", "Skipping adding Firewall for outgoing nats. Mbus url is empty") - return nil - } - net.logger.Info("NetworkSetup", "Adding Firewall not implemented on") - return nil -} - -const centosDHCPIfcfgTemplate = `DEVICE={{ .Name }} -BOOTPROTO=dhcp -ONBOOT=yes -PEERDNS=yes -` - -const centosStaticIfcfgTemplate = `DEVICE={{ .Name }} -BOOTPROTO=static -IPADDR={{ .Address }} -NETMASK={{ .Netmask }} -BROADCAST={{ .Broadcast }}{{if .IsDefaultForGateway}} -GATEWAY={{ .Gateway }}{{end}} -ONBOOT=yes -PEERDNS=no{{ range .DNSServers }} -DNS{{ .Index }}={{ .Address }}{{ end }} -` - -type centosStaticIfcfg struct { - *StaticInterfaceConfiguration - DNSServers []dnsConfig -} - -type dnsConfig struct { - Index int - Address string -} - -func newDNSConfigs(dnsServers []string) []dnsConfig { - dnsConfigs := []dnsConfig{} - for i := range dnsServers { - dnsConfigs = append(dnsConfigs, dnsConfig{Index: i + 1, Address: dnsServers[i]}) - } - return dnsConfigs -} - -func interfaceConfigurationFileCentos(name string) string { - return path.Join("/etc/sysconfig/network-scripts", "ifcfg-"+name) -} - -func (net centosNetManager) writeIfcfgFile(name string, t *template.Template, config interface{}) (bool, error) { - buffer := bytes.NewBuffer([]byte{}) - - err := t.Execute(buffer, config) - if err != nil { - return false, bosherr.WrapErrorf(err, "Generating '%s' config from template", name) - } - - filePath := interfaceConfigurationFileCentos(name) - changed, err := net.fs.ConvergeFileContents(filePath, buffer.Bytes()) - if err != nil { - return false, bosherr.WrapErrorf(err, "Writing config to '%s'", filePath) - } - - return changed, nil -} - -func (net centosNetManager) writeNetworkInterfaces(dhcpConfigs []DHCPInterfaceConfiguration, staticConfigs []StaticInterfaceConfiguration, dnsServers []string) (bool, error) { - anyInterfaceChanged := false - - staticConfig := centosStaticIfcfg{} - staticConfig.DNSServers = newDNSConfigs(dnsServers) - staticTemplate := template.Must(template.New("ifcfg").Parse(centosStaticIfcfgTemplate)) - - for i := range staticConfigs { - staticConfig.StaticInterfaceConfiguration = &staticConfigs[i] - - changed, err := net.writeIfcfgFile(staticConfig.StaticInterfaceConfiguration.Name, staticTemplate, staticConfig) //nolint:staticcheck - if err != nil { - return false, bosherr.WrapError(err, "Writing static config") - } - - anyInterfaceChanged = anyInterfaceChanged || changed - } - - dhcpTemplate := template.Must(template.New("ifcfg").Parse(centosDHCPIfcfgTemplate)) - - for i := range dhcpConfigs { - config := &dhcpConfigs[i] - - changed, err := net.writeIfcfgFile(config.Name, dhcpTemplate, config) - if err != nil { - return false, bosherr.WrapError(err, "Writing dhcp config") - } - - anyInterfaceChanged = anyInterfaceChanged || changed - } - - return anyInterfaceChanged, nil -} - -func (net centosNetManager) buildInterfaces(networks boshsettings.Networks) ([]StaticInterfaceConfiguration, []DHCPInterfaceConfiguration, error) { - interfacesByMacAddress, err := net.macAddressDetector.DetectMacAddresses() - if err != nil { - return nil, nil, bosherr.WrapError(err, "Getting network interfaces") - } - - staticConfigs, dhcpConfigs, err := net.interfaceConfigurationCreator.CreateInterfaceConfigurations(networks, interfacesByMacAddress) - - if err != nil { - return nil, nil, bosherr.WrapError(err, "Creating interface configurations") - } - - return staticConfigs, dhcpConfigs, nil -} - -func (net centosNetManager) restartNetworkingInterfaces() { - net.logger.Debug(centosNetManagerLogTag, "Restarting network interfaces") - - _, _, _, err := net.cmdRunner.RunCommand("service", "network", "restart") - if err != nil { - net.logger.Error(centosNetManagerLogTag, "Ignoring network restart failure: %s", err.Error()) - } -} - -// DHCP Config file - /etc/dhcp3/dhclient.conf -const centosDHCPConfigTemplate = `# Generated by bosh-agent - -option rfc3442-classless-static-routes code 121 = array of unsigned integer 8; - -send host-name ""; - -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; -{{ if . }} -prepend domain-name-servers {{ . }};{{ end }} -` - -func (net centosNetManager) writeDHCPConfiguration(dnsServers []string, dhcpConfigs []DHCPInterfaceConfiguration) (bool, error) { - 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 - dnsServersList := strings.Join(dnsServers, ", ") - err := t.Execute(buffer, dnsServersList) - if err != nil { - return false, bosherr.WrapError(err, "Generating config from template") - } - dhclientConfigFile := "/etc/dhcp/dhclient.conf" - changed, err := net.fs.ConvergeFileContents(dhclientConfigFile, buffer.Bytes()) - - if err != nil { - return changed, bosherr.WrapErrorf(err, "Writing to %s", dhclientConfigFile) - } - - for i := range dhcpConfigs { - name := dhcpConfigs[i].Name - interfaceDhclientConfigFile := path.Join("/etc/dhcp/", "dhclient-"+name+".conf") - err = net.fs.Symlink(dhclientConfigFile, interfaceDhclientConfigFile) - if err != nil { - return changed, bosherr.WrapErrorf(err, "Symlinking '%s' to '%s'", interfaceDhclientConfigFile, dhclientConfigFile) - } - } - - return changed, nil -} - -func (net centosNetManager) ifaceAddresses(staticConfigs []StaticInterfaceConfiguration, dhcpConfigs []DHCPInterfaceConfiguration) ([]boship.InterfaceAddress, []boship.InterfaceAddress) { - staticAddresses := []boship.InterfaceAddress{} - for _, iface := range staticConfigs { - staticAddresses = append(staticAddresses, boship.NewSimpleInterfaceAddress(iface.Name, iface.Address)) - } - dynamicAddresses := []boship.InterfaceAddress{} - for _, iface := range dhcpConfigs { - dynamicAddresses = append(dynamicAddresses, boship.NewResolvingInterfaceAddress(iface.Name, net.ipResolver)) - } - - return staticAddresses, dynamicAddresses -} diff --git a/platform/net/centos_net_manager_test.go b/platform/net/centos_net_manager_test.go deleted file mode 100644 index 44ce71d1a..000000000 --- a/platform/net/centos_net_manager_test.go +++ /dev/null @@ -1,732 +0,0 @@ -//go:build !windows - -package net_test - -import ( - "errors" - "fmt" - "sort" - "strings" - - "github.com/onsi/gomega/format" - - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" - - boshlog "github.com/cloudfoundry/bosh-utils/logger" - fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" - - . "github.com/cloudfoundry/bosh-agent/v2/platform/net" - fakearp "github.com/cloudfoundry/bosh-agent/v2/platform/net/arp/fakes" - fakednsresolver "github.com/cloudfoundry/bosh-agent/v2/platform/net/dnsresolver/fakes" - boship "github.com/cloudfoundry/bosh-agent/v2/platform/net/ip" - fakeip "github.com/cloudfoundry/bosh-agent/v2/platform/net/ip/fakes" - "github.com/cloudfoundry/bosh-agent/v2/platform/net/netfakes" - boshsettings "github.com/cloudfoundry/bosh-agent/v2/settings" -) - -var _ = Describe("centosNetManager", describeCentosNetManager) - -func describeCentosNetManager() { - var ( - fs *fakesys.FakeFileSystem - cmdRunner *fakesys.FakeCmdRunner - ipResolver *fakeip.FakeResolver - interfaceAddrsProvider *fakeip.FakeInterfaceAddressesProvider - addressBroadcaster *fakearp.FakeAddressBroadcaster - netManager Manager - interfaceConfigurationCreator InterfaceConfigurationCreator - fakeMACAddressDetector *netfakes.FakeMACAddressDetector - ) - - stubInterfaces := func(physicalInterfaces map[string]boshsettings.Network) { - addresses := map[string]string{} - for iface, networkSettings := range physicalInterfaces { - addresses[networkSettings.Mac] = iface - } - - fakeMACAddressDetector.DetectMacAddressesReturns(addresses, nil) - } - - BeforeEach(func() { - fs = fakesys.NewFakeFileSystem() - cmdRunner = fakesys.NewFakeCmdRunner() - ipResolver = &fakeip.FakeResolver{} - logger := boshlog.NewLogger(boshlog.LevelNone) - fakeMACAddressDetector = &netfakes.FakeMACAddressDetector{} - interfaceConfigurationCreator = NewInterfaceConfigurationCreator(logger) - interfaceAddrsProvider = &fakeip.FakeInterfaceAddressesProvider{} - fakeDnsResolver := &fakednsresolver.FakeDNSResolver{} - addressBroadcaster = &fakearp.FakeAddressBroadcaster{} - netManager = NewCentosNetManager( - fs, - cmdRunner, - ipResolver, - fakeMACAddressDetector, - interfaceConfigurationCreator, - interfaceAddrsProvider, - fakeDnsResolver, - addressBroadcaster, - logger, - ) - }) - - Describe("SetupNetworking", func() { - var ( - dhcpNetwork boshsettings.Network - staticNetwork boshsettings.Network - expectedNetworkConfigurationForStatic string - expectedNetworkConfigurationForDHCP string - expectedDhclientConfiguration 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", - 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"), - } - err := fs.WriteFileString("/etc/resolv.conf", ` -nameserver 8.8.8.8 -nameserver 9.9.9.9 -`) - Expect(err).NotTo(HaveOccurred()) - - expectedNetworkConfigurationForStatic = `DEVICE=ethstatic -BOOTPROTO=static -IPADDR=1.2.3.4 -NETMASK=255.255.255.0 -BROADCAST=1.2.3.255 -ONBOOT=yes -PEERDNS=no -DNS1=8.8.8.8 -DNS2=9.9.9.9 -` - - expectedNetworkConfigurationForDHCP = `DEVICE=ethdhcp -BOOTPROTO=dhcp -ONBOOT=yes -PEERDNS=yes -` - - expectedDhclientConfiguration = `# Generated by bosh-agent - -option rfc3442-classless-static-routes code 121 = array of unsigned integer 8; - -send host-name ""; - -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 network script for static and dynamic interfaces", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetwork, - "ethstatic": staticNetwork, - }) - - err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - staticConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic") - Expect(staticConfig).ToNot(BeNil()) - Expect(staticConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic)) - - dhcpConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethdhcp") - Expect(dhcpConfig).ToNot(BeNil()) - Expect(dhcpConfig.StringContents()).To(Equal(expectedNetworkConfigurationForDHCP)) - }) - - It("doesn't write /etc/resolv.conf with dns servers", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetwork, - "ethstatic": staticNetwork, - }) - - err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - resolvConf := fs.GetFileTestStat("/etc/resolv.conf") - Expect(resolvConf).ToNot(BeNil()) - Expect(resolvConf.StringContents()).To(Equal(` -nameserver 8.8.8.8 -nameserver 9.9.9.9 -`)) - }) - - It("doesn't write /etc/resolv.conf if there are no dns servers", func() { - dhcpNetworkWithoutDNS := boshsettings.Network{ - Type: "dynamic", - Mac: "fake-dhcp-mac-address", - } - - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetworkWithoutDNS, - }) - - err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetworkWithoutDNS}, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - resolvConf := fs.GetFileTestStat("/etc/resolv.conf") - Expect(resolvConf).ToNot(BeNil()) - Expect(resolvConf.StringContents()).To(Equal(` -nameserver 8.8.8.8 -nameserver 9.9.9.9 -`)) - - }) - - 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, nil) - Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("fs-write-file-error")) - }) - - It("returns errors when it can't create network interface configurations", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethstatic": staticNetwork, - }) - - staticNetwork.Netmask = "not an ip" // will cause InterfaceConfigurationCreator to fail - err := netManager.SetupNetworking(boshsettings.Networks{"static-network": staticNetwork}, nil, 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, nil) - Expect(err).ToNot(HaveOccurred()) - - dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf") - Expect(dhcpConfig).ToNot(BeNil()) - Expect(dhcpConfig.StringContents()).To(Equal(expectedDhclientConfiguration)) - - dhcpConfigSymlink := fs.GetFileTestStat("/etc/dhcp/dhclient-ethdhcp.conf") - Expect(dhcpConfigSymlink).ToNot(BeNil()) - Expect(dhcpConfigSymlink.SymlinkTarget).To(Equal("/etc/dhcp/dhclient.conf")) - }) - - 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, 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 ""; - -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; - -`)) - dhcpConfigSymlink := fs.GetFileTestStat("/etc/dhcp/dhclient-ethdhcp.conf") - Expect(dhcpConfigSymlink).ToNot(BeNil()) - Expect(dhcpConfigSymlink.SymlinkTarget).To(Equal("/etc/dhcp/dhclient.conf")) - }) - - 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, nil) - Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("dhclient.conf-write-error")) - }) - - It("returns an error if it can't symlink a dhcp configuration", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetwork, - "ethstatic": staticNetwork, - }) - - fs.SymlinkError = errors.New("dhclient-ethdhcp.conf-symlink-error") - - err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil, nil) - Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("dhclient-ethdhcp.conf-symlink-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, nil) - Expect(err).ToNot(HaveOccurred()) - - dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient-ethdhcp.conf") - Expect(dhcpConfig).To(BeNil()) - }) - - It("restarts the networks if any ifconfig file changes", func() { - changingStaticNetwork := boshsettings.Network{ - Type: "manual", - IP: "1.2.3.5", - Netmask: "255.255.255.0", - Gateway: "3.4.5.6", - Mac: "ethstatict-that-changes", - } - - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetwork, - "ethstatic-that-changes": changingStaticNetwork, - "ethstatic": staticNetwork, - }) - interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ - boship.NewSimpleInterfaceAddress("ethstatic", "1.2.3.4"), - boship.NewSimpleInterfaceAddress("ethstatic-that-changes", "1.2.3.5"), - } - - err := fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethstatic", expectedNetworkConfigurationForStatic) - Expect(err).NotTo(HaveOccurred()) - err = fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedDhclientConfiguration) - Expect(err).NotTo(HaveOccurred()) - - err = netManager.SetupNetworking(boshsettings.Networks{ - "dhcp-network": dhcpNetwork, - "changing-static-network": changingStaticNetwork, - "static-network": staticNetwork, - }, - nil, nil) - Expect(err).ToNot(HaveOccurred()) - - Expect(len(cmdRunner.RunCommands)).To(Equal(1)) - Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"})) - }) - - It("doesn't restart the networks if ifcfg and /etc/dhcp/dhclient.conf don't change", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetwork, - "ethstatic": staticNetwork, - }) - - err := fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethstatic", expectedNetworkConfigurationForStatic) - Expect(err).NotTo(HaveOccurred()) - err = fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethdhcp", expectedNetworkConfigurationForDHCP) - Expect(err).NotTo(HaveOccurred()) - err = fs.WriteFileString("/etc/dhcp/dhclient.conf", expectedDhclientConfiguration) - Expect(err).NotTo(HaveOccurred()) - - err = netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic)) - - dhcpConfig := fs.GetFileTestStat("/etc/dhcp/dhclient.conf") - Expect(dhcpConfig.StringContents()).To(Equal(expectedDhclientConfiguration)) - - 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, - }) - - err := fs.WriteFileString("/etc/sysconfig/network-scripts/ifcfg-ethstatic", expectedNetworkConfigurationForStatic) - Expect(err).NotTo(HaveOccurred()) - - err = netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic)) - - Expect(len(cmdRunner.RunCommands)).To(Equal(1)) - Expect(cmdRunner.RunCommands[0]).To(Equal([]string{"service", "network", "restart"})) - }) - - It("broadcasts MAC addresses for all interfaces", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethdhcp": dhcpNetwork, - "ethstatic": staticNetwork, - }) - - err := netManager.SetupNetworking(boshsettings.Networks{"dhcp-network": dhcpNetwork, "static-network": staticNetwork}, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - Eventually(func() []boship.InterfaceAddress { return addressBroadcaster.Value() }).Should( - 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{"4.4.4.4", "5.5.5.5"}, - 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, nil) - Expect(err).ToNot(HaveOccurred()) - - networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic)) - }) - - It("doesn't use vip networks dns", func() { - stubInterfaces(map[string]boshsettings.Network{ - "ethstatic": staticNetwork, - }) - - vipNetwork := boshsettings.Network{ - Type: "vip", - Default: []string{"dns"}, - DNS: []string{"4.4.4.4", "5.5.5.5"}, - Mac: "fake-vip-mac-address", - IP: "9.8.7.6", - } - - err := netManager.SetupNetworking(boshsettings.Networks{ - "vip-network": vipNetwork, - "static-network": staticNetwork, - }, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).ToNot(ContainSubstring("4.4.4.4")) - Expect(networkConfig.StringContents()).ToNot(ContainSubstring("5.5.5.5")) - }) - - 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}, nil, errCh) - Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("Validating static network configuration")) - }) - }) - - Context("when no MAC address is provided in the settings", func() { - var staticNetworkWithoutMAC boshsettings.Network - - BeforeEach(func() { - staticNetworkWithoutMAC = boshsettings.Network{ - Type: "manual", - IP: "1.2.3.4", - Netmask: "255.255.255.0", - Gateway: "3.4.5.6", - DNS: []string{"8.8.8.8", "9.9.9.9"}, - Default: []string{"dns"}, - } - }) - - It("configures network for single device", func() { - stubInterfaces( - map[string]boshsettings.Network{ - "ethstatic": staticNetwork, - }, - ) - - err := netManager.SetupNetworking(boshsettings.Networks{ - "static-network": staticNetworkWithoutMAC, - }, nil, nil) - Expect(err).ToNot(HaveOccurred()) - - networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-ethstatic") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).To(Equal(expectedNetworkConfigurationForStatic)) - }) - }) - - Context("when manual networks were configured with portable IP", func() { - var ( - portableNetwork boshsettings.Network - staticNetwork boshsettings.Network - staticNetwork1 boshsettings.Network - ) - BeforeEach(func() { - portableNetwork = boshsettings.Network{ - Type: "manual", - IP: "10.112.166.136", - Netmask: "255.255.255.192", - Resolved: false, - UseDHCP: false, - DNS: []string{"8.8.8.8"}, - Alias: "eth0:0", - } - staticNetwork = boshsettings.Network{ - Type: "dynamic", - IP: "169.50.68.75", - Netmask: "255.255.255.224", - Gateway: "169.50.68.65", - Default: []string{"gateway", "dns"}, - Resolved: false, - UseDHCP: false, - DNS: []string{"8.8.8.8", "10.0.80.11", "10.0.80.12"}, - Mac: "06:64:d4:7d:63:71", - Alias: "eth1", - } - staticNetwork1 = boshsettings.Network{ - Type: "dynamic", - IP: "10.112.39.113", - Netmask: "255.255.255.128", - Resolved: false, - UseDHCP: false, - DNS: []string{"8.8.8.8", "10.0.80.11", "10.0.80.12"}, - Mac: "06:b7:e8:0c:38:d8", - Alias: "eth0", - } - interfaceAddrsProvider.GetInterfaceAddresses = []boship.InterfaceAddress{ - boship.NewSimpleInterfaceAddress("eth0", "10.112.39.113"), - boship.NewSimpleInterfaceAddress("eth1", "169.50.68.75"), - } - err := fs.WriteFileString("/etc/resolv.conf", ` -nameserver 8.8.8.8 -nameserver 10.0.80.11 -nameserver 10.0.80.12 -`) - Expect(err).NotTo(HaveOccurred()) - }) - - scrubMultipleLines := func(in string) string { - return strings.Replace(in, "\n\n\n", "\n\n", -1) //nolint:staticcheck - } - - It("succeeds", func() { - stubInterfaces(map[string]boshsettings.Network{ - "eth1": staticNetwork, - "eth0": staticNetwork1, - }) - - err := netManager.SetupNetworking(boshsettings.Networks{"default": portableNetwork, "dynamic": staticNetwork, "dynamic_1": staticNetwork1}, nil, nil) - Expect(err).NotTo(HaveOccurred()) - - Eventually(func() []boship.InterfaceAddress { - ifaceAddresses := addressBroadcaster.Value() - sort.Slice(ifaceAddresses[:], func(i, j int) bool { - return ifaceAddresses[i].GetInterfaceName() < ifaceAddresses[j].GetInterfaceName() - }) - return ifaceAddresses - }).Should( - Equal([]boship.InterfaceAddress{ - boship.NewSimpleInterfaceAddress("eth0", "10.112.39.113"), - boship.NewSimpleInterfaceAddress("eth1", "169.50.68.75"), - }), - ) - - matches, err := fs.Ls("/etc/sysconfig/network-scripts/") - Expect(err).NotTo(HaveOccurred()) - Expect(matches).To(ConsistOf( - "/etc/sysconfig/network-scripts/ifcfg-eth0", - "/etc/sysconfig/network-scripts/ifcfg-eth0:0", - "/etc/sysconfig/network-scripts/ifcfg-eth1", - )) - - format.TruncatedDiff = false - - networkConfig := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).To(Equal(`DEVICE=eth0 -BOOTPROTO=static -IPADDR=10.112.39.113 -NETMASK=255.255.255.128 -BROADCAST=10.112.39.127 -ONBOOT=yes -PEERDNS=no -DNS1=8.8.8.8 -DNS2=10.0.80.11 -DNS3=10.0.80.12 -`)) - networkConfig = fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0:0") - Expect(networkConfig).ToNot(BeNil()) - Expect(networkConfig.StringContents()).To(Equal(`DEVICE=eth0:0 -BOOTPROTO=static -IPADDR=10.112.166.136 -NETMASK=255.255.255.192 -BROADCAST=10.112.166.191 -ONBOOT=yes -PEERDNS=no -DNS1=8.8.8.8 -DNS2=10.0.80.11 -DNS3=10.0.80.12 -`)) - networkConfig = fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth1") - Expect(networkConfig).ToNot(BeNil()) - Expect(scrubMultipleLines(networkConfig.StringContents())).To(Equal(`DEVICE=eth1 -BOOTPROTO=static -IPADDR=169.50.68.75 -NETMASK=255.255.255.224 -BROADCAST=169.50.68.95 -GATEWAY=169.50.68.65 -ONBOOT=yes -PEERDNS=no -DNS1=8.8.8.8 -DNS2=10.0.80.11 -DNS3=10.0.80.12 -`)) - }) - }) - - 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, nil) - Expect(err).ToNot(HaveOccurred()) - - networkConfig0 := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth0") - networkConfig1 := fs.GetFileTestStat("/etc/sysconfig/network-scripts/ifcfg-eth1") - Expect(networkConfig0).ToNot(BeNil()) - Expect(networkConfig1).ToNot(BeNil()) - Expect(networkConfig0.StringContents()).To(Equal(`DEVICE=eth0 -BOOTPROTO=static -IPADDR=1.2.3.4 -NETMASK=255.255.255.0 -BROADCAST=1.2.3.255 -ONBOOT=yes -PEERDNS=no -DNS1=8.8.8.8 -`)) - Expect(networkConfig1.StringContents()).To(Equal(`DEVICE=eth1 -BOOTPROTO=static -IPADDR=5.6.7.8 -NETMASK=255.255.255.0 -BROADCAST=5.6.7.255 -GATEWAY=6.7.8.9 -ONBOOT=yes -PEERDNS=no -DNS1=8.8.8.8 -`)) - - }) - - }) - - Describe("GetConfiguredNetworkInterfaces", func() { - Context("when there are network devices", func() { - BeforeEach(func() { - stubInterfaces(map[string]boshsettings.Network{ - "fake-eth0": boshsettings.Network{Mac: "aa:bb"}, - "fake-eth1": boshsettings.Network{Mac: "cc:dd"}, - "fake-eth2": boshsettings.Network{Mac: "ee:ff"}, - "fake-ens4": boshsettings.Network{Mac: "yy:zz"}, - }) - }) - - writeIfcgfFile := func(iface string) { - err := fs.WriteFileString(fmt.Sprintf("/etc/sysconfig/network-scripts/ifcfg-%s", iface), "fake-config") - Expect(err).NotTo(HaveOccurred()) - } - - It("returns networks that have ifcfg config present", func() { - writeIfcgfFile("fake-eth0") - writeIfcgfFile("fake-eth2") - - 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{})) - }) - }) - }) -} diff --git a/platform/net/routes_searcher_unix.go b/platform/net/routes_searcher_unix.go index b2fffcbe7..52443b940 100644 --- a/platform/net/routes_searcher_unix.go +++ b/platform/net/routes_searcher_unix.go @@ -13,7 +13,6 @@ import ( ) // cmdRoutesSearcher uses `route -n` command to list routes -// which routes in a same format on Ubuntu and CentOS type cmdRoutesSearcher struct { runner boshsys.CmdRunner logger boshlog.Logger diff --git a/platform/provider.go b/platform/provider.go index 7349c0110..7581f9828 100644 --- a/platform/provider.go +++ b/platform/provider.go @@ -96,7 +96,6 @@ func NewProvider(logger boshlog.Logger, dirProvider boshdirs.Provider, statsColl kernelIPv6 := boshnet.NewKernelIPv6Impl(fs, runner, logger) macAddressDetector := boshnet.NewLinuxMacAddressDetector(fs, logger) - centosNetManager := boshnet.NewCentosNetManager(fs, runner, ipResolver, macAddressDetector, interfaceConfigurationCreator, interfaceAddressesProvider, dnsResolver, arping, logger) ubuntuNetManager := boshnet.NewUbuntuNetManager(fs, runner, ipResolver, macAddressDetector, interfaceConfigurationCreator, interfaceAddressesProvider, dnsResolver, arping, kernelIPv6, logger) windowsNetManager := boshnet.NewWindowsNetManager( @@ -109,7 +108,6 @@ func NewProvider(logger boshlog.Logger, dirProvider boshdirs.Provider, statsColl dirProvider, ) - centosCertManager := boshcert.NewCentOSCertManager(fs, runner, 0, logger) ubuntuCertManager := boshcert.NewUbuntuCertManager(fs, runner, 60, logger) windowsCertManager := boshcert.NewWindowsCertManager(fs, runner, dirProvider, logger) @@ -161,32 +159,6 @@ func NewProvider(logger boshlog.Logger, dirProvider boshdirs.Provider, statsColl uuidGenerator := boshuuid.NewGenerator() logsTarProvider := boshlogstarprovider.NewLogsTarProvider(compressor, copier, dirProvider) - var centos = func() Platform { - return NewLinuxPlatform( - fs, - runner, - statsCollector, - compressor, - copier, - dirProvider, - vitalsService, - linuxCdutil, - linuxDiskManager, - centosNetManager, - centosCertManager, - monitRetryStrategy, - devicePathResolver, - bootstrapState, - options.Linux, - logger, - defaultNetworkResolver, - uuidGenerator, - auditLogger, - logsTarProvider, - serviceManager, - ) - } - var ubuntu = func() Platform { return NewLinuxPlatform( fs, @@ -248,7 +220,6 @@ func NewProvider(logger boshlog.Logger, dirProvider boshdirs.Provider, statsColl return provider{ platforms: map[string]func() Platform{ "ubuntu": ubuntu, - "centos": centos, "dummy": dummy, "windows": windows, },