9559673574

Committed 18 Jun 2024 05:47AM UTC coverage: 52.682% (-0.06%) from 52.742%

Build # 9559673574

Build Type

Pull #4433

github

Committed by

qinqon

Commit Message

node: Use mdlayher/arp at link_network_manager

Signed-off-by: Enrique Llorente <ellorent@redhat.com>

Pull Request Pull Request #4433: node: Use mdlayher/arp at link_network_manager

Run Details

6 of 74 new or added lines in 2 files covered. (8.11%)

9 existing lines in 5 files now uncovered.

28714 of 54504 relevant lines covered (52.68%)

100.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

78.92

/go-controller/pkg/ovn/hybrid.go

package ovn

import (
        "errors"
        "fmt"
        "net"
        "strings"
        "sync/atomic"

        libovsdbclient "github.com/ovn-org/libovsdb/client"
        "github.com/ovn-org/ovn-kubernetes/go-controller/hybrid-overlay/pkg/types"
        hotypes "github.com/ovn-org/ovn-kubernetes/go-controller/hybrid-overlay/pkg/types"
        houtil "github.com/ovn-org/ovn-kubernetes/go-controller/hybrid-overlay/pkg/util"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/config"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/kube"
        libovsdbops "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/ops"
        libovsdbutil "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/util"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/nbdb"

        ovntypes "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/types"
        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"

        kapi "k8s.io/api/core/v1"
        "k8s.io/klog/v2"
        utilnet "k8s.io/utils/net"
)

const (
        hybridCidrClusterKey = "cluster"
)

// handleHybridOverlayPort reconciles the node's overlay port with OVN.
// It needs to handle the following cases:
//   - no subnet allocated: unset MAC annotation
//   - no MAC annotation, no lsp: configure lsp, set annotation
//   - annotation, no lsp: configure lsp
//   - annotation, lsp: ensure lsp matches annotation
//   - no annotation, lsp: set annotation from lsp
func (oc *DefaultNetworkController) handleHybridOverlayPort(node *kapi.Node, annotator kube.Annotator) error {
        var err error
        var annotationMAC, portMAC net.HardwareAddr
        var drIP net.IP
        portName := util.GetHybridOverlayPortName(node.Name)

        // retrieve mac annotation
        am, annotationOK := node.Annotations[types.HybridOverlayDRMAC]
        if annotationOK {
                annotationMAC, err = net.ParseMAC(am)
                if err != nil {
                        klog.Errorf("MAC annotation %s on node %s is invalid, ignoring.", annotationMAC, node.Name)
                        annotationOK = false
                }
        }

        // no subnet allocated? unset mac annotation, be done.
        subnets, err := util.ParseNodeHostSubnetAnnotation(node, ovntypes.DefaultNetworkName)
        if subnets == nil || err != nil {
                // No subnet allocated yet; clean up
                klog.V(5).Infof("No subnet allocation yet for %s", node.Name)
                if annotationOK {
                        if err := oc.deleteHybridOverlayPort(node); err != nil {
                                return err
                        }
                        annotator.Delete(types.HybridOverlayDRMAC)
                }
                return nil
        }

        // Retrieve port MAC address; if the port isn't set up, portMAC will be nil
        lsp := &nbdb.LogicalSwitchPort{Name: portName}
        lsp, err = libovsdbops.GetLogicalSwitchPort(oc.nbClient, lsp)
        if err == nil {
                portMAC, _, _ = libovsdbutil.ExtractPortAddresses(lsp)
        }

        // compare port configuration to annotation MAC, reconcile as needed
        lspOK := false

        if drIP = net.ParseIP(node.Annotations[hotypes.HybridOverlayDRIP]); drIP == nil {
                return fmt.Errorf("cannot set up hybrid overlay ports, distributed router ip is nil")
        }
        // nothing allocated, allocate mac from HybridOverlayDRIP
        if portMAC == nil && annotationMAC == nil {
                portMAC = util.IPAddrToHWAddr(drIP)
                annotationMAC = portMAC
                klog.V(5).Infof("Allocating MAC %s to node %s", portMAC.String(), node.Name)
        } else if portMAC == nil && annotationMAC != nil { // annotation, no port
                portMAC = annotationMAC
        } else if portMAC != nil && annotationMAC == nil { // port, no annotation
                lspOK = true
                annotationMAC = portMAC
        } else if portMAC != nil && annotationMAC != nil { // port & annotation: anno wins
                if portMAC.String() != annotationMAC.String() {
                        klog.V(2).Infof("Warning: node %s lsp %s has mismatching hybrid port mac, correcting", node.Name, portName)
                        portMAC = annotationMAC
                } else {
                        lspOK = true
                }
        }

        // we need to setup a reroute policy for hybrid overlay subnet
        // this is so hybrid pod -> service -> hybrid endpoint will reroute to the DR IP
        if err := oc.setupHybridLRPolicySharedGw(subnets, node.Name, portMAC, drIP); err != nil {
                return fmt.Errorf("unable to setup Hybrid Subnet Logical Route Policy for node: %s, error: %w",
                        node.Name, err)
        }

        if !lspOK {
                klog.Infof("Creating / updating node %s hybrid overlay port with mac %s", node.Name, portMAC.String())

                // create / update lsps
                lsp := nbdb.LogicalSwitchPort{
                        Name:      portName,
                        Addresses: []string{portMAC.String()},
                }
                sw := nbdb.LogicalSwitch{Name: node.Name}

                err := libovsdbops.CreateOrUpdateLogicalSwitchPortsOnSwitch(oc.nbClient, &sw, &lsp)
                if err != nil {
                        return fmt.Errorf("failed to add hybrid overlay port %+v for node %s: %w", lsp, node.Name, err)
                }
                for _, subnet := range subnets {
                        if err := libovsdbutil.UpdateNodeSwitchExcludeIPs(oc.nbClient, node.Name, subnet); err != nil {
                                return err
                        }
                }
        }

        if !annotationOK {
                klog.Infof("Setting node %s hybrid overlay mac annotation to %s", node.Name, annotationMAC.String())
                if err := annotator.Set(types.HybridOverlayDRMAC, portMAC.String()); err != nil {
                        return fmt.Errorf("failed to set node %s hybrid overlay DRMAC annotation: %v", node.Name, err)
                }
        }

        return nil
}

