From 0aff8e2bcdb04ea14947fd9d225f1e636e5de46f Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Tue, 17 Jun 2025 11:24:13 +0200 Subject: [PATCH 01/22] Fix unit tests --- agent/action/get_state.go | 1 + agent/agent.go | 1 + .../instance_metadata_settings_source.go | 1 + main/agent.go | 1 - platform/dummy_platform_test.go | 2 +- platform/linux_platform_test.go | 2 +- platform/net/arp/arping_test.go | 2 +- platform/net/default_network_resolver.go | 14 +++++++++----- platform/net/default_network_resolver_test.go | 10 +++++----- .../fakes/fake_default_network_resolver.go | 2 +- platform/net/ip/fakes/fake_ip_resolver.go | 19 ++++++++++++++----- platform/net/ip/interface_address_test.go | 18 +++++++++--------- .../ip/interface_addresses_provider_test.go | 2 +- platform/net/ip/ip_resolver.go | 6 ++++++ platform/net/ip/ip_resolver_test.go | 4 ++-- platform/net/routes_searcher_unix_test.go | 8 ++++---- platform/net/routes_searcher_windows.go | 8 ++++++-- platform/net/ubuntu_net_manager.go | 1 + platform/platformfakes/fake_platform.go | 2 +- .../fake_platform_settings_getter.go | 2 +- 20 files changed, 66 insertions(+), 40 deletions(-) diff --git a/agent/action/get_state.go b/agent/action/get_state.go index 3998d7497..e71cfee82 100644 --- a/agent/action/get_state.go +++ b/agent/action/get_state.go @@ -31,6 +31,7 @@ func NewGetState( return } + func (a GetStateAction) IsAsynchronous(_ ProtocolVersion) bool { return false } diff --git a/agent/agent.go b/agent/agent.go index 93fea3659..2cb2c374c 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -144,6 +144,7 @@ func (a Agent) sendAndRecordHeartbeat(errCh chan error, retry bool) { heartbeatRetryable := boshretry.NewRetryable(func() (bool, error) { a.logger.Info(agentLogTag, "Attempting to send Heartbeat") + a.logger.Info(agentLogTag, "Attempting to send Heartbeat - with a test message 1") err = a.mbusHandler.Send(boshhandler.HealthMonitor, boshhandler.Heartbeat, heartbeat) if err != nil { return true, bosherr.WrapError(err, "Sending Heartbeat") diff --git a/infrastructure/instance_metadata_settings_source.go b/infrastructure/instance_metadata_settings_source.go index 06dd852f9..05951cd95 100644 --- a/infrastructure/instance_metadata_settings_source.go +++ b/infrastructure/instance_metadata_settings_source.go @@ -87,5 +87,6 @@ func (s *InstanceMetadataSettingsSource) Settings() (boshsettings.Settings, erro err, "Parsing instance metadata settings from %q", contents) } + s.logger.Info("INFO", "Parsed settings from instance metadata: %s", contents) return settings, nil } diff --git a/main/agent.go b/main/agent.go index f9c8ca577..639f52fa2 100644 --- a/main/agent.go +++ b/main/agent.go @@ -31,7 +31,6 @@ func runAgent(opts boshapp.Options, logger logger.Logger) chan error { } app := boshapp.New(logger, fs) - err := app.Setup(opts) if err != nil { logger.Error(mainLogTag, "App setup %s", err.Error()) diff --git a/platform/dummy_platform_test.go b/platform/dummy_platform_test.go index 9d36d8807..8929ae0a7 100644 --- a/platform/dummy_platform_test.go +++ b/platform/dummy_platform_test.go @@ -73,7 +73,7 @@ var _ = Describe("DummyPlatform", func() { err := fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`) Expect(err).NotTo(HaveOccurred()) - network, err := platform.GetDefaultNetwork() + network, err := platform.GetDefaultNetwork(true) Expect(err).NotTo(HaveOccurred()) Expect(network.IP).To(Equal("1.2.3.4")) diff --git a/platform/linux_platform_test.go b/platform/linux_platform_test.go index 79722a7c5..d443bd8a6 100644 --- a/platform/linux_platform_test.go +++ b/platform/linux_platform_test.go @@ -4140,7 +4140,7 @@ unit: sectors defaultNetwork := boshsettings.Network{IP: "1.2.3.4"} fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork - network, err := platform.GetDefaultNetwork() + network, err := platform.GetDefaultNetwork(true) Expect(err).ToNot(HaveOccurred()) Expect(network).To(Equal(defaultNetwork)) diff --git a/platform/net/arp/arping_test.go b/platform/net/arp/arping_test.go index 322723c36..afe5e65be 100644 --- a/platform/net/arp/arping_test.go +++ b/platform/net/arp/arping_test.go @@ -19,7 +19,7 @@ type failingInterfaceAddress struct{} func (ia failingInterfaceAddress) GetInterfaceName() string { return "eth0" } -func (ia failingInterfaceAddress) GetIP() (string, error) { +func (ia failingInterfaceAddress) GetIP(IsVersion6 bool) (string, error) { return "", errors.New("fake-get-ip-err") } diff --git a/platform/net/default_network_resolver.go b/platform/net/default_network_resolver.go index 4726bdedd..0076361a6 100644 --- a/platform/net/default_network_resolver.go +++ b/platform/net/default_network_resolver.go @@ -44,15 +44,19 @@ func (r defaultNetworkResolver) GetDefaultNetwork(is_ipv6 bool) (boshsettings.Ne ip, err := r.ipResolver.GetPrimaryIP(route.InterfaceName, is_ipv6) - if err != nil { - ipVersion := 4 + ipVersion := 4 + if is_ipv6 { + ipVersion = 6 + } - if is_ipv6 { - ipVersion = 6 - } + if err != nil { return network, bosherr.WrapErrorf(err, "Getting primary IPv%d for interface '%s'", ipVersion, route.InterfaceName) } + if ip == nil { + return network, bosherr.Errorf("Getting primary IPv%d for interface '%s'", ipVersion, route.InterfaceName) + } + return boshsettings.Network{ IP: ip.IP.String(), Netmask: gonet.IP(ip.Mask).String(), diff --git a/platform/net/default_network_resolver_test.go b/platform/net/default_network_resolver_test.go index 2ff8ca156..978758e76 100644 --- a/platform/net/default_network_resolver_test.go +++ b/platform/net/default_network_resolver_test.go @@ -52,7 +52,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns network with primary IPv4 address from associated interface", func() { - network, err := resolver.GetDefaultNetwork() + network, err := resolver.GetDefaultNetwork(false) Expect(err).ToNot(HaveOccurred()) Expect(network).To(Equal(boshsettings.Network{ IP: "127.0.0.1", @@ -68,7 +68,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error", func() { - network, err := resolver.GetDefaultNetwork() + network, err := resolver.GetDefaultNetwork(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-primary-ipv4-err")) Expect(network).To(Equal(boshsettings.Network{})) @@ -86,7 +86,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error", func() { - network, err := resolver.GetDefaultNetwork() + network, err := resolver.GetDefaultNetwork(true) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to find default route")) Expect(network).To(Equal(boshsettings.Network{})) @@ -99,7 +99,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error if there are no routes", func() { - network, err := resolver.GetDefaultNetwork() + network, err := resolver.GetDefaultNetwork(true) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("No routes")) Expect(network).To(Equal(boshsettings.Network{})) @@ -112,7 +112,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error if searching routes fails", func() { - network, err := resolver.GetDefaultNetwork() + network, err := resolver.GetDefaultNetwork(true) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-search-routes-err")) Expect(network).To(Equal(boshsettings.Network{})) diff --git a/platform/net/fakes/fake_default_network_resolver.go b/platform/net/fakes/fake_default_network_resolver.go index 222c46625..d6fb7722b 100644 --- a/platform/net/fakes/fake_default_network_resolver.go +++ b/platform/net/fakes/fake_default_network_resolver.go @@ -10,7 +10,7 @@ type FakeDefaultNetworkResolver struct { GetDefaultNetworkCalled bool } -func (r *FakeDefaultNetworkResolver) GetDefaultNetwork() (boshsettings.Network, error) { +func (r *FakeDefaultNetworkResolver) GetDefaultNetwork(isIpv6 bool) (boshsettings.Network, error) { r.GetDefaultNetworkCalled = true return r.GetDefaultNetworkNetwork, r.GetDefaultNetworkErr } diff --git a/platform/net/ip/fakes/fake_ip_resolver.go b/platform/net/ip/fakes/fake_ip_resolver.go index 7e4d676c7..937a7eeff 100644 --- a/platform/net/ip/fakes/fake_ip_resolver.go +++ b/platform/net/ip/fakes/fake_ip_resolver.go @@ -5,12 +5,21 @@ import ( ) type FakeResolver struct { - GetPrimaryIPInterfaceName string - GetPrimaryIPIPNet *gonet.IPNet - GetPrimaryIPErr error + GetPrimaryIPv4InterfaceName string + GetPrimaryIPv4IPNet *gonet.IPNet + GetPrimaryIPErr error + GetPrimaryIPv4Err error } func (r *FakeResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) { - r.GetPrimaryIPInterfaceName = interfaceName - return r.GetPrimaryIPIPNet, r.GetPrimaryIPErr + r.GetPrimaryIPv4InterfaceName = interfaceName + if !is_ipv6 { + return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPv4Err + } + return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPErr +} + +func (r *FakeResolver) GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) { + r.GetPrimaryIPv4InterfaceName = interfaceName + return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPv4Err } diff --git a/platform/net/ip/interface_address_test.go b/platform/net/ip/interface_address_test.go index 9ef144608..84b4405e8 100644 --- a/platform/net/ip/interface_address_test.go +++ b/platform/net/ip/interface_address_test.go @@ -14,23 +14,23 @@ import ( var _ = Describe("simpleInterfaceAddress", func() { Describe("GetIP", func() { It("returns fully formatted IPv4", func() { - ipStr, err := NewSimpleInterfaceAddress("iface", "127.0.0.1").GetIP() + ipStr, err := NewSimpleInterfaceAddress("iface", "127.0.0.1").GetIP(false) Expect(err).ToNot(HaveOccurred()) Expect(ipStr).To(Equal("127.0.0.1")) }) It("returns fully formatted IPv6", func() { - ipStr, err := NewSimpleInterfaceAddress("iface", "ff00:f8::").GetIP() + ipStr, err := NewSimpleInterfaceAddress("iface", "ff00:f8::").GetIP(true) Expect(err).ToNot(HaveOccurred()) Expect(ipStr).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000")) - ipStr, err = NewSimpleInterfaceAddress("iface", "1101:2202:3303:4404:5505:6606:7707:8808").GetIP() + ipStr, err = NewSimpleInterfaceAddress("iface", "1101:2202:3303:4404:5505:6606:7707:8808").GetIP(true) Expect(err).ToNot(HaveOccurred()) Expect(ipStr).To(Equal("1101:2202:3303:4404:5505:6606:7707:8808")) }) It("returns error if IP cannot be parsed", func() { - _, err := NewSimpleInterfaceAddress("iface", "").GetIP() + _, err := NewSimpleInterfaceAddress("iface", "").GetIP(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(Equal("Cannot parse IP ''")) }) @@ -58,7 +58,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { }) It("resolves the IP and returns fully formatted IPv4", func() { - ip, err := interfaceAddress.GetIP() + ip, err := interfaceAddress.GetIP(false) Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("127.0.0.1")) @@ -71,7 +71,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { Mask: gonet.CIDRMask(64, 128), } - ip, err := interfaceAddress.GetIP() + ip, err := interfaceAddress.GetIP(true) Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000")) @@ -81,7 +81,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { It("returns error if resolving IP fails", func() { ipResolver.GetPrimaryIPv4Err = errors.New("fake-get-primary-ipv4-err") - ip, err := interfaceAddress.GetIP() + ip, err := interfaceAddress.GetIP(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-primary-ipv4-err")) Expect(ip).To(Equal("")) @@ -95,14 +95,14 @@ var _ = Describe("resolvingInterfaceAddress", func() { Mask: gonet.CIDRMask(16, 32), } - _, err := interfaceAddress.GetIP() + _, err := interfaceAddress.GetIP(false) Expect(err).ToNot(HaveOccurred()) }) It("does not attempt to resolve IP again", func() { ipResolver.GetPrimaryIPv4InterfaceName = "" - ip, err := interfaceAddress.GetIP() + ip, err := interfaceAddress.GetIP(false) Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("127.0.0.1")) diff --git a/platform/net/ip/interface_addresses_provider_test.go b/platform/net/ip/interface_addresses_provider_test.go index adcfadd3a..75920fbfa 100644 --- a/platform/net/ip/interface_addresses_provider_test.go +++ b/platform/net/ip/interface_addresses_provider_test.go @@ -22,7 +22,7 @@ var _ = Describe("InterfaceAddressesProvider", func() { var loopBackInterface InterfaceAddress for _, iface := range ifaces { - ip, err := iface.GetIP() + ip, err := iface.GetIP(true) Expect(err).ToNot(HaveOccurred()) if ip == "127.0.0.1" { diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index ca20288eb..4324ba7a4 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -20,6 +20,7 @@ func NetworkInterfaceToAddrsFunc(interfaceName string) ([]gonet.Addr, error) { type Resolver interface { // GetPrimaryIP always returns error unless IPNet is found for given interface GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) + GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) } type ipResolver struct { @@ -63,3 +64,8 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN return nil, bosherr.Errorf("Failed to find primary address IPv%d for interface '%s'", ipVersion, interfaceName) } + +func (r ipResolver) GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) { + return r.GetPrimaryIP(interfaceName, false) +} + diff --git a/platform/net/ip/ip_resolver_test.go b/platform/net/ip/ip_resolver_test.go index 9df3e7355..ee813d996 100644 --- a/platform/net/ip/ip_resolver_test.go +++ b/platform/net/ip/ip_resolver_test.go @@ -72,7 +72,7 @@ var _ = Describe("ipResolver", func() { ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("Failed to find primary address for interface")) + Expect(err.Error()).To(ContainSubstring("Failed to find primary address IPv4 for interface 'fake-iface-name'")) Expect(ip).To(BeNil()) }) @@ -81,7 +81,7 @@ var _ = Describe("ipResolver", func() { ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("Failed to find primary address for interface")) + Expect(err.Error()).To(ContainSubstring("Failed to find primary address IPv4 for interface 'fake-iface-name'")) Expect(ip).To(BeNil()) }) }) diff --git a/platform/net/routes_searcher_unix_test.go b/platform/net/routes_searcher_unix_test.go index fc3c818ab..1170310d8 100644 --- a/platform/net/routes_searcher_unix_test.go +++ b/platform/net/routes_searcher_unix_test.go @@ -36,7 +36,7 @@ default via 172.16.79.1 dev eth0 proto dhcp metric 100 `, }) - routes, err := searcher.SearchRoutes() + routes, err := searcher.SearchRoutes(false) Expect(err).ToNot(HaveOccurred()) Expect(runner.RunCommandsQuietly[0]).To(Equal([]string{"ip", "r"})) Expect(routes).To(Equal([]Route{ @@ -55,7 +55,7 @@ blackhole 10.200.115.192/26 proto bird `, }) - routes, err := searcher.SearchRoutes() + routes, err := searcher.SearchRoutes(false) Expect(err).ToNot(HaveOccurred()) Expect(runner.RunCommandsQuietly[0]).To(Equal([]string{"ip", "r"})) Expect(routes).To(Equal([]Route{ @@ -71,7 +71,7 @@ blackhole 10.200.115.192/26 proto bird `, }) - routes, err := searcher.SearchRoutes() + routes, err := searcher.SearchRoutes(true) Expect(err).ToNot(HaveOccurred()) Expect(routes).To(BeEmpty()) }) @@ -83,7 +83,7 @@ blackhole 10.200.115.192/26 proto bird Error: errors.New("fake-run-err"), }) - routes, err := searcher.SearchRoutes() + routes, err := searcher.SearchRoutes(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-run-err")) Expect(routes).To(BeEmpty()) diff --git a/platform/net/routes_searcher_windows.go b/platform/net/routes_searcher_windows.go index 7545b8bd9..352579988 100644 --- a/platform/net/routes_searcher_windows.go +++ b/platform/net/routes_searcher_windows.go @@ -16,18 +16,22 @@ func NewRoutesSearcher(_ boshlog.Logger, cmdRunner boshsys.CmdRunner, interfaceM } func (s windowsRoutesSearcher) SearchRoutes(ipv6 bool) ([]Route, error) { + var err error + ifs, err := s.interfaceManager.GetInterfaces() if err != nil { return nil, bosherr.WrapError(err, "Running route") } + var defaultGateway string + if ipv6 { - defaultGateway, _, _, err := s.cmdRunner.RunCommandQuietly("(Get-NetRoute -DestinationPrefix '::/0').NextHop") + defaultGateway, _, _, err = s.cmdRunner.RunCommandQuietly("(Get-NetRoute -DestinationPrefix '::/0').NextHop") if err != nil { return nil, bosherr.WrapError(err, "Running IPv6 route") } } else { - defaultGateway, _, _, err := s.cmdRunner.RunCommandQuietly("(Get-NetRoute -DestinationPrefix '0.0.0.0/0').NextHop") + defaultGateway, _, _, err = s.cmdRunner.RunCommandQuietly("(Get-NetRoute -DestinationPrefix '0.0.0.0/0').NextHop") if err != nil { return nil, bosherr.WrapError(err, "Running IPv4 route") } diff --git a/platform/net/ubuntu_net_manager.go b/platform/net/ubuntu_net_manager.go index f259ac9ad..7eed8637f 100644 --- a/platform/net/ubuntu_net_manager.go +++ b/platform/net/ubuntu_net_manager.go @@ -512,6 +512,7 @@ func (net UbuntuNetManager) writeDynamicInterfaceConfiguration(config DHCPInterf matchSection.AddKey("Name", config.Name) file.AppendSection(matchSection) + // Network Section networkSection := &ini.Section{Name: "Network"} networkSection.AddKey("DHCP", "yes") diff --git a/platform/platformfakes/fake_platform.go b/platform/platformfakes/fake_platform.go index 2512ea3fa..91f3ea77b 100644 --- a/platform/platformfakes/fake_platform.go +++ b/platform/platformfakes/fake_platform.go @@ -1420,7 +1420,7 @@ func (fake *FakePlatform) GetCopierReturnsOnCall(i int, result1 fileutil.Copier) }{result1} } -func (fake *FakePlatform) GetDefaultNetwork() (settings.Network, error) { +func (fake *FakePlatform) GetDefaultNetwork(isIpv6 bool) (settings.Network, error) { fake.getDefaultNetworkMutex.Lock() ret, specificReturn := fake.getDefaultNetworkReturnsOnCall[len(fake.getDefaultNetworkArgsForCall)] fake.getDefaultNetworkArgsForCall = append(fake.getDefaultNetworkArgsForCall, struct { diff --git a/settings/settingsfakes/fake_platform_settings_getter.go b/settings/settingsfakes/fake_platform_settings_getter.go index 58a895f4e..cb706fb0a 100644 --- a/settings/settingsfakes/fake_platform_settings_getter.go +++ b/settings/settingsfakes/fake_platform_settings_getter.go @@ -128,7 +128,7 @@ func (fake *FakePlatformSettingsGetter) GetAgentSettingsPathReturnsOnCall(i int, }{result1} } -func (fake *FakePlatformSettingsGetter) GetDefaultNetwork() (settings.Network, error) { +func (fake *FakePlatformSettingsGetter) GetDefaultNetwork(isIpV6 bool) (settings.Network, error) { fake.getDefaultNetworkMutex.Lock() ret, specificReturn := fake.getDefaultNetworkReturnsOnCall[len(fake.getDefaultNetworkArgsForCall)] fake.getDefaultNetworkArgsForCall = append(fake.getDefaultNetworkArgsForCall, struct { From a890ca9460c6ad14f2aa25f53e5fc84ec2f69c70 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Tue, 17 Jun 2025 14:22:09 +0200 Subject: [PATCH 02/22] Fix lints --- platform/net/ubuntu_net_manager.go | 1 - 1 file changed, 1 deletion(-) diff --git a/platform/net/ubuntu_net_manager.go b/platform/net/ubuntu_net_manager.go index 7eed8637f..f259ac9ad 100644 --- a/platform/net/ubuntu_net_manager.go +++ b/platform/net/ubuntu_net_manager.go @@ -512,7 +512,6 @@ func (net UbuntuNetManager) writeDynamicInterfaceConfiguration(config DHCPInterf matchSection.AddKey("Name", config.Name) file.AppendSection(matchSection) - // Network Section networkSection := &ini.Section{Name: "Network"} networkSection.AddKey("DHCP", "yes") From f36111cf0a14c981b8a3d0a44c5897c77b08cf96 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Wed, 18 Jun 2025 08:20:35 +0200 Subject: [PATCH 03/22] Fix linting --- agent/action/get_state.go | 1 - platform/net/ip/ip_resolver.go | 3 +-- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/agent/action/get_state.go b/agent/action/get_state.go index e71cfee82..3998d7497 100644 --- a/agent/action/get_state.go +++ b/agent/action/get_state.go @@ -31,7 +31,6 @@ func NewGetState( return } - func (a GetStateAction) IsAsynchronous(_ ProtocolVersion) bool { return false } diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index 4324ba7a4..285b50fba 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -60,7 +60,7 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN ipVersion := 4 if is_ipv6 { ipVersion = 6 - } + } return nil, bosherr.Errorf("Failed to find primary address IPv%d for interface '%s'", ipVersion, interfaceName) } @@ -68,4 +68,3 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN func (r ipResolver) GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) { return r.GetPrimaryIP(interfaceName, false) } - From f491d2b96fbb88de2490fd50cd19b757282df26d Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Wed, 18 Jun 2025 08:27:46 +0200 Subject: [PATCH 04/22] Fix tests --- platform/net/routes_searcher_windows_test.go | 2 +- platform/windows_platform_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/platform/net/routes_searcher_windows_test.go b/platform/net/routes_searcher_windows_test.go index 29471aa2f..046697137 100644 --- a/platform/net/routes_searcher_windows_test.go +++ b/platform/net/routes_searcher_windows_test.go @@ -35,7 +35,7 @@ var _ = Describe("Windows Route Searcher", func() { Stdout: `10.0.16.1`, }) - routes, err := searcher.SearchRoutes() + routes, err := searcher.SearchRoutes(false) Expect(err).NotTo(HaveOccurred()) Expect(routes).To(HaveLen(2)) diff --git a/platform/windows_platform_test.go b/platform/windows_platform_test.go index c54878859..d3fec1017 100644 --- a/platform/windows_platform_test.go +++ b/platform/windows_platform_test.go @@ -273,7 +273,7 @@ var _ = Describe("WindowsPlatform", func() { defaultNetwork := boshsettings.Network{IP: "1.2.3.4"} fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork - network, err := platform.GetDefaultNetwork() + network, err := platform.GetDefaultNetwork(false) Expect(err).ToNot(HaveOccurred()) Expect(network).To(Equal(defaultNetwork)) From 4082d2ec3f15e43bce681ebfdb86c2fe4d8ac3b3 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Wed, 18 Jun 2025 08:38:43 +0200 Subject: [PATCH 05/22] Fix tests --- agent/agent.go | 1 - infrastructure/instance_metadata_settings_source.go | 1 - 2 files changed, 2 deletions(-) diff --git a/agent/agent.go b/agent/agent.go index 2cb2c374c..93fea3659 100644 --- a/agent/agent.go +++ b/agent/agent.go @@ -144,7 +144,6 @@ func (a Agent) sendAndRecordHeartbeat(errCh chan error, retry bool) { heartbeatRetryable := boshretry.NewRetryable(func() (bool, error) { a.logger.Info(agentLogTag, "Attempting to send Heartbeat") - a.logger.Info(agentLogTag, "Attempting to send Heartbeat - with a test message 1") err = a.mbusHandler.Send(boshhandler.HealthMonitor, boshhandler.Heartbeat, heartbeat) if err != nil { return true, bosherr.WrapError(err, "Sending Heartbeat") diff --git a/infrastructure/instance_metadata_settings_source.go b/infrastructure/instance_metadata_settings_source.go index 05951cd95..06dd852f9 100644 --- a/infrastructure/instance_metadata_settings_source.go +++ b/infrastructure/instance_metadata_settings_source.go @@ -87,6 +87,5 @@ func (s *InstanceMetadataSettingsSource) Settings() (boshsettings.Settings, erro err, "Parsing instance metadata settings from %q", contents) } - s.logger.Info("INFO", "Parsed settings from instance metadata: %s", contents) return settings, nil } From 60fc458fce21f36f2533cad645b0c2d9dd6f8f78 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Wed, 18 Jun 2025 10:20:14 +0200 Subject: [PATCH 06/22] Fix tests --- platform/dummy_platform_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platform/dummy_platform_test.go b/platform/dummy_platform_test.go index 8929ae0a7..478507a42 100644 --- a/platform/dummy_platform_test.go +++ b/platform/dummy_platform_test.go @@ -73,7 +73,7 @@ var _ = Describe("DummyPlatform", func() { err := fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`) Expect(err).NotTo(HaveOccurred()) - network, err := platform.GetDefaultNetwork(true) + network, err := platform.GetDefaultNetwork(false) Expect(err).NotTo(HaveOccurred()) Expect(network.IP).To(Equal("1.2.3.4")) From f181d825feef616f83f8a6876cc32655f82925e0 Mon Sep 17 00:00:00 2001 From: Felix Moehler Date: Wed, 18 Jun 2025 11:10:47 +0200 Subject: [PATCH 07/22] add debugging --- platform/net/ubuntu_net_manager.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/platform/net/ubuntu_net_manager.go b/platform/net/ubuntu_net_manager.go index f259ac9ad..caf18f8ed 100644 --- a/platform/net/ubuntu_net_manager.go +++ b/platform/net/ubuntu_net_manager.go @@ -109,6 +109,8 @@ func (net UbuntuNetManager) SetupIPv6(config boshsettings.IPv6, stopCh <-chan st } func (net UbuntuNetManager) SetupNetworking(networks boshsettings.Networks, mbus string, errCh chan error) error { + _, _, _, err := net.cmdRunner.RunCommand("ip", "a") + if networks.IsPreconfigured() { // Note in this case IPs are not broadcast dnsNetwork, _ := networks.DefaultNetworkFor("dns") From ccc1372dd65aed184a4a9bd3d8b3427076ac2dc5 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Wed, 18 Jun 2025 15:29:36 +0200 Subject: [PATCH 08/22] Fix tests --- platform/linux_platform_test.go | 20 ++++++++++--------- .../fakes/fake_default_network_resolver.go | 8 +++++--- 2 files changed, 16 insertions(+), 12 deletions(-) diff --git a/platform/linux_platform_test.go b/platform/linux_platform_test.go index d443bd8a6..54b6d9eb0 100644 --- a/platform/linux_platform_test.go +++ b/platform/linux_platform_test.go @@ -4136,15 +4136,17 @@ unit: sectors }) Describe("GetDefaultNetwork", func() { - It("delegates to the defaultNetworkResolver", func() { - defaultNetwork := boshsettings.Network{IP: "1.2.3.4"} - fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork - - network, err := platform.GetDefaultNetwork(true) - Expect(err).ToNot(HaveOccurred()) - - Expect(network).To(Equal(defaultNetwork)) - }) + for _, value := range []bool{true, false} { + title := fmt.Sprintf("delegates to the defaultNetworkResolver with input param %t", value) + It(title, func() { + defaultNetwork := boshsettings.Network{} + fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork + network, err := platform.GetDefaultNetwork(true) + Expect(err).ToNot(HaveOccurred()) + Expect(network).To(Equal(defaultNetwork)) + Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalledWith).To(Equal(true)) + }) + } }) Describe("GetHostPublicKey", func() { diff --git a/platform/net/fakes/fake_default_network_resolver.go b/platform/net/fakes/fake_default_network_resolver.go index d6fb7722b..1f9919310 100644 --- a/platform/net/fakes/fake_default_network_resolver.go +++ b/platform/net/fakes/fake_default_network_resolver.go @@ -5,12 +5,14 @@ import ( ) type FakeDefaultNetworkResolver struct { - GetDefaultNetworkNetwork boshsettings.Network - GetDefaultNetworkErr error - GetDefaultNetworkCalled bool + GetDefaultNetworkNetwork boshsettings.Network + GetDefaultNetworkErr error + GetDefaultNetworkCalled bool + GetDefaultNetworkCalledWith bool } func (r *FakeDefaultNetworkResolver) GetDefaultNetwork(isIpv6 bool) (boshsettings.Network, error) { r.GetDefaultNetworkCalled = true + r.GetDefaultNetworkCalledWith = isIpv6 return r.GetDefaultNetworkNetwork, r.GetDefaultNetworkErr } From 2255d0c036071e5b50037dcb00e009e8899e2fd1 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 08:27:40 +0200 Subject: [PATCH 09/22] Fix tests --- platform/net/ip/fakes/fake_ip_resolver.go | 15 ++++++------ platform/net/ip/interface_address_test.go | 4 ++-- platform/net/ip/ip_resolver.go | 20 +++++++--------- platform/net/ip/ip_resolver_test.go | 29 ++++++++++++++++------- platform/net/ubuntu_net_manager.go | 2 -- 5 files changed, 39 insertions(+), 31 deletions(-) diff --git a/platform/net/ip/fakes/fake_ip_resolver.go b/platform/net/ip/fakes/fake_ip_resolver.go index 937a7eeff..b8471a72f 100644 --- a/platform/net/ip/fakes/fake_ip_resolver.go +++ b/platform/net/ip/fakes/fake_ip_resolver.go @@ -7,19 +7,18 @@ import ( type FakeResolver struct { GetPrimaryIPv4InterfaceName string GetPrimaryIPv4IPNet *gonet.IPNet - GetPrimaryIPErr error GetPrimaryIPv4Err error + + GetPrimaryIPv6InterfaceName string + GetPrimaryIPv6IPNet *gonet.IPNet + GetPrimaryIPv6Err error } func (r *FakeResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) { r.GetPrimaryIPv4InterfaceName = interfaceName - if !is_ipv6 { - return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPv4Err + r.GetPrimaryIPv6InterfaceName = interfaceName + if is_ipv6 { + return r.GetPrimaryIPv6IPNet, r.GetPrimaryIPv6Err } - return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPErr -} - -func (r *FakeResolver) GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) { - r.GetPrimaryIPv4InterfaceName = interfaceName return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPv4Err } diff --git a/platform/net/ip/interface_address_test.go b/platform/net/ip/interface_address_test.go index 84b4405e8..25dc8af17 100644 --- a/platform/net/ip/interface_address_test.go +++ b/platform/net/ip/interface_address_test.go @@ -66,7 +66,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { }) It("resolves the IP and returns fully formatted IPv6", func() { - ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{ + ipResolver.GetPrimaryIPv6IPNet = &gonet.IPNet{ IP: gonet.ParseIP("ff00:f8::"), Mask: gonet.CIDRMask(64, 128), } @@ -75,7 +75,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000")) - Expect(ipResolver.GetPrimaryIPv4InterfaceName).To(Equal("fake-iface-name")) + Expect(ipResolver.GetPrimaryIPv6InterfaceName).To(Equal("fake-iface-name")) }) It("returns error if resolving IP fails", func() { diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index 285b50fba..e2d07a503 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -20,7 +20,7 @@ func NetworkInterfaceToAddrsFunc(interfaceName string) ([]gonet.Addr, error) { type Resolver interface { // GetPrimaryIP always returns error unless IPNet is found for given interface GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) - GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) + // GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) } type ipResolver struct { @@ -43,19 +43,21 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN for _, addr := range addrs { ip, ok := addr.(*gonet.IPNet) + if !ok { continue } - if is_ipv6 { - if ip.IP.To16() != nil || ip.IP.IsGlobalUnicast() { - return ip, nil - } - } else { - if ip.IP.To4() != nil || ip.IP.IsGlobalUnicast() { + if ip.IP.To16() != nil && is_ipv6 { + if ip.IP.IsGlobalUnicast() { return ip, nil } } + + if ip.IP.To4() != nil && !is_ipv6 { + return ip, nil + } + } ipVersion := 4 if is_ipv6 { @@ -64,7 +66,3 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN return nil, bosherr.Errorf("Failed to find primary address IPv%d for interface '%s'", ipVersion, interfaceName) } - -func (r ipResolver) GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) { - return r.GetPrimaryIP(interfaceName, false) -} diff --git a/platform/net/ip/ip_resolver_test.go b/platform/net/ip/ip_resolver_test.go index ee813d996..05f521448 100644 --- a/platform/net/ip/ip_resolver_test.go +++ b/platform/net/ip/ip_resolver_test.go @@ -29,7 +29,7 @@ var _ = Describe("ipResolver", func() { ipResolver = NewResolver(ifaceToAddrs) }) - Describe("GetPrimaryIPv4", func() { + Describe("GetPrimaryIP", func() { Context("when interface exists", func() { It("returns first ipv4 address from associated interface", func() { addrs = []gonet.Addr{ @@ -40,11 +40,24 @@ var _ = Describe("ipResolver", func() { &gonet.IPNet{IP: gonet.ParseIP("127.0.0.10"), Mask: gonet.CIDRMask(24, 32)}, } - ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") + ip, err := ipResolver.GetPrimaryIP("fake-iface-name", false) Expect(err).ToNot(HaveOccurred()) Expect(ip.String()).To(Equal("127.0.0.1/16")) }) + It("returns first non-local ipv4 address if available from associated interface", func() { + addrs = []gonet.Addr{ + NotIPNet{}, + &gonet.IPNet{IP: gonet.IPv6linklocalallrouters}, + &gonet.IPNet{IP: gonet.ParseIP("ff::"), Mask: gonet.CIDRMask(64, 128)}, + &gonet.IPNet{IP: gonet.ParseIP("10.0.0.1"), Mask: gonet.CIDRMask(16, 32)}, + } + + ip, err := ipResolver.GetPrimaryIP("fake-iface-name", false) + Expect(err).ToNot(HaveOccurred()) + Expect(ip.String()).To(Equal("10.0.0.1/16")) + }) + It("returns first non-local ipv6 address if available from associated interface", func() { addrs = []gonet.Addr{ NotIPNet{}, @@ -53,7 +66,7 @@ var _ = Describe("ipResolver", func() { &gonet.IPNet{IP: gonet.ParseIP("127.0.0.1"), Mask: gonet.CIDRMask(16, 32)}, } - ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") + ip, err := ipResolver.GetPrimaryIP("fake-iface-name", true) Expect(err).ToNot(HaveOccurred()) Expect(ip.String()).To(Equal("ff::/64")) }) @@ -61,7 +74,7 @@ var _ = Describe("ipResolver", func() { It("returns error if associated interface does not have any addresses", func() { addrs = []gonet.Addr{} - ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") + ip, err := ipResolver.GetPrimaryIP("fake-iface-name", false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("No addresses found for interface")) Expect(ip).To(BeNil()) @@ -70,16 +83,16 @@ var _ = Describe("ipResolver", func() { It("returns error if associated interface only has non-IPNet addresses", func() { addrs = []gonet.Addr{NotIPNet{}} - ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") + ip, err := ipResolver.GetPrimaryIP("fake-iface-name", true) Expect(err).To(HaveOccurred()) - Expect(err.Error()).To(ContainSubstring("Failed to find primary address IPv4 for interface 'fake-iface-name'")) + Expect(err.Error()).To(ContainSubstring("Failed to find primary address IPv6 for interface 'fake-iface-name'")) Expect(ip).To(BeNil()) }) It("returns error if associated interface only has ipv6 addresses", func() { addrs = []gonet.Addr{&gonet.IPNet{IP: gonet.IPv6linklocalallrouters}} - ip, err := ipResolver.GetPrimaryIPv4("fake-iface-name") + ip, err := ipResolver.GetPrimaryIP("fake-iface-name", false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to find primary address IPv4 for interface 'fake-iface-name'")) Expect(ip).To(BeNil()) @@ -90,7 +103,7 @@ var _ = Describe("ipResolver", func() { It("returns error", func() { funcError = errors.New("fake-network-func-error") - ip, err := ipResolver.GetPrimaryIPv4("whatever") + ip, err := ipResolver.GetPrimaryIP("whatever", false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-network-func-error")) Expect(err.Error()).To(ContainSubstring("Looking up addresses for interface")) diff --git a/platform/net/ubuntu_net_manager.go b/platform/net/ubuntu_net_manager.go index caf18f8ed..f259ac9ad 100644 --- a/platform/net/ubuntu_net_manager.go +++ b/platform/net/ubuntu_net_manager.go @@ -109,8 +109,6 @@ func (net UbuntuNetManager) SetupIPv6(config boshsettings.IPv6, stopCh <-chan st } func (net UbuntuNetManager) SetupNetworking(networks boshsettings.Networks, mbus string, errCh chan error) error { - _, _, _, err := net.cmdRunner.RunCommand("ip", "a") - if networks.IsPreconfigured() { // Note in this case IPs are not broadcast dnsNetwork, _ := networks.DefaultNetworkFor("dns") From 900335825025523a96c84f0621a8d0f5f90df0f9 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 10:42:58 +0200 Subject: [PATCH 10/22] Fix tests --- platform/net/ip/ip_resolver.go | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index e2d07a503..b7e80ccae 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -48,10 +48,8 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN continue } - if ip.IP.To16() != nil && is_ipv6 { - if ip.IP.IsGlobalUnicast() { - return ip, nil - } + if ip.IP.To16() != nil && ip.IP.IsGlobalUnicast() && is_ipv6 { + return ip, nil } if ip.IP.To4() != nil && !is_ipv6 { From d9c73876fb301f92dc3cbcee4cc0c6a7c9fdd342 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 11:05:25 +0200 Subject: [PATCH 11/22] Fix tests --- platform/net/ip/ip_resolver.go | 17 +++++++++++++++-- platform/net/ip/ip_resolver_test.go | 1 + 2 files changed, 16 insertions(+), 2 deletions(-) diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index b7e80ccae..df9cc736c 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -1,6 +1,7 @@ package ip import ( + "net" gonet "net" bosherr "github.com/cloudfoundry/bosh-utils/errors" @@ -41,6 +42,8 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN return nil, bosherr.Errorf("No addresses found for interface '%s'", interfaceName) } + var foundNonGlobalUniCast *net.IPNet + for _, addr := range addrs { ip, ok := addr.(*gonet.IPNet) @@ -53,14 +56,24 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN } if ip.IP.To4() != nil && !is_ipv6 { - return ip, nil + if ip.IP.IsGlobalUnicast() { + return ip, nil + } else { + if foundNonGlobalUniCast == nil { + foundNonGlobalUniCast = ip + } + } } - } + ipVersion := 4 if is_ipv6 { ipVersion = 6 } + if foundNonGlobalUniCast != nil { + return foundNonGlobalUniCast, nil + } + return nil, bosherr.Errorf("Failed to find primary address IPv%d for interface '%s'", ipVersion, interfaceName) } diff --git a/platform/net/ip/ip_resolver_test.go b/platform/net/ip/ip_resolver_test.go index 05f521448..46b8f6ccb 100644 --- a/platform/net/ip/ip_resolver_test.go +++ b/platform/net/ip/ip_resolver_test.go @@ -50,6 +50,7 @@ var _ = Describe("ipResolver", func() { NotIPNet{}, &gonet.IPNet{IP: gonet.IPv6linklocalallrouters}, &gonet.IPNet{IP: gonet.ParseIP("ff::"), Mask: gonet.CIDRMask(64, 128)}, + &gonet.IPNet{IP: gonet.ParseIP("127.0.0.1"), Mask: gonet.CIDRMask(16, 32)}, &gonet.IPNet{IP: gonet.ParseIP("10.0.0.1"), Mask: gonet.CIDRMask(16, 32)}, } From 7f0f405ea6250b44e4a41634db983cf88a2f4edc Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 11:09:57 +0200 Subject: [PATCH 12/22] Fix tests --- platform/net/default_network_resolver.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/platform/net/default_network_resolver.go b/platform/net/default_network_resolver.go index 0076361a6..a3218268e 100644 --- a/platform/net/default_network_resolver.go +++ b/platform/net/default_network_resolver.go @@ -53,10 +53,6 @@ func (r defaultNetworkResolver) GetDefaultNetwork(is_ipv6 bool) (boshsettings.Ne return network, bosherr.WrapErrorf(err, "Getting primary IPv%d for interface '%s'", ipVersion, route.InterfaceName) } - if ip == nil { - return network, bosherr.Errorf("Getting primary IPv%d for interface '%s'", ipVersion, route.InterfaceName) - } - return boshsettings.Network{ IP: ip.IP.String(), Netmask: gonet.IP(ip.Mask).String(), From 873c185e8607afb4fdfa1bf7b8141b7d68e6b5bb Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 11:30:50 +0200 Subject: [PATCH 13/22] Refactor tests --- platform/net/default_network_resolver_test.go | 4 ++-- platform/net/ip/fakes/fake_ip_resolver.go | 19 ++++++------------- platform/net/ip/interface_address_test.go | 16 ++++++++-------- 3 files changed, 16 insertions(+), 23 deletions(-) diff --git a/platform/net/default_network_resolver_test.go b/platform/net/default_network_resolver_test.go index 978758e76..f1b9e09ff 100644 --- a/platform/net/default_network_resolver_test.go +++ b/platform/net/default_network_resolver_test.go @@ -45,7 +45,7 @@ var _ = Describe("defaultNetworkResolver", func() { Context("when primary IPv4 exists for the found route", func() { BeforeEach(func() { - ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{ + ipResolver.GetPrimaryIPNet = &gonet.IPNet{ IP: gonet.ParseIP("127.0.0.1"), Mask: gonet.CIDRMask(16, 32), } @@ -64,7 +64,7 @@ var _ = Describe("defaultNetworkResolver", func() { Context("when primary IPv4 does not exist for the found route", func() { BeforeEach(func() { - ipResolver.GetPrimaryIPv4Err = errors.New("fake-get-primary-ipv4-err") + ipResolver.GetPrimaryIPErr = errors.New("fake-get-primary-ipv4-err") }) It("returns error", func() { diff --git a/platform/net/ip/fakes/fake_ip_resolver.go b/platform/net/ip/fakes/fake_ip_resolver.go index b8471a72f..fcc6cbea1 100644 --- a/platform/net/ip/fakes/fake_ip_resolver.go +++ b/platform/net/ip/fakes/fake_ip_resolver.go @@ -5,20 +5,13 @@ import ( ) type FakeResolver struct { - GetPrimaryIPv4InterfaceName string - GetPrimaryIPv4IPNet *gonet.IPNet - GetPrimaryIPv4Err error - - GetPrimaryIPv6InterfaceName string - GetPrimaryIPv6IPNet *gonet.IPNet - GetPrimaryIPv6Err error + GetPrimaryIPInterfaceName string + GetPrimaryIPNet *gonet.IPNet + GetPrimaryIPErr error } func (r *FakeResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) { - r.GetPrimaryIPv4InterfaceName = interfaceName - r.GetPrimaryIPv6InterfaceName = interfaceName - if is_ipv6 { - return r.GetPrimaryIPv6IPNet, r.GetPrimaryIPv6Err - } - return r.GetPrimaryIPv4IPNet, r.GetPrimaryIPv4Err + r.GetPrimaryIPInterfaceName = interfaceName + + return r.GetPrimaryIPNet, r.GetPrimaryIPErr } diff --git a/platform/net/ip/interface_address_test.go b/platform/net/ip/interface_address_test.go index 25dc8af17..687588223 100644 --- a/platform/net/ip/interface_address_test.go +++ b/platform/net/ip/interface_address_test.go @@ -51,7 +51,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { Describe("GetIP", func() { Context("when IP was not yet resolved", func() { BeforeEach(func() { - ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{ + ipResolver.GetPrimaryIPNet = &gonet.IPNet{ IP: gonet.ParseIP("127.0.0.1"), Mask: gonet.CIDRMask(16, 32), } @@ -62,11 +62,11 @@ var _ = Describe("resolvingInterfaceAddress", func() { Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("127.0.0.1")) - Expect(ipResolver.GetPrimaryIPv4InterfaceName).To(Equal("fake-iface-name")) + Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal("fake-iface-name")) }) It("resolves the IP and returns fully formatted IPv6", func() { - ipResolver.GetPrimaryIPv6IPNet = &gonet.IPNet{ + ipResolver.GetPrimaryIPNet = &gonet.IPNet{ IP: gonet.ParseIP("ff00:f8::"), Mask: gonet.CIDRMask(64, 128), } @@ -75,11 +75,11 @@ var _ = Describe("resolvingInterfaceAddress", func() { Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000")) - Expect(ipResolver.GetPrimaryIPv6InterfaceName).To(Equal("fake-iface-name")) + Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal("fake-iface-name")) }) It("returns error if resolving IP fails", func() { - ipResolver.GetPrimaryIPv4Err = errors.New("fake-get-primary-ipv4-err") + ipResolver.GetPrimaryIPErr = errors.New("fake-get-primary-ipv4-err") ip, err := interfaceAddress.GetIP(false) Expect(err).To(HaveOccurred()) @@ -90,7 +90,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { Context("when IP was already resolved", func() { BeforeEach(func() { - ipResolver.GetPrimaryIPv4IPNet = &gonet.IPNet{ + ipResolver.GetPrimaryIPNet = &gonet.IPNet{ IP: gonet.ParseIP("127.0.0.1"), Mask: gonet.CIDRMask(16, 32), } @@ -100,13 +100,13 @@ var _ = Describe("resolvingInterfaceAddress", func() { }) It("does not attempt to resolve IP again", func() { - ipResolver.GetPrimaryIPv4InterfaceName = "" + ipResolver.GetPrimaryIPInterfaceName = "" ip, err := interfaceAddress.GetIP(false) Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("127.0.0.1")) - Expect(ipResolver.GetPrimaryIPv4InterfaceName).To(Equal("")) + Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal("")) }) }) }) From 44289557f0ee58b189a23d4caa000e49cd843eb6 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 11:32:24 +0200 Subject: [PATCH 14/22] Refactor tests --- platform/net/default_network_resolver.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/platform/net/default_network_resolver.go b/platform/net/default_network_resolver.go index a3218268e..328e08e73 100644 --- a/platform/net/default_network_resolver.go +++ b/platform/net/default_network_resolver.go @@ -44,12 +44,11 @@ func (r defaultNetworkResolver) GetDefaultNetwork(is_ipv6 bool) (boshsettings.Ne ip, err := r.ipResolver.GetPrimaryIP(route.InterfaceName, is_ipv6) - ipVersion := 4 - if is_ipv6 { - ipVersion = 6 - } - if err != nil { + ipVersion := 4 + if is_ipv6 { + ipVersion = 6 + } return network, bosherr.WrapErrorf(err, "Getting primary IPv%d for interface '%s'", ipVersion, route.InterfaceName) } From db93ed35419a418a3704d28f240ecbacd9c283ec Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 11:56:30 +0200 Subject: [PATCH 15/22] Refactor tests --- platform/net/default_network_resolver_test.go | 6 ++--- platform/net/ip/fakes/fake_ip_resolver.go | 5 +++- platform/net/ip/interface_address_test.go | 23 ++++++++++++++++++- 3 files changed, 29 insertions(+), 5 deletions(-) diff --git a/platform/net/default_network_resolver_test.go b/platform/net/default_network_resolver_test.go index f1b9e09ff..e67988697 100644 --- a/platform/net/default_network_resolver_test.go +++ b/platform/net/default_network_resolver_test.go @@ -86,7 +86,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error", func() { - network, err := resolver.GetDefaultNetwork(true) + network, err := resolver.GetDefaultNetwork(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Failed to find default route")) Expect(network).To(Equal(boshsettings.Network{})) @@ -99,7 +99,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error if there are no routes", func() { - network, err := resolver.GetDefaultNetwork(true) + network, err := resolver.GetDefaultNetwork(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("No routes")) Expect(network).To(Equal(boshsettings.Network{})) @@ -112,7 +112,7 @@ var _ = Describe("defaultNetworkResolver", func() { }) It("returns error if searching routes fails", func() { - network, err := resolver.GetDefaultNetwork(true) + network, err := resolver.GetDefaultNetwork(false) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-search-routes-err")) Expect(network).To(Equal(boshsettings.Network{})) diff --git a/platform/net/ip/fakes/fake_ip_resolver.go b/platform/net/ip/fakes/fake_ip_resolver.go index fcc6cbea1..49d530867 100644 --- a/platform/net/ip/fakes/fake_ip_resolver.go +++ b/platform/net/ip/fakes/fake_ip_resolver.go @@ -1,6 +1,7 @@ package fakes import ( + "fmt" gonet "net" ) @@ -8,10 +9,12 @@ type FakeResolver struct { GetPrimaryIPInterfaceName string GetPrimaryIPNet *gonet.IPNet GetPrimaryIPErr error + GetPrimaryIPCalledWith []string } func (r *FakeResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) { r.GetPrimaryIPInterfaceName = interfaceName - + r.GetPrimaryIPCalledWith = append(r.GetPrimaryIPCalledWith, interfaceName) + r.GetPrimaryIPCalledWith = append(r.GetPrimaryIPCalledWith, fmt.Sprintf("%t", is_ipv6)) return r.GetPrimaryIPNet, r.GetPrimaryIPErr } diff --git a/platform/net/ip/interface_address_test.go b/platform/net/ip/interface_address_test.go index 687588223..e0e6e2bbe 100644 --- a/platform/net/ip/interface_address_test.go +++ b/platform/net/ip/interface_address_test.go @@ -2,6 +2,7 @@ package ip_test import ( "errors" + "fmt" gonet "net" . "github.com/onsi/ginkgo/v2" @@ -71,7 +72,7 @@ var _ = Describe("resolvingInterfaceAddress", func() { Mask: gonet.CIDRMask(64, 128), } - ip, err := interfaceAddress.GetIP(true) + ip, err := interfaceAddress.GetIP(false) Expect(err).ToNot(HaveOccurred()) Expect(ip).To(Equal("ff00:00f8:0000:0000:0000:0000:0000:0000")) @@ -109,5 +110,25 @@ var _ = Describe("resolvingInterfaceAddress", func() { Expect(ipResolver.GetPrimaryIPInterfaceName).To(Equal("")) }) }) + + Context("when GetIP was called with true or false", func() { + + BeforeEach(func() { + ipResolver.GetPrimaryIPNet = &gonet.IPNet{ + IP: gonet.ParseIP("127.0.0.1"), + Mask: gonet.CIDRMask(16, 32), + } + }) + + for _, value := range []bool{true, false} { + valueStr := fmt.Sprintf("%t", value) + It("it should have been called ipResolver with same value: "+valueStr, func() { + _, err := interfaceAddress.GetIP(value) + Expect(err).ToNot(HaveOccurred()) + Expect(ipResolver.GetPrimaryIPCalledWith).To(Equal([]string{"fake-iface-name", valueStr})) + }) + } + + }) }) }) From 53b9f30d9ccf323b4a30238d9b905429e30d3305 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Fri, 20 Jun 2025 12:03:03 +0200 Subject: [PATCH 16/22] Refactor tests --- platform/net/ip/ip_resolver.go | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index df9cc736c..7708521c2 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -1,7 +1,6 @@ package ip import ( - "net" gonet "net" bosherr "github.com/cloudfoundry/bosh-utils/errors" @@ -42,7 +41,7 @@ func (r ipResolver) GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPN return nil, bosherr.Errorf("No addresses found for interface '%s'", interfaceName) } - var foundNonGlobalUniCast *net.IPNet + var foundNonGlobalUniCast *gonet.IPNet for _, addr := range addrs { ip, ok := addr.(*gonet.IPNet) From f98c9f6fabaea79e97e1152e3383066ca6fdeb4a Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Mon, 23 Jun 2025 08:31:56 +0200 Subject: [PATCH 17/22] Refactor tests --- platform/net/default_network_resolver.go | 2 +- .../ip/interface_addresses_provider_test.go | 2 +- platform/net/routes_searcher_interface.go | 6 +++- .../net/routes_searcher_interface_test.go | 10 ++++-- platform/net/routes_searcher_unix.go | 20 +++++++---- platform/net/routes_searcher_unix_test.go | 36 ++++++++++++++++++- 6 files changed, 63 insertions(+), 13 deletions(-) diff --git a/platform/net/default_network_resolver.go b/platform/net/default_network_resolver.go index 328e08e73..966b9129e 100644 --- a/platform/net/default_network_resolver.go +++ b/platform/net/default_network_resolver.go @@ -38,7 +38,7 @@ func (r defaultNetworkResolver) GetDefaultNetwork(is_ipv6 bool) (boshsettings.Ne } for _, route := range routes { - if !route.IsDefault() { + if !route.IsDefault(is_ipv6) { continue } diff --git a/platform/net/ip/interface_addresses_provider_test.go b/platform/net/ip/interface_addresses_provider_test.go index 75920fbfa..8987018f2 100644 --- a/platform/net/ip/interface_addresses_provider_test.go +++ b/platform/net/ip/interface_addresses_provider_test.go @@ -22,7 +22,7 @@ var _ = Describe("InterfaceAddressesProvider", func() { var loopBackInterface InterfaceAddress for _, iface := range ifaces { - ip, err := iface.GetIP(true) + ip, err := iface.GetIP(false) Expect(err).ToNot(HaveOccurred()) if ip == "127.0.0.1" { diff --git a/platform/net/routes_searcher_interface.go b/platform/net/routes_searcher_interface.go index 53b33df5a..c34a73b7b 100644 --- a/platform/net/routes_searcher_interface.go +++ b/platform/net/routes_searcher_interface.go @@ -12,7 +12,11 @@ type RoutesSearcher interface { } const DefaultAddress = `0.0.0.0` +const DefaultAddressIpv6 = `::` -func (r Route) IsDefault() bool { +func (r Route) IsDefault(isIpv6 bool) bool { + if isIpv6 { + return r.Destination == DefaultAddressIpv6 + } return r.Destination == DefaultAddress } diff --git a/platform/net/routes_searcher_interface_test.go b/platform/net/routes_searcher_interface_test.go index 15b69682d..bfc0c7ff6 100644 --- a/platform/net/routes_searcher_interface_test.go +++ b/platform/net/routes_searcher_interface_test.go @@ -10,12 +10,16 @@ import ( var _ = Describe("Route", func() { Describe("IsDefault", func() { It("returns true if destination is 0.0.0.0", func() { - Expect(Route{Destination: "0.0.0.0"}.IsDefault()).To(BeTrue()) + Expect(Route{Destination: "0.0.0.0"}.IsDefault(false)).To(BeTrue()) + }) + + It("returns true if destination is ::", func() { + Expect(Route{Destination: "::"}.IsDefault(true)).To(BeTrue()) }) It("returns false if destination is not 0.0.0.0", func() { - Expect(Route{}.IsDefault()).To(BeFalse()) - Expect(Route{Destination: "1.1.1.1"}.IsDefault()).To(BeFalse()) + Expect(Route{}.IsDefault(false)).To(BeFalse()) + Expect(Route{Destination: "1.1.1.1"}.IsDefault(false)).To(BeFalse()) }) }) }) diff --git a/platform/net/routes_searcher_unix.go b/platform/net/routes_searcher_unix.go index ad427338b..eb77ab4ff 100644 --- a/platform/net/routes_searcher_unix.go +++ b/platform/net/routes_searcher_unix.go @@ -27,7 +27,7 @@ func NewRoutesSearcher(logger boshlog.Logger, runner boshsys.CmdRunner, _ Interf } func parseRoute(ipString string) (Route, error) { - var r = regexp.MustCompile(`(?P[a-z0-9.]+)(/[0-9]+)?( via (?P[0-9.]+))? dev (?P[a-z0-9]+)`) + var r = regexp.MustCompile(`(?P[a-z0-9.:]+)(/[0-9]+)?( via (?P[a-f0-9.:]+))? dev (?P[a-z0-9]+)`) match := r.FindStringSubmatch(ipString) if len(match) == 0 { @@ -37,14 +37,22 @@ func parseRoute(ipString string) (Route, error) { for i, name := range r.SubexpNames() { matches[name] = match[i] } - gateway := DefaultAddress - if len(matches["gateway"]) > 0 { - gateway = matches["gateway"] - } destination := matches["destination"] + gateway := matches["gateway"] + + defaultGateway := DefaultAddress + + if strings.Contains(destination, ":") || strings.Contains(gateway, ":") { + defaultGateway = DefaultAddressIpv6 + } + + if len(gateway) == 0 { + gateway = defaultGateway + } + if destination == "default" { - destination = DefaultAddress + destination = defaultGateway } return Route{ diff --git a/platform/net/routes_searcher_unix_test.go b/platform/net/routes_searcher_unix_test.go index 1170310d8..c2539b70c 100644 --- a/platform/net/routes_searcher_unix_test.go +++ b/platform/net/routes_searcher_unix_test.go @@ -65,9 +65,22 @@ blackhole 10.200.115.192/26 proto bird })) }) - It("ignores empty lines", func() { + It("ignores empty lines for ipv4", func() { runner.AddCmdResult("ip r", fakesys.FakeCmdResult{ Stdout: ` + +`, + }) + + routes, err := searcher.SearchRoutes(false) + Expect(err).ToNot(HaveOccurred()) + Expect(routes).To(BeEmpty()) + }) + + It("ignores empty lines for ipv6", func() { + runner.AddCmdResult("ip -6 r", fakesys.FakeCmdResult{ + Stdout: ` + `, }) @@ -75,6 +88,27 @@ blackhole 10.200.115.192/26 proto bird Expect(err).ToNot(HaveOccurred()) Expect(routes).To(BeEmpty()) }) + + It("returns parsed routes information for ipv6", func() { + runner.AddCmdResult("ip -6 r", fakesys.FakeCmdResult{ + Stdout: ` +::1 dev lo proto kernel metric 256 pref medium +2600:1f18:58fb:2009::/64 dev eth0 proto ra metric 1024 pref medium +fe80::/64 dev eth0 proto kernel metric 256 pref medium +default via fe80::ceb:d3ff:fef9:fa93 dev eth0 proto ra metric 1024 expires 1796sec pref medium +`, + }) + + routes, err := searcher.SearchRoutes(true) + Expect(err).ToNot(HaveOccurred()) + Expect(routes).To(Equal([]Route{ + Route{Destination: "::1", Gateway: "::", InterfaceName: "lo"}, + Route{Destination: "2600:1f18:58fb:2009::", Gateway: "::", InterfaceName: "eth0"}, + Route{Destination: "fe80::", Gateway: "::", InterfaceName: "eth0"}, + Route{Destination: "::", Gateway: "fe80::ceb:d3ff:fef9:fa93", InterfaceName: "eth0"}, + })) + }) + }) Context("when running ip command fails", func() { From 333409835d8308986ebbf38f174d7b8ebefb7fd2 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Mon, 23 Jun 2025 09:12:09 +0200 Subject: [PATCH 18/22] Refactor tests --- platform/linux_platform_test.go | 4 ++-- platform/net/ip/ip_resolver.go | 1 - platform/windows_platform_test.go | 20 +++++++++++--------- 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/platform/linux_platform_test.go b/platform/linux_platform_test.go index 54b6d9eb0..89002801c 100644 --- a/platform/linux_platform_test.go +++ b/platform/linux_platform_test.go @@ -4141,10 +4141,10 @@ unit: sectors It(title, func() { defaultNetwork := boshsettings.Network{} fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork - network, err := platform.GetDefaultNetwork(true) + network, err := platform.GetDefaultNetwork(value) Expect(err).ToNot(HaveOccurred()) Expect(network).To(Equal(defaultNetwork)) - Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalledWith).To(Equal(true)) + Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalledWith).To(Equal(value)) }) } }) diff --git a/platform/net/ip/ip_resolver.go b/platform/net/ip/ip_resolver.go index 7708521c2..e8a7f097c 100644 --- a/platform/net/ip/ip_resolver.go +++ b/platform/net/ip/ip_resolver.go @@ -20,7 +20,6 @@ func NetworkInterfaceToAddrsFunc(interfaceName string) ([]gonet.Addr, error) { type Resolver interface { // GetPrimaryIP always returns error unless IPNet is found for given interface GetPrimaryIP(interfaceName string, is_ipv6 bool) (*gonet.IPNet, error) - // GetPrimaryIPv4(interfaceName string) (*gonet.IPNet, error) } type ipResolver struct { diff --git a/platform/windows_platform_test.go b/platform/windows_platform_test.go index d3fec1017..69467d1b4 100644 --- a/platform/windows_platform_test.go +++ b/platform/windows_platform_test.go @@ -269,15 +269,17 @@ var _ = Describe("WindowsPlatform", func() { }) Describe("GetDefaultNetwork", func() { - It("delegates to the defaultNetworkResolver", func() { - defaultNetwork := boshsettings.Network{IP: "1.2.3.4"} - fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork - - network, err := platform.GetDefaultNetwork(false) - Expect(err).ToNot(HaveOccurred()) - - Expect(network).To(Equal(defaultNetwork)) - }) + for _, value := range []bool{true, false} { + title := fmt.Sprintf("delegates to the defaultNetworkResolver with input param %t", value) + It(title, func() { + defaultNetwork := boshsettings.Network{} + fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = defaultNetwork + network, err := platform.GetDefaultNetwork(value) + Expect(err).ToNot(HaveOccurred()) + Expect(network).To(Equal(defaultNetwork)) + Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalledWith).To(Equal(value)) + }) + } }) Describe("SetTimeWithNtpServers", func() { From 9afec62866b6f1bc5db0bac386efec84458c5147 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Mon, 23 Jun 2025 09:13:36 +0200 Subject: [PATCH 19/22] Refactor tests --- platform/net/routes_searcher_windows_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/platform/net/routes_searcher_windows_test.go b/platform/net/routes_searcher_windows_test.go index 046697137..c4b639cf4 100644 --- a/platform/net/routes_searcher_windows_test.go +++ b/platform/net/routes_searcher_windows_test.go @@ -41,11 +41,11 @@ var _ = Describe("Windows Route Searcher", func() { Expect(routes[0].InterfaceName).To(Equal("some-created-interface")) Expect(routes[0].Gateway).To(Equal("172.30.0.1")) - Expect(routes[0].IsDefault()).To(BeFalse()) + Expect(routes[0].IsDefault(false)).To(BeFalse()) Expect(routes[1].InterfaceName).To(Equal("some-default-interface")) Expect(routes[1].Gateway).To(Equal("10.0.16.1")) - Expect(routes[1].IsDefault()).To(BeTrue()) + Expect(routes[1].IsDefault(false)).To(BeTrue()) }) }) }) From c5e82caf36828fe2ac1da46199ea431f99bf012d Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Mon, 23 Jun 2025 13:23:46 +0200 Subject: [PATCH 20/22] Refactor tests --- platform/net/routes_searcher_windows_test.go | 22 ++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/platform/net/routes_searcher_windows_test.go b/platform/net/routes_searcher_windows_test.go index c4b639cf4..d7ab8edd1 100644 --- a/platform/net/routes_searcher_windows_test.go +++ b/platform/net/routes_searcher_windows_test.go @@ -47,5 +47,27 @@ var _ = Describe("Windows Route Searcher", func() { Expect(routes[1].Gateway).To(Equal("10.0.16.1")) Expect(routes[1].IsDefault(false)).To(BeTrue()) }) + + It("returns default and non-default routes for existing interfaces", func() { + interfaceManager.GetInterfacesInterfaces = []net.Interface{ + {Name: "some-created-interface", Gateway: "2600:1000::1"}, + {Name: "some-default-interface", Gateway: "10.0.16.1"}, + } + runner.AddCmdResult("(Get-NetRoute -DestinationPrefix '::/0').NextHop", fakesys.FakeCmdResult{ + Stdout: `2600:1000::1`, + }) + + routes, err := searcher.SearchRoutes(true) + Expect(err).NotTo(HaveOccurred()) + Expect(routes).To(HaveLen(2)) + + Expect(routes[0].InterfaceName).To(Equal("some-created-interface")) + Expect(routes[0].Gateway).To(Equal("2600:1000::1")) + Expect(routes[0].IsDefault(false)).To(BeTrue()) + + Expect(routes[1].InterfaceName).To(Equal("some-default-interface")) + Expect(routes[1].Gateway).To(Equal("10.0.16.1")) + Expect(routes[1].IsDefault(false)).To(BeFalse()) + }) }) }) From 52d1a219cfdbc5d102f84bc51bdcdd5752b6ae29 Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Mon, 23 Jun 2025 13:37:35 +0200 Subject: [PATCH 21/22] Refactor tests --- platform/net/routes_searcher_windows_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platform/net/routes_searcher_windows_test.go b/platform/net/routes_searcher_windows_test.go index d7ab8edd1..e728c5637 100644 --- a/platform/net/routes_searcher_windows_test.go +++ b/platform/net/routes_searcher_windows_test.go @@ -63,7 +63,7 @@ var _ = Describe("Windows Route Searcher", func() { Expect(routes[0].InterfaceName).To(Equal("some-created-interface")) Expect(routes[0].Gateway).To(Equal("2600:1000::1")) - Expect(routes[0].IsDefault(false)).To(BeTrue()) + Expect(routes[0].IsDefault(true)).To(BeTrue()) Expect(routes[1].InterfaceName).To(Equal("some-default-interface")) Expect(routes[1].Gateway).To(Equal("10.0.16.1")) From 57f784372a6b6b3a100ae7aa177ce39b068d68dd Mon Sep 17 00:00:00 2001 From: Dennis Ahaus Date: Mon, 23 Jun 2025 13:49:11 +0200 Subject: [PATCH 22/22] Refactor tests --- platform/net/routes_searcher_windows.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/platform/net/routes_searcher_windows.go b/platform/net/routes_searcher_windows.go index 352579988..6519728d6 100644 --- a/platform/net/routes_searcher_windows.go +++ b/platform/net/routes_searcher_windows.go @@ -45,7 +45,7 @@ func (s windowsRoutesSearcher) SearchRoutes(ipv6 bool) ([]Route, error) { } if fs.Gateway == defaultGateway { if ipv6 { - route.Destination = "::/0" // Default route for IPv6 + route.Destination = "::" // Default route for IPv6 } else { route.Destination = "0.0.0.0" // Default route for IPv4 }