func (oc *DefaultNetworkController) deleteHybridOverlayPort(node *kapi.Node) error {
        klog.Infof("Removing node %s hybrid overlay port", node.Name)
        portName := util.GetHybridOverlayPortName(node.Name)
        lsp := nbdb.LogicalSwitchPort{Name: portName}
        sw := nbdb.LogicalSwitch{Name: node.Name}
        if err := libovsdbops.DeleteLogicalSwitchPorts(oc.nbClient, &sw, &lsp); err != nil {
                return err
        }
        if err := oc.removeHybridLRPolicySharedGW(node); err != nil {
                return err
        }
        return nil
}

func (oc *DefaultNetworkController) setupHybridLRPolicySharedGw(nodeSubnets []*net.IPNet, nodeName string, portMac net.HardwareAddr, drIPs net.IP) error {
        klog.Infof("Setting up logical route policy for hybrid subnet on node: %s", nodeName)
        var L3Prefix string
        for _, nodeSubnet := range nodeSubnets {
                if utilnet.IsIPv6CIDR(nodeSubnet) {
                        L3Prefix = "ip6"
                } else {
                        L3Prefix = "ip4"
                }
                hybridCIDRs := map[string]*net.IPNet{}
                if len(config.HybridOverlay.ClusterSubnets) > 0 {
                        for _, hybridSubnet := range config.HybridOverlay.ClusterSubnets {
                                if utilnet.IsIPv6CIDR(hybridSubnet.CIDR) == utilnet.IsIPv6CIDR(nodeSubnet) {
                                        hybridCIDRs[hybridCidrClusterKey] = hybridSubnet.CIDR
                                        break
                                }
                        }
                } else {
                        // In cases of OpenShift SDN live migration, where config.HybridOverlay.ClusterSubnets is not provided, we
                        // use the host subnets allocated by OpenShiftSDN as the hybrid-overlay-node-subnet and set up hybrid
                        // overlay routes/policies to these subnets.
                        nodes, err := oc.kube.GetNodes()
                        if err != nil {
                                return err
                        }
                        for _, node := range nodes {
                                node := *node
                                if util.NoHostSubnet(&node) {
                                        if subnet, _ := houtil.ParseHybridOverlayHostSubnet(&node); subnet != nil {
                                                hybridCIDRs[node.Name] = subnet
                                        }
                                }
                        }
                }

                for hoNodeName, hybridCIDR := range hybridCIDRs {
                        if utilnet.IsIPv6CIDR(hybridCIDR) != utilnet.IsIPv6CIDR(nodeSubnet) {
                                // skip if the IP family is not match
                                continue
                        }
                        drIP := drIPs
                        matchStr := fmt.Sprintf(`inport == "%s%s" && %s.dst == %s`,
                                ovntypes.RouterToSwitchPrefix, nodeName, L3Prefix, hybridCIDR)

                        name := ovntypes.HybridSubnetPrefix + nodeName + ":" + hoNodeName
                        if hoNodeName == hybridCidrClusterKey {
                                name = ovntypes.HybridSubnetPrefix + nodeName
                        }
                        // Logic route policy to steer packet from pod to hybrid overlay nodes
                        logicalRouterPolicy := nbdb.LogicalRouterPolicy{
                                Priority: ovntypes.HybridOverlaySubnetPriority,
                                ExternalIDs: map[string]string{
                                        "name": name,
                                },
                                Action:   nbdb.LogicalRouterPolicyActionReroute,
                                Nexthops: []string{drIP.String()},
                                Match:    matchStr,
                        }

                        if err := libovsdbops.CreateOrUpdateLogicalRouterPolicyWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, &logicalRouterPolicy, func(item *nbdb.LogicalRouterPolicy) bool {
                                return item.Priority == logicalRouterPolicy.Priority &&
                                        item.ExternalIDs["name"] == logicalRouterPolicy.ExternalIDs["name"]
                        }, &logicalRouterPolicy.Nexthops, &logicalRouterPolicy.Match, &logicalRouterPolicy.Action); err != nil {
                                return fmt.Errorf("failed to add policy route '%s' for host %q on %s , error: %w", matchStr, nodeName, ovntypes.OVNClusterRouter, err)
                        }

                        smb := &nbdb.StaticMACBinding{
                                LogicalPort:        ovntypes.RouterToSwitchPrefix + nodeName,
                                MAC:                portMac.String(),
                                IP:                 drIP.String(),
                                OverrideDynamicMAC: true,
                        }
                        if err := libovsdbops.CreateOrUpdateStaticMacBinding(oc.nbClient, smb); err != nil {
                                return fmt.Errorf("failed to create MAC Binding for hybrid overlay: %v", err)
                        }

                        // Logic route policy to steer packet from external to nodePort service backed by non-ovnkube pods to hybrid overlay nodes
                        gwLRPIfAddrs, err := libovsdbutil.GetLRPAddrs(oc.nbClient, ovntypes.GWRouterToJoinSwitchPrefix+ovntypes.GWRouterPrefix+nodeName)
                        if err != nil {
                                return err
                        }
                        gwLRPIfAddr, err := util.MatchFirstIPNetFamily(utilnet.IsIPv6CIDR(hybridCIDR), gwLRPIfAddrs)
                        if err != nil {
                                return err
                        }
                        grMatchStr := fmt.Sprintf(`%s.src == %s && %s.dst == %s`,
                                L3Prefix, gwLRPIfAddr.IP.String(), L3Prefix, hybridCIDR)
                        grLogicalRouterPolicy := nbdb.LogicalRouterPolicy{
                                Priority: ovntypes.HybridOverlaySubnetPriority,
                                ExternalIDs: map[string]string{
                                        "name": ovntypes.HybridSubnetPrefix + nodeName + ovntypes.HybridOverlayGRSubfix,
                                },
                                Action:   nbdb.LogicalRouterPolicyActionReroute,
                                Nexthops: []string{drIP.String()},
                                Match:    grMatchStr,
                        }

                        if err := libovsdbops.CreateOrUpdateLogicalRouterPolicyWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, &grLogicalRouterPolicy, func(item *nbdb.LogicalRouterPolicy) bool {
                                return item.Priority == grLogicalRouterPolicy.Priority &&
                                        item.ExternalIDs["name"] == grLogicalRouterPolicy.ExternalIDs["name"]
                        }, &grLogicalRouterPolicy.Nexthops, &grLogicalRouterPolicy.Match, &grLogicalRouterPolicy.Action); err != nil {
                                return fmt.Errorf("failed to add policy route '%s' for host %q on %s , error: %w", matchStr, nodeName, ovntypes.OVNClusterRouter, err)
                        }
                        klog.Infof("Created hybrid overlay logical route policies for node %s", nodeName)

                        // Static route to steer packets from external to nodePort service backed by pods on hybrid overlay node.
                        // This route is to used for triggering above route policy
                        clusterRouterStaticRoutes := nbdb.LogicalRouterStaticRoute{
                                IPPrefix: hybridCIDR.String(),
                                Nexthop:  drIP.String(),
                                ExternalIDs: map[string]string{
                                        "name": name,
                                },
                        }
                        if err := libovsdbops.CreateOrReplaceLogicalRouterStaticRouteWithPredicate(oc.nbClient,
                                ovntypes.OVNClusterRouter, &clusterRouterStaticRoutes,
                                func(item *nbdb.LogicalRouterStaticRoute) bool {
                                        return item.IPPrefix == clusterRouterStaticRoutes.IPPrefix &&
                                                item.ExternalIDs["name"] == clusterRouterStaticRoutes.ExternalIDs["name"] &&
                                                libovsdbops.PolicyEqualPredicate(clusterRouterStaticRoutes.Policy, item.Policy)
                                }, &clusterRouterStaticRoutes.Nexthop); err != nil {
                                return fmt.Errorf("failed to add policy route static '%s %s' for on %s , error: %w",
                                        clusterRouterStaticRoutes.IPPrefix, clusterRouterStaticRoutes.Nexthop,
                                        ovntypes.GWRouterPrefix+nodeName, err)
                        }
                        klog.Infof("Created hybrid overlay logical route static route at cluster router for node %s", nodeName)

                        // Static route to steer packets from external to nodePort service backed by pods on hybrid overlay node to cluster router.
                        drLRPIfAddrs, err := libovsdbutil.GetLRPAddrs(oc.nbClient, ovntypes.GWRouterToJoinSwitchPrefix+ovntypes.OVNClusterRouter)
                        if err != nil {
                                return err
                        }
                        drLRPIfAddr, err := util.MatchFirstIPNetFamily(utilnet.IsIPv6CIDR(hybridCIDR), drLRPIfAddrs)
                        if err != nil {
                                return fmt.Errorf("failed to match cluster router join interface IPs: %v, err: %v", drLRPIfAddr, err)
                        }
                        nodeGWRouterStaticRoutes := nbdb.LogicalRouterStaticRoute{
                                IPPrefix: hybridCIDR.String(),
                                Nexthop:  drLRPIfAddr.IP.String(),
                                ExternalIDs: map[string]string{
                                        "name": ovntypes.HybridSubnetPrefix + nodeName + ovntypes.HybridOverlayGRSubfix,
                                },
                        }
                        if err := libovsdbops.CreateOrReplaceLogicalRouterStaticRouteWithPredicate(oc.nbClient,
                                ovntypes.GWRouterPrefix+nodeName, &nodeGWRouterStaticRoutes,
                                func(item *nbdb.LogicalRouterStaticRoute) bool {
                                        return item.IPPrefix == nodeGWRouterStaticRoutes.IPPrefix &&
                                                item.ExternalIDs["name"] == nodeGWRouterStaticRoutes.ExternalIDs["name"] &&
                                                libovsdbops.PolicyEqualPredicate(nodeGWRouterStaticRoutes.Policy, item.Policy)
                                }, &nodeGWRouterStaticRoutes.Nexthop); err != nil {
                                return fmt.Errorf("failed to add policy route static '%s %s' for on %s , error: %w",
                                        nodeGWRouterStaticRoutes.IPPrefix, nodeGWRouterStaticRoutes.Nexthop,
                                        ovntypes.GWRouterPrefix+nodeName, err)
                        }
                        klog.Infof("Created hybrid overlay logical route static route at gateway router for node %s", nodeName)
                }
        }
        return nil
}

func (oc *DefaultNetworkController) removeHybridLRPolicySharedGW(node *kapi.Node) error {
        nodeName := node.Name
        name := ovntypes.HybridSubnetPrefix + nodeName

        if err := libovsdbops.DeleteLogicalRouterPoliciesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterPolicy) bool {
                return strings.Contains(item.ExternalIDs["name"], name)
        }); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {
                return fmt.Errorf("failed to delete policy %s from %s, error: %w", name, ovntypes.OVNClusterRouter, err)
        }

        // order is important here to not incur referential integrity violation
        // first remove GR routes with a specific predicate, then remove the
        // remaining ones from cluster router with a generic predicate
        if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.GWRouterPrefix+nodeName, func(item *nbdb.LogicalRouterStaticRoute) bool {
                return item.ExternalIDs["name"] == name+ovntypes.HybridOverlayGRSubfix
        }); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {
                return fmt.Errorf("failed to delete static route %s from %s, error: %w", name+"gr", ovntypes.GWRouterPrefix+nodeName, err)
        }
        if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterStaticRoute) bool {
                return strings.Contains(item.ExternalIDs["name"], name)
        }); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {
                return fmt.Errorf("failed to delete static route %s from %s, error: %w", name, ovntypes.OVNClusterRouter, err)
        }

        if node.Annotations[hotypes.HybridOverlayDRIP] != "" {
                smb := &nbdb.StaticMACBinding{
                        IP:          node.Annotations[hotypes.HybridOverlayDRIP],
                        LogicalPort: ovntypes.RouterToSwitchPrefix + nodeName,
                }
                err := libovsdbops.DeleteStaticMacBindings(oc.nbClient, smb)
                if err != nil {
                        return fmt.Errorf("failed to delete static mac binding %+v: %v", smb, err)
                }
        }

        return nil
}

// takes the node name and allocates the hybrid overlay distributed router ip address
func (oc *DefaultNetworkController) allocateHybridOverlayDRIP(node *kapi.Node) error {
        if atomic.LoadUint32(&oc.allInitialPodsProcessed) == 0 {
                return fmt.Errorf("cannot allocate hybrid overlay distributed router ip for nodes until all initial pods are processed")
        }

        var ips []string
        // check if there is a hybrid distributed router IP set as an annotation
        nodeHybridOverlayDRIP := node.Annotations[hotypes.HybridOverlayDRIP]
        if len(nodeHybridOverlayDRIP) > 0 {
                ips = strings.Split(nodeHybridOverlayDRIP, ",")
        }

        allocatedHybridOverlayDRIPs, err := oc.lsManager.AllocateHybridOverlay(node.Name, ips)
        if err != nil {
                return fmt.Errorf("cannot allocate hybrid overlay interface addresses on node %s: %v", node.Name, err)
        }

        var sliceHybridOverlayDRIP []string
        for _, ip := range allocatedHybridOverlayDRIPs {
                sliceHybridOverlayDRIP = append(sliceHybridOverlayDRIP, ip.IP.String())
        }

        err = oc.kube.SetAnnotationsOnNode(node.Name, map[string]interface{}{hotypes.HybridOverlayDRIP: strings.Join(sliceHybridOverlayDRIP, ",")})
        if err != nil {
                return fmt.Errorf("cannot set hybrid annotation on node %s: %v", node.Name, err)
        }

        return nil
}

func (oc *DefaultNetworkController) removeRoutesToHONodeSubnet(nodeSubnet *net.IPNet) error {
        klog.Infof("Delete hybrid overlay policy and static routes to %s", nodeSubnet.String())

        // Delete policy to HO subnet from the cluster router
        if err := libovsdbops.DeleteLogicalRouterPoliciesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterPolicy) bool {
                return strings.Contains(item.Match, nodeSubnet.String())
        }); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {
                return fmt.Errorf("failed to delete policy route to %s from %s, error: %w", nodeSubnet, ovntypes.OVNClusterRouter, err)
        }

        // Delete routes to HO subnet from the cluster router
        if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterStaticRoute) bool {
                name, ok := item.ExternalIDs["name"]
                if !ok {
                        return false
                }
                if !strings.Contains(name, ovntypes.HybridSubnetPrefix) || strings.Contains(name, ovntypes.HybridOverlayGRSubfix) {
                        return false
                }
                return item.IPPrefix == nodeSubnet.String() && item.Policy == nil
        }); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {
                return fmt.Errorf("failed to delete static route to %s from %s, error: %w", nodeSubnet, ovntypes.OVNClusterRouter, err)
        }

        // Delete routes to HO subnet from GRs
        nodes, err := oc.kube.GetNodes()
        if err != nil {
                return err
        }
        for _, node := range nodes {
                node := *node
                // Check existence of Gateway Router before removing the static route from it.
                if _, err := libovsdbops.GetLogicalRouter(oc.nbClient, &nbdb.LogicalRouter{Name: ovntypes.GWRouterPrefix + node.Name}); err != nil {
                        if err == libovsdbclient.ErrNotFound {
                                continue
                        }
                        return fmt.Errorf("failed to get logical router %s, error: %w", ovntypes.GWRouterPrefix+node.Name, err)
                }
                if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.GWRouterPrefix+node.Name, func(item *nbdb.LogicalRouterStaticRoute) bool {
                        name, ok := item.ExternalIDs["name"]
                        if !ok {
                                return false
                        }
                        if name != ovntypes.HybridSubnetPrefix+node.Name+ovntypes.HybridOverlayGRSubfix {
                                return false
                        }
                        return item.IPPrefix == nodeSubnet.String() && item.Policy == nil
                }); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {
                        return fmt.Errorf("failed to delete static route to %s from %s, error: %w", nodeSubnet, ovntypes.GWRouterPrefix+node.Name, err)
                }
        }
        return nil
}

1	package ovn
2
3	import (
4	"errors"
5	"fmt"
6	"net"
7	"strings"
8	"sync/atomic"
9
10	libovsdbclient "github.com/ovn-org/libovsdb/client"
11	"github.com/ovn-org/ovn-kubernetes/go-controller/hybrid-overlay/pkg/types"
12	hotypes "github.com/ovn-org/ovn-kubernetes/go-controller/hybrid-overlay/pkg/types"
13	houtil "github.com/ovn-org/ovn-kubernetes/go-controller/hybrid-overlay/pkg/util"
14	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/config"
15	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/kube"
16	libovsdbops "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/ops"
17	libovsdbutil "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/libovsdb/util"
18	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/nbdb"
19
20	ovntypes "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/types"
21	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/util"
22
23	kapi "k8s.io/api/core/v1"
24	"k8s.io/klog/v2"
25	utilnet "k8s.io/utils/net"
26	)
27
28	const (
29	hybridCidrClusterKey = "cluster"
30	)
31
32	// handleHybridOverlayPort reconciles the node's overlay port with OVN.
33	// It needs to handle the following cases:
34	// - no subnet allocated: unset MAC annotation
35	// - no MAC annotation, no lsp: configure lsp, set annotation
36	// - annotation, no lsp: configure lsp
37	// - annotation, lsp: ensure lsp matches annotation
38	// - no annotation, lsp: set annotation from lsp
39	func (oc DefaultNetworkController) handleHybridOverlayPort(node kapi.Node, annotator kube.Annotator) error {	39✔
40	var err error	39✔
41	var annotationMAC, portMAC net.HardwareAddr	39✔
42	var drIP net.IP	39✔
43	portName := util.GetHybridOverlayPortName(node.Name)	39✔
44		39✔
45	// retrieve mac annotation	39✔
46	am, annotationOK := node.Annotations[types.HybridOverlayDRMAC]	39✔
47	if annotationOK {	60✔
48	annotationMAC, err = net.ParseMAC(am)	21✔
49	if err != nil {	21✔
50	klog.Errorf("MAC annotation %s on node %s is invalid, ignoring.", annotationMAC, node.Name)	×
51	annotationOK = false	×
52	}	×
53	}
54
55	// no subnet allocated? unset mac annotation, be done.
56	subnets, err := util.ParseNodeHostSubnetAnnotation(node, ovntypes.DefaultNetworkName)	39✔
57	if subnets == nil \|\| err != nil {	42✔
58	// No subnet allocated yet; clean up	3✔
59	klog.V(5).Infof("No subnet allocation yet for %s", node.Name)	3✔
60	if annotationOK {	5✔
61	if err := oc.deleteHybridOverlayPort(node); err != nil {	2✔
62	return err	×
63	}	×
64	annotator.Delete(types.HybridOverlayDRMAC)	2✔
65	}
66	return nil	3✔
67	}
68
69	// Retrieve port MAC address; if the port isn't set up, portMAC will be nil
70	lsp := &nbdb.LogicalSwitchPort{Name: portName}	36✔
71	lsp, err = libovsdbops.GetLogicalSwitchPort(oc.nbClient, lsp)	36✔
72	if err == nil {	54✔
73	portMAC, _, _ = libovsdbutil.ExtractPortAddresses(lsp)	18✔
74	}	18✔
75
76	// compare port configuration to annotation MAC, reconcile as needed
77	lspOK := false	36✔
78		36✔
79	if drIP = net.ParseIP(node.Annotations[hotypes.HybridOverlayDRIP]); drIP == nil {	48✔
80	return fmt.Errorf("cannot set up hybrid overlay ports, distributed router ip is nil")	12✔
81	}	12✔
82	// nothing allocated, allocate mac from HybridOverlayDRIP
83	if portMAC == nil && annotationMAC == nil {	31✔
84	portMAC = util.IPAddrToHWAddr(drIP)	7✔
85	annotationMAC = portMAC	7✔
86	klog.V(5).Infof("Allocating MAC %s to node %s", portMAC.String(), node.Name)	7✔
87	} else if portMAC == nil && annotationMAC != nil { // annotation, no port	24✔
88	portMAC = annotationMAC	×
89	} else if portMAC != nil && annotationMAC == nil { // port, no annotation	18✔
90	lspOK = true	1✔
91	annotationMAC = portMAC	1✔
92	} else if portMAC != nil && annotationMAC != nil { // port & annotation: anno wins	33✔
93	if portMAC.String() != annotationMAC.String() {	16✔
94	klog.V(2).Infof("Warning: node %s lsp %s has mismatching hybrid port mac, correcting", node.Name, portName)	×
95	portMAC = annotationMAC	×
96	} else {	16✔
97	lspOK = true	16✔
98	}	16✔
99	}
100
101	// we need to setup a reroute policy for hybrid overlay subnet
102	// this is so hybrid pod -> service -> hybrid endpoint will reroute to the DR IP
103	if err := oc.setupHybridLRPolicySharedGw(subnets, node.Name, portMAC, drIP); err != nil {	25✔
104	return fmt.Errorf("unable to setup Hybrid Subnet Logical Route Policy for node: %s, error: %w",	1✔
105	node.Name, err)	1✔
106	}	1✔
107
108	if !lspOK {	29✔
109	klog.Infof("Creating / updating node %s hybrid overlay port with mac %s", node.Name, portMAC.String())	6✔
110		6✔
111	// create / update lsps	6✔
112	lsp := nbdb.LogicalSwitchPort{	6✔
113	Name: portName,	6✔
114	Addresses: []string{portMAC.String()},	6✔
115	}	6✔
116	sw := nbdb.LogicalSwitch{Name: node.Name}	6✔
117		6✔
118	err := libovsdbops.CreateOrUpdateLogicalSwitchPortsOnSwitch(oc.nbClient, &sw, &lsp)	6✔
119	if err != nil {	6✔
120	return fmt.Errorf("failed to add hybrid overlay port %+v for node %s: %w", lsp, node.Name, err)	×
121	}	×
122	for _, subnet := range subnets {	12✔
123	if err := libovsdbutil.UpdateNodeSwitchExcludeIPs(oc.nbClient, node.Name, subnet); err != nil {	6✔
124	return err	×
125	}	×
126	}
127	}
128
129	if !annotationOK {	30✔
130	klog.Infof("Setting node %s hybrid overlay mac annotation to %s", node.Name, annotationMAC.String())	7✔
131	if err := annotator.Set(types.HybridOverlayDRMAC, portMAC.String()); err != nil {	7✔
132	return fmt.Errorf("failed to set node %s hybrid overlay DRMAC annotation: %v", node.Name, err)	×
133	}	×
134	}
135
136	return nil	23✔
137	}
138
139	func (oc DefaultNetworkController) deleteHybridOverlayPort(node kapi.Node) error {	28✔
140	klog.Infof("Removing node %s hybrid overlay port", node.Name)	28✔
141	portName := util.GetHybridOverlayPortName(node.Name)	28✔
142	lsp := nbdb.LogicalSwitchPort{Name: portName}	28✔
143	sw := nbdb.LogicalSwitch{Name: node.Name}	28✔
144	if err := libovsdbops.DeleteLogicalSwitchPorts(oc.nbClient, &sw, &lsp); err != nil {	28✔
145	return err	×
146	}	×
147	if err := oc.removeHybridLRPolicySharedGW(node); err != nil {	28✔
148	return err	×
149	}	×
150	return nil	28✔
151	}
152
153	func (oc DefaultNetworkController) setupHybridLRPolicySharedGw(nodeSubnets []net.IPNet, nodeName string, portMac net.HardwareAddr, drIPs net.IP) error {	24✔
154	klog.Infof("Setting up logical route policy for hybrid subnet on node: %s", nodeName)	24✔
155	var L3Prefix string	24✔
156	for _, nodeSubnet := range nodeSubnets {	48✔
157	if utilnet.IsIPv6CIDR(nodeSubnet) {	24✔
158	L3Prefix = "ip6"	×
159	} else {	24✔
160	L3Prefix = "ip4"	24✔
161	}	24✔
162	hybridCIDRs := map[string]*net.IPNet{}	24✔
163	if len(config.HybridOverlay.ClusterSubnets) > 0 {	34✔
164	for _, hybridSubnet := range config.HybridOverlay.ClusterSubnets {	20✔
165	if utilnet.IsIPv6CIDR(hybridSubnet.CIDR) == utilnet.IsIPv6CIDR(nodeSubnet) {	20✔
166	hybridCIDRs[hybridCidrClusterKey] = hybridSubnet.CIDR	10✔
167	break	10✔
168	}
169	}
170	} else {	14✔
171	// In cases of OpenShift SDN live migration, where config.HybridOverlay.ClusterSubnets is not provided, we	14✔
172	// use the host subnets allocated by OpenShiftSDN as the hybrid-overlay-node-subnet and set up hybrid	14✔
173	// overlay routes/policies to these subnets.	14✔
174	nodes, err := oc.kube.GetNodes()	14✔
175	if err != nil {	14✔
176	return err	×
177	}	×
178	for _, node := range nodes {	42✔
179	node := *node	28✔
180	if util.NoHostSubnet(&node) {	42✔
181	if subnet, _ := houtil.ParseHybridOverlayHostSubnet(&node); subnet != nil {	28✔
182	hybridCIDRs[node.Name] = subnet	14✔
183	}	14✔
184	}
185	}
186	}
187
188	for hoNodeName, hybridCIDR := range hybridCIDRs {	48✔
189	if utilnet.IsIPv6CIDR(hybridCIDR) != utilnet.IsIPv6CIDR(nodeSubnet) {	24✔
190	// skip if the IP family is not match	×
191	continue	×
192	}
193	drIP := drIPs	24✔
194	matchStr := fmt.Sprintf(`inport == "%s%s" && %s.dst == %s`,	24✔
195	ovntypes.RouterToSwitchPrefix, nodeName, L3Prefix, hybridCIDR)	24✔
196		24✔
197	name := ovntypes.HybridSubnetPrefix + nodeName + ":" + hoNodeName	24✔
198	if hoNodeName == hybridCidrClusterKey {	34✔
199	name = ovntypes.HybridSubnetPrefix + nodeName	10✔
200	}	10✔
201	// Logic route policy to steer packet from pod to hybrid overlay nodes
202	logicalRouterPolicy := nbdb.LogicalRouterPolicy{	24✔
203	Priority: ovntypes.HybridOverlaySubnetPriority,	24✔
204	ExternalIDs: map[string]string{	24✔
205	"name": name,	24✔
206	},	24✔
207	Action: nbdb.LogicalRouterPolicyActionReroute,	24✔
208	Nexthops: []string{drIP.String()},	24✔
209	Match: matchStr,	24✔
210	}	24✔
211		24✔
212	if err := libovsdbops.CreateOrUpdateLogicalRouterPolicyWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, &logicalRouterPolicy, func(item *nbdb.LogicalRouterPolicy) bool {	107✔
213	return item.Priority == logicalRouterPolicy.Priority &&	83✔
214	item.ExternalIDs["name"] == logicalRouterPolicy.ExternalIDs["name"]	83✔
215	}, &logicalRouterPolicy.Nexthops, &logicalRouterPolicy.Match, &logicalRouterPolicy.Action); err != nil {	84✔
216	return fmt.Errorf("failed to add policy route '%s' for host %q on %s , error: %w", matchStr, nodeName, ovntypes.OVNClusterRouter, err)	1✔
217	}	1✔
218
219	smb := &nbdb.StaticMACBinding{	23✔
220	LogicalPort: ovntypes.RouterToSwitchPrefix + nodeName,	23✔
221	MAC: portMac.String(),	23✔
222	IP: drIP.String(),	23✔
223	OverrideDynamicMAC: true,	23✔
224	}	23✔
225	if err := libovsdbops.CreateOrUpdateStaticMacBinding(oc.nbClient, smb); err != nil {	23✔
226	return fmt.Errorf("failed to create MAC Binding for hybrid overlay: %v", err)	×
227	}	×
228
229	// Logic route policy to steer packet from external to nodePort service backed by non-ovnkube pods to hybrid overlay nodes
230	gwLRPIfAddrs, err := libovsdbutil.GetLRPAddrs(oc.nbClient, ovntypes.GWRouterToJoinSwitchPrefix+ovntypes.GWRouterPrefix+nodeName)	23✔
231	if err != nil {	23✔
232	return err	×
233	}	×
234	gwLRPIfAddr, err := util.MatchFirstIPNetFamily(utilnet.IsIPv6CIDR(hybridCIDR), gwLRPIfAddrs)	23✔
235	if err != nil {	23✔
236	return err	×
237	}	×
238	grMatchStr := fmt.Sprintf(`%s.src == %s && %s.dst == %s`,	23✔
239	L3Prefix, gwLRPIfAddr.IP.String(), L3Prefix, hybridCIDR)	23✔
240	grLogicalRouterPolicy := nbdb.LogicalRouterPolicy{	23✔
241	Priority: ovntypes.HybridOverlaySubnetPriority,	23✔
242	ExternalIDs: map[string]string{	23✔
243	"name": ovntypes.HybridSubnetPrefix + nodeName + ovntypes.HybridOverlayGRSubfix,	23✔
244	},	23✔
245	Action: nbdb.LogicalRouterPolicyActionReroute,	23✔
246	Nexthops: []string{drIP.String()},	23✔
247	Match: grMatchStr,	23✔
248	}	23✔
249		23✔
250	if err := libovsdbops.CreateOrUpdateLogicalRouterPolicyWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, &grLogicalRouterPolicy, func(item *nbdb.LogicalRouterPolicy) bool {	110✔
251	return item.Priority == grLogicalRouterPolicy.Priority &&	87✔
252	item.ExternalIDs["name"] == grLogicalRouterPolicy.ExternalIDs["name"]	87✔
253	}, &grLogicalRouterPolicy.Nexthops, &grLogicalRouterPolicy.Match, &grLogicalRouterPolicy.Action); err != nil {	87✔
254	return fmt.Errorf("failed to add policy route '%s' for host %q on %s , error: %w", matchStr, nodeName, ovntypes.OVNClusterRouter, err)	×
255	}	×
256	klog.Infof("Created hybrid overlay logical route policies for node %s", nodeName)	23✔
257		23✔
258	// Static route to steer packets from external to nodePort service backed by pods on hybrid overlay node.	23✔
259	// This route is to used for triggering above route policy	23✔
260	clusterRouterStaticRoutes := nbdb.LogicalRouterStaticRoute{	23✔
261	IPPrefix: hybridCIDR.String(),	23✔
262	Nexthop: drIP.String(),	23✔
263	ExternalIDs: map[string]string{	23✔
264	"name": name,	23✔
265	},	23✔
266	}	23✔
267	if err := libovsdbops.CreateOrReplaceLogicalRouterStaticRouteWithPredicate(oc.nbClient,	23✔
268	ovntypes.OVNClusterRouter, &clusterRouterStaticRoutes,	23✔
269	func(item *nbdb.LogicalRouterStaticRoute) bool {	87✔
270	return item.IPPrefix == clusterRouterStaticRoutes.IPPrefix &&	64✔
271	item.ExternalIDs["name"] == clusterRouterStaticRoutes.ExternalIDs["name"] &&	64✔
272	libovsdbops.PolicyEqualPredicate(clusterRouterStaticRoutes.Policy, item.Policy)	64✔
273	}, &clusterRouterStaticRoutes.Nexthop); err != nil {	64✔
UNCOV 274	return fmt.Errorf("failed to add policy route static '%s %s' for on %s , error: %w",	×
UNCOV 275	clusterRouterStaticRoutes.IPPrefix, clusterRouterStaticRoutes.Nexthop,	×
UNCOV 276	ovntypes.GWRouterPrefix+nodeName, err)	×
UNCOV 277	}	×
278	klog.Infof("Created hybrid overlay logical route static route at cluster router for node %s", nodeName)	23✔
279		23✔
280	// Static route to steer packets from external to nodePort service backed by pods on hybrid overlay node to cluster router.	23✔
281	drLRPIfAddrs, err := libovsdbutil.GetLRPAddrs(oc.nbClient, ovntypes.GWRouterToJoinSwitchPrefix+ovntypes.OVNClusterRouter)	23✔
282	if err != nil {	23✔
283	return err	×
284	}	×
285	drLRPIfAddr, err := util.MatchFirstIPNetFamily(utilnet.IsIPv6CIDR(hybridCIDR), drLRPIfAddrs)	23✔
286	if err != nil {	23✔
287	return fmt.Errorf("failed to match cluster router join interface IPs: %v, err: %v", drLRPIfAddr, err)	×
288	}	×
289	nodeGWRouterStaticRoutes := nbdb.LogicalRouterStaticRoute{	23✔
290	IPPrefix: hybridCIDR.String(),	23✔
291	Nexthop: drLRPIfAddr.IP.String(),	23✔
292	ExternalIDs: map[string]string{	23✔
293	"name": ovntypes.HybridSubnetPrefix + nodeName + ovntypes.HybridOverlayGRSubfix,	23✔
294	},	23✔
295	}	23✔
296	if err := libovsdbops.CreateOrReplaceLogicalRouterStaticRouteWithPredicate(oc.nbClient,	23✔
297	ovntypes.GWRouterPrefix+nodeName, &nodeGWRouterStaticRoutes,	23✔
298	func(item *nbdb.LogicalRouterStaticRoute) bool {	110✔
299	return item.IPPrefix == nodeGWRouterStaticRoutes.IPPrefix &&	87✔
300	item.ExternalIDs["name"] == nodeGWRouterStaticRoutes.ExternalIDs["name"] &&	87✔
301	libovsdbops.PolicyEqualPredicate(nodeGWRouterStaticRoutes.Policy, item.Policy)	87✔
302	}, &nodeGWRouterStaticRoutes.Nexthop); err != nil {	87✔
303	return fmt.Errorf("failed to add policy route static '%s %s' for on %s , error: %w",	×
304	nodeGWRouterStaticRoutes.IPPrefix, nodeGWRouterStaticRoutes.Nexthop,	×
305	ovntypes.GWRouterPrefix+nodeName, err)	×
306	}	×
307	klog.Infof("Created hybrid overlay logical route static route at gateway router for node %s", nodeName)	23✔
308	}
309	}
310	return nil	23✔
311	}
312
313	func (oc DefaultNetworkController) removeHybridLRPolicySharedGW(node kapi.Node) error {	28✔
314	nodeName := node.Name	28✔
315	name := ovntypes.HybridSubnetPrefix + nodeName	28✔
316		28✔
317	if err := libovsdbops.DeleteLogicalRouterPoliciesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterPolicy) bool {	61✔
318	return strings.Contains(item.ExternalIDs["name"], name)	33✔
319	}); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {	33✔
320	return fmt.Errorf("failed to delete policy %s from %s, error: %w", name, ovntypes.OVNClusterRouter, err)	×
321	}	×
322
323	// order is important here to not incur referential integrity violation
324	// first remove GR routes with a specific predicate, then remove the
325	// remaining ones from cluster router with a generic predicate
326	if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.GWRouterPrefix+nodeName, func(item *nbdb.LogicalRouterStaticRoute) bool {	98✔
327	return item.ExternalIDs["name"] == name+ovntypes.HybridOverlayGRSubfix	70✔
328	}); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {	70✔
329	return fmt.Errorf("failed to delete static route %s from %s, error: %w", name+"gr", ovntypes.GWRouterPrefix+nodeName, err)	×
330	}	×
331	if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterStaticRoute) bool {	95✔
332	return strings.Contains(item.ExternalIDs["name"], name)	67✔
333	}); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {	67✔
334	return fmt.Errorf("failed to delete static route %s from %s, error: %w", name, ovntypes.OVNClusterRouter, err)	×
335	}	×
336
337	if node.Annotations[hotypes.HybridOverlayDRIP] != "" {	32✔
338	smb := &nbdb.StaticMACBinding{	4✔
339	IP: node.Annotations[hotypes.HybridOverlayDRIP],	4✔
340	LogicalPort: ovntypes.RouterToSwitchPrefix + nodeName,	4✔
341	}	4✔
342	err := libovsdbops.DeleteStaticMacBindings(oc.nbClient, smb)	4✔
343	if err != nil {	4✔
344	return fmt.Errorf("failed to delete static mac binding %+v: %v", smb, err)	×
345	}	×
346	}
347
348	return nil	28✔
349	}
350
351	// takes the node name and allocates the hybrid overlay distributed router ip address
352	func (oc DefaultNetworkController) allocateHybridOverlayDRIP(node kapi.Node) error {	9✔
353	if atomic.LoadUint32(&oc.allInitialPodsProcessed) == 0 {	11✔
354	return fmt.Errorf("cannot allocate hybrid overlay distributed router ip for nodes until all initial pods are processed")	2✔
355	}	2✔
356
357	var ips []string	7✔
358	// check if there is a hybrid distributed router IP set as an annotation	7✔
359	nodeHybridOverlayDRIP := node.Annotations[hotypes.HybridOverlayDRIP]	7✔
360	if len(nodeHybridOverlayDRIP) > 0 {	7✔
361	ips = strings.Split(nodeHybridOverlayDRIP, ",")	×
362	}	×
363
364	allocatedHybridOverlayDRIPs, err := oc.lsManager.AllocateHybridOverlay(node.Name, ips)	7✔
365	if err != nil {	7✔
366	return fmt.Errorf("cannot allocate hybrid overlay interface addresses on node %s: %v", node.Name, err)	×
367	}	×
368
369	var sliceHybridOverlayDRIP []string	7✔
370	for _, ip := range allocatedHybridOverlayDRIPs {	14✔
371	sliceHybridOverlayDRIP = append(sliceHybridOverlayDRIP, ip.IP.String())	7✔
372	}	7✔
373
374	err = oc.kube.SetAnnotationsOnNode(node.Name, map[string]interface{}{hotypes.HybridOverlayDRIP: strings.Join(sliceHybridOverlayDRIP, ",")})	7✔
375	if err != nil {	7✔
376	return fmt.Errorf("cannot set hybrid annotation on node %s: %v", node.Name, err)	×
377	}	×
378
379	return nil	7✔
380	}
381
382	func (oc DefaultNetworkController) removeRoutesToHONodeSubnet(nodeSubnet net.IPNet) error {	1✔
383	klog.Infof("Delete hybrid overlay policy and static routes to %s", nodeSubnet.String())	1✔
384		1✔
385	// Delete policy to HO subnet from the cluster router	1✔
386	if err := libovsdbops.DeleteLogicalRouterPoliciesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterPolicy) bool {	5✔
387	return strings.Contains(item.Match, nodeSubnet.String())	4✔
388	}); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {	4✔
389	return fmt.Errorf("failed to delete policy route to %s from %s, error: %w", nodeSubnet, ovntypes.OVNClusterRouter, err)	×
390	}	×
391
392	// Delete routes to HO subnet from the cluster router
393	if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.OVNClusterRouter, func(item *nbdb.LogicalRouterStaticRoute) bool {	8✔
394	name, ok := item.ExternalIDs["name"]	7✔
395	if !ok {	12✔
396	return false	5✔
397	}	5✔
398	if !strings.Contains(name, ovntypes.HybridSubnetPrefix) \|\| strings.Contains(name, ovntypes.HybridOverlayGRSubfix) {	3✔
399	return false	1✔
400	}	1✔
401	return item.IPPrefix == nodeSubnet.String() && item.Policy == nil	1✔
402	}); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {	×
403	return fmt.Errorf("failed to delete static route to %s from %s, error: %w", nodeSubnet, ovntypes.OVNClusterRouter, err)	×
404	}	×
405
406	// Delete routes to HO subnet from GRs
407	nodes, err := oc.kube.GetNodes()	1✔
408	if err != nil {	1✔
409	return err	×
410	}	×
411	for _, node := range nodes {	3✔
412	node := *node	2✔
413	// Check existence of Gateway Router before removing the static route from it.	2✔
414	if _, err := libovsdbops.GetLogicalRouter(oc.nbClient, &nbdb.LogicalRouter{Name: ovntypes.GWRouterPrefix + node.Name}); err != nil {	3✔
415	if err == libovsdbclient.ErrNotFound {	2✔
416	continue	1✔
417	}
418	return fmt.Errorf("failed to get logical router %s, error: %w", ovntypes.GWRouterPrefix+node.Name, err)	×
419	}
420	if err := libovsdbops.DeleteLogicalRouterStaticRoutesWithPredicate(oc.nbClient, ovntypes.GWRouterPrefix+node.Name, func(item *nbdb.LogicalRouterStaticRoute) bool {	7✔
421	name, ok := item.ExternalIDs["name"]	6✔
422	if !ok {	11✔
423	return false	5✔
424	}	5✔
425	if name != ovntypes.HybridSubnetPrefix+node.Name+ovntypes.HybridOverlayGRSubfix {	1✔
426	return false	×
427	}	×
428	return item.IPPrefix == nodeSubnet.String() && item.Policy == nil	1✔
429	}); err != nil && !errors.Is(err, libovsdbclient.ErrNotFound) {	×
430	return fmt.Errorf("failed to delete static route to %s from %s, error: %w", nodeSubnet, ovntypes.GWRouterPrefix+node.Name, err)	×
431	}	×
432	}
433	return nil	1✔
434	}

ovn-org / ovn-kubernetes / 9559673574

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous