16414518284

Committed 21 Jul 2025 10:26AM UTC coverage: 21.433% (-0.004%) from 21.437%

Build # 16414518284

Build Type

Pull #5501

github

Committed by

oilbeater

Commit Message

fix: ip/vpc are not deleted by helm uninstall

Signed-off-by: Mengxin Liu <liumengxinfly@gmail.com>

Pull Request Pull Request #5501: fix: ip/vpc are not deleted by helm uninstall

Run Details

10540 of 49176 relevant lines covered (21.43%)

0.25 hits per line

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

74.6

/pkg/ovs/ovn-nb-logical_router_route.go

package ovs

import (
        "context"
        "errors"
        "fmt"
        "slices"

        "github.com/ovn-org/libovsdb/client"
        "github.com/ovn-org/libovsdb/model"
        "github.com/ovn-org/libovsdb/ovsdb"
        "github.com/scylladb/go-set/strset"
        "k8s.io/klog/v2"
        "k8s.io/utils/ptr"
        "k8s.io/utils/set"

        ovsclient "github.com/kubeovn/kube-ovn/pkg/ovsdb/client"
        "github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
        "github.com/kubeovn/kube-ovn/pkg/util"
)

func (c *OVNNbClient) ListLogicalRouterStaticRoutesByOption(lrName, _, key, value string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
        fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {
                if len(route.Options) != 0 {
                        if _, ok := route.Options[key]; ok {
                                return route.Options[key] == value
                        }
                }
                return false
        }
        return c.listLogicalRouterStaticRoutesByFilter(lrName, fnFilter)
}

// CreateLogicalRouterStaticRoutes create several logical router static route once
func (c *OVNNbClient) CreateLogicalRouterStaticRoutes(lrName string, routes ...*ovnnb.LogicalRouterStaticRoute) error {
        if len(routes) == 0 {
                return nil
        }

        models := make([]model.Model, 0, len(routes))
        routeUUIDs := make([]string, 0, len(routes))
        for _, route := range routes {
                if route != nil {
                        models = append(models, model.Model(route))
                        routeUUIDs = append(routeUUIDs, route.UUID)
                }
        }

        createRoutesOp, err := c.Create(models...)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for creating static routes: %w", err)
        }

        routeAddOp, err := c.LogicalRouterUpdateStaticRouteOp(lrName, routeUUIDs, ovsdb.MutateOperationInsert)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for adding static routes to logical router %s: %w", lrName, err)
        }

        ops := make([]ovsdb.Operation, 0, len(createRoutesOp)+len(routeAddOp))
        ops = append(ops, createRoutesOp...)
        ops = append(ops, routeAddOp...)

        if err = c.Transact("lr-routes-add", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("add static routes to %s: %w", lrName, err)
        }

        return nil
}

// AddLogicalRouterStaticRoute add a logical router static route
func (c *OVNNbClient) AddLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix string, bfdID *string, externalIDs map[string]string, nexthops ...string) error {
        if len(policy) == 0 {
                policy = ovnnb.LogicalRouterStaticRoutePolicyDstIP
        }

        routes, err := c.ListLogicalRouterStaticRoutes(lrName, &routeTable, &policy, ipPrefix, nil)
        if err != nil {
                klog.Error(err)
                return err
        }

        existing := strset.New()
        var toDel []string
        for _, route := range routes {
                if slices.Contains(nexthops, route.Nexthop) {
                        existing.Add(route.Nexthop)
                } else {
                        if route.BFD != nil && bfdID != nil && *route.BFD != *bfdID {
                                continue
                        }
                        toDel = append(toDel, route.UUID)
                }
        }
        var toAdd []*ovnnb.LogicalRouterStaticRoute
        for _, nexthop := range nexthops {
                if !existing.Has(nexthop) {
                        route, err := c.newLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop, bfdID, externalIDs)
                        if err != nil {
                                klog.Error(err)
                                return err
                        }
                        toAdd = append(toAdd, route)
                }
        }
        if len(toDel) != 0 {
                klog.Infof("logical router %s del static routes: %v", lrName, toDel)
        }
        ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, toDel, ovsdb.MutateOperationDelete)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for removing static routes from logical router %s: %w", lrName, err)
        }
        if err = c.Transact("lr-route-del", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to delete static routes from logical router %s: %w", lrName, err)
        }
        if err = c.CreateLogicalRouterStaticRoutes(lrName, toAdd...); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to add static routes to logical router %s: %w", lrName, err)
        }
        return nil
}

// UpdateLogicalRouterStaticRoute update logical router static route
func (c *OVNNbClient) UpdateLogicalRouterStaticRoute(route *ovnnb.LogicalRouterStaticRoute, fields ...any) error {
        if route == nil {
                return errors.New("route is nil")
        }

        op, err := c.ovsDbClient.Where(route).Update(route, fields...)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for updating logical router static route 'policy %s ip_prefix %s': %w", *route.Policy, route.IPPrefix, err)
        }

        if err = c.Transact("net-update", op); err != nil {
                klog.Error(err)
                return fmt.Errorf("update logical router static route 'policy %s ip_prefix %s': %w", *route.Policy, route.IPPrefix, err)
        }

        return nil
}

// DeleteLogicalRouterStaticRoute delete a logical router static route
func (c *OVNNbClient) DeleteLogicalRouterStaticRoute(lrName string, routeTable, policy *string, ipPrefix, nexthop string) error {
        if policy == nil || len(*policy) == 0 {
                policy = ptr.To(ovnnb.LogicalRouterStaticRoutePolicyDstIP)
        }

        lr, err := c.GetLogicalRouter(lrName, true)
        if lr == nil && err == nil {
                return nil
        }

        routes, err := c.ListLogicalRouterStaticRoutes(lrName, routeTable, policy, ipPrefix, nil)
        if err != nil {
                klog.Error(err)
                return err
        }

        // not found, skip
        if len(routes) == 0 {
                return nil
        }

        uuids := make([]string, 0, len(routes))
        for _, route := range routes {
                if nexthop == "" || route.Nexthop == nexthop {
                        uuids = append(uuids, route.UUID)
                }
        }

        // remove static route from logical router
        ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, uuids, ovsdb.MutateOperationDelete)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for removing static routes %v from logical router %s: %w", uuids, lrName, err)
        }
        if err = c.Transact("lr-route-del", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("delete static routes %v from logical router %s: %w", uuids, lrName, err)
        }

        return nil
}

// DeleteLogicalRouterStaticRoute delete a logical router static route
func (c *OVNNbClient) DeleteLogicalRouterStaticRouteByUUID(lrName, uuid string) error {
        lr, err := c.GetLogicalRouter(lrName, true)
        if err != nil {
                return err
        }
        if lr == nil {
                return nil
        }

        // remove static route from logical router
        ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, []string{uuid}, ovsdb.MutateOperationDelete)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for removing static route %s from logical router %s: %w", uuid, lrName, err)
        }
        if err = c.Transact("lr-route-del", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("delete static route %s from logical router %s: %w", uuid, lrName, err)
        }

        return nil
}

func (c *OVNNbClient) DeleteLogicalRouterStaticRouteByExternalIDs(lrName string, externalIDs map[string]string) error {
        lr, err := c.GetLogicalRouter(lrName, true)
        if err != nil {
                return err
        }
        if lr == nil {
                return nil
        }

        routes, err := c.ListLogicalRouterStaticRoutes(lrName, nil, nil, "", externalIDs)
        if err != nil {
                klog.Error(err)
                return err
        }
        if len(routes) == 0 {
                return nil
        }

        uuids := make([]string, 0, len(routes))
        for _, route := range routes {
                uuids = append(uuids, route.UUID)
        }

        // remove static route from logical router
        ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, uuids, ovsdb.MutateOperationDelete)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for removing static routes %v from logical router %s: %w", uuids, lrName, err)
        }
        if err = c.Transact("lr-route-del", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("delete static routes %v from logical router %s: %w", uuids, lrName, err)
        }

        return nil
}

// BatchDeleteLogicalRouterStaticRoute batch delete a logical router static route
func (c *OVNNbClient) BatchDeleteLogicalRouterStaticRoute(lrName string, staticRoutes []*ovnnb.LogicalRouterStaticRoute) error {
        lr, err := c.GetLogicalRouter(lrName, true)
        if lr == nil && err == nil {
                return nil
        }

        staticRoutesMap := make(map[string]string, len(staticRoutes))
        for _, route := range staticRoutes {
                if route == nil {
                        continue
                }
                if route.Policy == nil {
                        route.Policy = &ovnnb.LogicalRouterStaticRoutePolicyDstIP
                }

                staticRoutesMap[createStaticRouteKey(route.RouteTable, *route.Policy, route.IPPrefix)] = route.Nexthop
        }
        routes, err := c.batchListLogicalRouterStaticRoutesForDelete(staticRoutesMap, lr.StaticRoutes)
        if err != nil {
                klog.Error(err)
                return err
        }

        // not found, skip
        if len(routes) == 0 {
                return nil
        }

        uuids := make([]string, 0, len(routes))
        for _, route := range routes {
                key := createStaticRouteKey(route.RouteTable, *route.Policy, route.IPPrefix)
                nexthop, exits := staticRoutesMap[key]
                if exits && (nexthop == "" || route.Nexthop == nexthop) {
                        uuids = append(uuids, route.UUID)
                }
        }

        // remove static route from logical router
        ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, uuids, ovsdb.MutateOperationDelete)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for removing static routes %v from logical router %s: %w", uuids, lrName, err)
        }
        if err = c.Transact("lr-route-del", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("delete static routes %v from logical router %s: %w", uuids, lrName, err)
        }

        return nil
}

// ClearLogicalRouterStaticRoute clear static route from logical router once
func (c *OVNNbClient) ClearLogicalRouterStaticRoute(lrName string) error {
        lr, err := c.GetLogicalRouter(lrName, false)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("get logical router %s: %w", lrName, err)
        }

        // clear static route
        lr.StaticRoutes = nil
        ops, err := c.UpdateLogicalRouterOp(lr, &lr.StaticRoutes)
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for clear logical router %s static route: %w", lrName, err)
        }
        if err = c.Transact("lr-route-clear", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("clear logical router %s static routes: %w", lrName, err)
        }

        return nil
}

// GetLogicalRouterStaticRouteByUUID get logical router static route by UUID
func (c *OVNNbClient) GetLogicalRouterStaticRouteByUUID(uuid string) (*ovnnb.LogicalRouterStaticRoute, error) {
        ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
        defer cancel()

        route := &ovnnb.LogicalRouterStaticRoute{UUID: uuid}
        if err := c.Get(ctx, route); err != nil {
                klog.Error(err)
                return nil, err
        }

        return route, nil
}

// GetLogicalRouterStaticRoute get logical router static route by some attribute,
// a static route is uniquely identified by router(lrName), policy and ipPrefix when route is not ecmp
// a static route is uniquely identified by router(lrName), policy, ipPrefix and nexthop when route is ecmp
func (c *OVNNbClient) GetLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop string, ignoreNotFound bool) (*ovnnb.LogicalRouterStaticRoute, error) {
        // this is necessary because may exist same static route in different logical router
        if len(lrName) == 0 {
                return nil, errors.New("the logical router name is required")
        }

        fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {
                return route.RouteTable == routeTable && route.Policy != nil && *route.Policy == policy && route.IPPrefix == ipPrefix && route.Nexthop == nexthop
        }
        routeList, err := c.listLogicalRouterStaticRoutesByFilter(lrName, fnFilter)
        if err != nil {
                klog.Error(err)
                return nil, fmt.Errorf("get logical router %s static route 'policy %s ip_prefix %s nexthop %s': %w", lrName, policy, ipPrefix, nexthop, err)
        }

        // not found
        if len(routeList) == 0 {
                if ignoreNotFound {
                        return nil, nil
                }
                return nil, fmt.Errorf("not found logical router %s static route 'policy %s ip_prefix %s nexthop %s'", lrName, policy, ipPrefix, nexthop)
        }

        if len(routeList) > 1 {
                return nil, fmt.Errorf("more than one static route 'policy %s ip_prefix %s nexthop %s' in logical router %s", policy, ipPrefix, nexthop, lrName)
        }

        return routeList[0], nil
}

// ListLogicalRouterStaticRoutes list route which match the given externalIDs
func (c *OVNNbClient) ListLogicalRouterStaticRoutes(lrName string, routeTable, policy *string, ipPrefix string, externalIDs map[string]string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
        fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {
                if len(route.ExternalIDs) < len(externalIDs) {
                        return false
                }

                if len(route.ExternalIDs) != 0 {
                        for k, v := range externalIDs {
                                // if only key exist but not value in externalIDs, we should include this route,
                                // it's equal to shell command `ovn-nbctl --columns=xx find logical_router_static_route external_ids:key!=\"\"`
                                if len(v) == 0 {
                                        if len(route.ExternalIDs[k]) == 0 {
                                                return false
                                        }
                                } else {
                                        if route.ExternalIDs[k] != v {
                                                return false
                                        }
                                }
                        }
                }

                if routeTable != nil && route.RouteTable != *routeTable {
                        return false
                }
                if policy != nil {
                        if route.Policy != nil {
                                if *route.Policy != *policy {
                                        return false
                                }
                        } else if *policy != ovnnb.LogicalRouterStaticRoutePolicyDstIP {
                                return false
                        }
                }
                if ipPrefix != "" && route.IPPrefix != ipPrefix {
                        return false
                }

                return true
        }

        return c.listLogicalRouterStaticRoutesByFilter(lrName, fnFilter)
}

func (c *OVNNbClient) LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop string) (bool, error) {
        route, err := c.GetLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop, true)
        return route != nil, err
}

// newLogicalRouterStaticRoute return logical router static route with basic information
func (c *OVNNbClient) newLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop string, bfdID *string, externalIDs map[string]string, options ...func(route *ovnnb.LogicalRouterStaticRoute)) (*ovnnb.LogicalRouterStaticRoute, error) {
        if len(lrName) == 0 {
                return nil, errors.New("the logical router name is required")
        }

        if len(policy) == 0 {
                policy = ovnnb.LogicalRouterStaticRoutePolicyDstIP
        }

        exists, err := c.LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop)
        if err != nil {
                klog.Error(err)
                return nil, fmt.Errorf("get logical router %s route: %w", lrName, err)
        }

        // found, ignore
        if exists {
                return nil, nil
        }

        route := &ovnnb.LogicalRouterStaticRoute{
                UUID:        ovsclient.NamedUUID(),
                Policy:      &policy,
                IPPrefix:    ipPrefix,
                Nexthop:     nexthop,
                RouteTable:  routeTable,
                ExternalIDs: externalIDs,
        }
        for _, option := range options {
                option(route)
        }

        if bfdID != nil {
                route.BFD = bfdID
                if route.Options == nil {
                        route.Options = make(map[string]string)
                }
                route.Options[util.StaticRouteBfdEcmp] = "true"
        }
        return route, nil
}

func (c *OVNNbClient) listLogicalRouterStaticRoutesByFilter(lrName string, filter func(route *ovnnb.LogicalRouterStaticRoute) bool) ([]*ovnnb.LogicalRouterStaticRoute, error) {
        lr, err := c.GetLogicalRouter(lrName, false)
        if err != nil {
                klog.Error(err)
                return nil, err
        }

        routeList := make([]*ovnnb.LogicalRouterStaticRoute, 0, len(lr.StaticRoutes))
        for _, uuid := range lr.StaticRoutes {
                route, err := c.GetLogicalRouterStaticRouteByUUID(uuid)
                if err != nil {
                        if errors.Is(err, client.ErrNotFound) {
                                continue
                        }
                        klog.Error(err)
                        return nil, err
                }
                if filter == nil || filter(route) {
                        routeList = append(routeList, route)
                }
        }

        return routeList, nil
}

// batchListLogicalRouterStaticRoutesForDelete batch list route which match the given condition when need delete static route
func (c *OVNNbClient) batchListLogicalRouterStaticRoutesForDelete(staticRoutes map[string]string, lrStaticRoute []string) ([]*ovnnb.LogicalRouterStaticRoute, error) {
        lrStaticRouteSet := set.New(lrStaticRoute...)
        fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {
                if !lrStaticRouteSet.Has(route.UUID) {
                        return false
                }

                if route.Policy == nil {
                        route.Policy = &ovnnb.LogicalRouterStaticRoutePolicyDstIP
                }

                key := createStaticRouteKey(route.RouteTable, *route.Policy, route.IPPrefix)
                _, exists := staticRoutes[key]
                return exists
        }

        ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
        defer cancel()

        routeList := make([]*ovnnb.LogicalRouterStaticRoute, 0)
        if err := c.ovsDbClient.WhereCache(fnFilter).List(ctx, &routeList); err != nil {
                klog.Error(err)
                return nil, fmt.Errorf("batch list logical staric router %v lr staric route %v route: %w", staticRoutes, lrStaticRoute, err)
        }

        return routeList, nil
}

func createStaticRouteKey(routeTable, policy, ipPrefix string) string {
        return fmt.Sprintf("%s-%s-%s", routeTable, policy, ipPrefix)
}

1	package ovs
2
3	import (
4	"context"
5	"errors"
6	"fmt"
7	"slices"
8
9	"github.com/ovn-org/libovsdb/client"
10	"github.com/ovn-org/libovsdb/model"
11	"github.com/ovn-org/libovsdb/ovsdb"
12	"github.com/scylladb/go-set/strset"
13	"k8s.io/klog/v2"
14	"k8s.io/utils/ptr"
15	"k8s.io/utils/set"
16
17	ovsclient "github.com/kubeovn/kube-ovn/pkg/ovsdb/client"
18	"github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
19	"github.com/kubeovn/kube-ovn/pkg/util"
20	)
21
22	func (c OVNNbClient) ListLogicalRouterStaticRoutesByOption(lrName, _, key, value string) ([]ovnnb.LogicalRouterStaticRoute, error) {	1✔
23	fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {	2✔
24	if len(route.Options) != 0 {	2✔
25	if _, ok := route.Options[key]; ok {	2✔
26	return route.Options[key] == value	1✔
27	}	1✔
28	}
29	return false	1✔
30	}
31	return c.listLogicalRouterStaticRoutesByFilter(lrName, fnFilter)	1✔
32	}
33
34	// CreateLogicalRouterStaticRoutes create several logical router static route once
35	func (c OVNNbClient) CreateLogicalRouterStaticRoutes(lrName string, routes ...ovnnb.LogicalRouterStaticRoute) error {	1✔
36	if len(routes) == 0 {	2✔
37	return nil	1✔
38	}	1✔
39
40	models := make([]model.Model, 0, len(routes))	1✔
41	routeUUIDs := make([]string, 0, len(routes))	1✔
42	for _, route := range routes {	2✔
43	if route != nil {	2✔
44	models = append(models, model.Model(route))	1✔
45	routeUUIDs = append(routeUUIDs, route.UUID)	1✔
46	}	1✔
47	}
48
49	createRoutesOp, err := c.Create(models...)	1✔
50	if err != nil {	1✔
51	klog.Error(err)	×
52	return fmt.Errorf("generate operations for creating static routes: %w", err)	×
53	}	×
54
55	routeAddOp, err := c.LogicalRouterUpdateStaticRouteOp(lrName, routeUUIDs, ovsdb.MutateOperationInsert)	1✔
56	if err != nil {	2✔
57	klog.Error(err)	1✔
58	return fmt.Errorf("generate operations for adding static routes to logical router %s: %w", lrName, err)	1✔
59	}	1✔
60
61	ops := make([]ovsdb.Operation, 0, len(createRoutesOp)+len(routeAddOp))	1✔
62	ops = append(ops, createRoutesOp...)	1✔
63	ops = append(ops, routeAddOp...)	1✔
64		1✔
65	if err = c.Transact("lr-routes-add", ops); err != nil {	1✔
66	klog.Error(err)	×
67	return fmt.Errorf("add static routes to %s: %w", lrName, err)	×
68	}	×
69
70	return nil	1✔
71	}
72
73	// AddLogicalRouterStaticRoute add a logical router static route
74	func (c OVNNbClient) AddLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix string, bfdID string, externalIDs map[string]string, nexthops ...string) error {	1✔
75	if len(policy) == 0 {	2✔
76	policy = ovnnb.LogicalRouterStaticRoutePolicyDstIP	1✔
77	}	1✔
78
79	routes, err := c.ListLogicalRouterStaticRoutes(lrName, &routeTable, &policy, ipPrefix, nil)	1✔
80	if err != nil {	2✔
81	klog.Error(err)	1✔
82	return err	1✔
83	}	1✔
84
85	existing := strset.New()	1✔
86	var toDel []string	1✔
87	for _, route := range routes {	2✔
88	if slices.Contains(nexthops, route.Nexthop) {	2✔
89	existing.Add(route.Nexthop)	1✔
90	} else {	2✔
91	if route.BFD != nil && bfdID != nil && route.BFD != bfdID {	1✔
92	continue	×
93	}
94	toDel = append(toDel, route.UUID)	1✔
95	}
96	}
97	var toAdd []*ovnnb.LogicalRouterStaticRoute	1✔
98	for _, nexthop := range nexthops {	2✔
99	if !existing.Has(nexthop) {	2✔
100	route, err := c.newLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop, bfdID, externalIDs)	1✔
101	if err != nil {	1✔
102	klog.Error(err)	×
103	return err	×
104	}	×
105	toAdd = append(toAdd, route)	1✔
106	}
107	}
108	if len(toDel) != 0 {	2✔
109	klog.Infof("logical router %s del static routes: %v", lrName, toDel)	1✔
110	}	1✔
111	ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, toDel, ovsdb.MutateOperationDelete)	1✔
112	if err != nil {	1✔
113	klog.Error(err)	×
114	return fmt.Errorf("generate operations for removing static routes from logical router %s: %w", lrName, err)	×
115	}	×
116	if err = c.Transact("lr-route-del", ops); err != nil {	1✔
117	klog.Error(err)	×
118	return fmt.Errorf("failed to delete static routes from logical router %s: %w", lrName, err)	×
119	}	×
120	if err = c.CreateLogicalRouterStaticRoutes(lrName, toAdd...); err != nil {	1✔
121	klog.Error(err)	×
122	return fmt.Errorf("failed to add static routes to logical router %s: %w", lrName, err)	×
123	}	×
124	return nil	1✔
125	}
126
127	// UpdateLogicalRouterStaticRoute update logical router static route
128	func (c OVNNbClient) UpdateLogicalRouterStaticRoute(route ovnnb.LogicalRouterStaticRoute, fields ...any) error {	1✔
129	if route == nil {	2✔
130	return errors.New("route is nil")	1✔
131	}	1✔
132
133	op, err := c.ovsDbClient.Where(route).Update(route, fields...)	1✔
134	if err != nil {	1✔
135	klog.Error(err)	×
136	return fmt.Errorf("generate operations for updating logical router static route 'policy %s ip_prefix %s': %w", *route.Policy, route.IPPrefix, err)	×
137	}	×
138
139	if err = c.Transact("net-update", op); err != nil {	1✔
140	klog.Error(err)	×
141	return fmt.Errorf("update logical router static route 'policy %s ip_prefix %s': %w", *route.Policy, route.IPPrefix, err)	×
142	}	×
143
144	return nil	1✔
145	}
146
147	// DeleteLogicalRouterStaticRoute delete a logical router static route
148	func (c OVNNbClient) DeleteLogicalRouterStaticRoute(lrName string, routeTable, policy string, ipPrefix, nexthop string) error {	1✔
149	if policy == nil \|\| len(*policy) == 0 {	2✔
150	policy = ptr.To(ovnnb.LogicalRouterStaticRoutePolicyDstIP)	1✔
151	}	1✔
152
153	lr, err := c.GetLogicalRouter(lrName, true)	1✔
154	if lr == nil && err == nil {	2✔
155	return nil	1✔
156	}	1✔
157
158	routes, err := c.ListLogicalRouterStaticRoutes(lrName, routeTable, policy, ipPrefix, nil)	1✔
159	if err != nil {	1✔
160	klog.Error(err)	×
161	return err	×
162	}	×
163
164	// not found, skip
165	if len(routes) == 0 {	2✔
166	return nil	1✔
167	}	1✔
168
169	uuids := make([]string, 0, len(routes))	1✔
170	for _, route := range routes {	2✔
171	if nexthop == "" \|\| route.Nexthop == nexthop {	2✔
172	uuids = append(uuids, route.UUID)	1✔
173	}	1✔
174	}
175
176	// remove static route from logical router
177	ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, uuids, ovsdb.MutateOperationDelete)	1✔
178	if err != nil {	1✔
179	klog.Error(err)	×
180	return fmt.Errorf("generate operations for removing static routes %v from logical router %s: %w", uuids, lrName, err)	×
181	}	×
182	if err = c.Transact("lr-route-del", ops); err != nil {	1✔
183	klog.Error(err)	×
184	return fmt.Errorf("delete static routes %v from logical router %s: %w", uuids, lrName, err)	×
185	}	×
186
187	return nil	1✔
188	}
189
190	// DeleteLogicalRouterStaticRoute delete a logical router static route
191	func (c *OVNNbClient) DeleteLogicalRouterStaticRouteByUUID(lrName, uuid string) error {	1✔
192	lr, err := c.GetLogicalRouter(lrName, true)	1✔
193	if err != nil {	1✔
194	return err	×
195	}	×
196	if lr == nil {	1✔
197	return nil	×
198	}	×
199
200	// remove static route from logical router
201	ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, []string{uuid}, ovsdb.MutateOperationDelete)	1✔
202	if err != nil {	1✔
203	klog.Error(err)	×
204	return fmt.Errorf("generate operations for removing static route %s from logical router %s: %w", uuid, lrName, err)	×
205	}	×
206	if err = c.Transact("lr-route-del", ops); err != nil {	1✔
207	klog.Error(err)	×
208	return fmt.Errorf("delete static route %s from logical router %s: %w", uuid, lrName, err)	×
209	}	×
210
211	return nil	1✔
212	}
213
214	func (c *OVNNbClient) DeleteLogicalRouterStaticRouteByExternalIDs(lrName string, externalIDs map[string]string) error {	1✔
215	lr, err := c.GetLogicalRouter(lrName, true)	1✔
216	if err != nil {	1✔
217	return err	×
218	}	×
219	if lr == nil {	1✔
220	return nil	×
221	}	×
222
223	routes, err := c.ListLogicalRouterStaticRoutes(lrName, nil, nil, "", externalIDs)	1✔
224	if err != nil {	1✔
225	klog.Error(err)	×
226	return err	×
227	}	×
228	if len(routes) == 0 {	2✔
229	return nil	1✔
230	}	1✔
231
232	uuids := make([]string, 0, len(routes))	1✔
233	for _, route := range routes {	2✔
234	uuids = append(uuids, route.UUID)	1✔
235	}	1✔
236
237	// remove static route from logical router
238	ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, uuids, ovsdb.MutateOperationDelete)	1✔
239	if err != nil {	1✔
240	klog.Error(err)	×
241	return fmt.Errorf("generate operations for removing static routes %v from logical router %s: %w", uuids, lrName, err)	×
242	}	×
243	if err = c.Transact("lr-route-del", ops); err != nil {	1✔
244	klog.Error(err)	×
245	return fmt.Errorf("delete static routes %v from logical router %s: %w", uuids, lrName, err)	×
246	}	×
247
248	return nil	1✔
249	}
250
251	// BatchDeleteLogicalRouterStaticRoute batch delete a logical router static route
252	func (c OVNNbClient) BatchDeleteLogicalRouterStaticRoute(lrName string, staticRoutes []ovnnb.LogicalRouterStaticRoute) error {	1✔
253	lr, err := c.GetLogicalRouter(lrName, true)	1✔
254	if lr == nil && err == nil {	2✔
255	return nil	1✔
256	}	1✔
257
258	staticRoutesMap := make(map[string]string, len(staticRoutes))	1✔
259	for _, route := range staticRoutes {	2✔
260	if route == nil {	1✔
261	continue	×
262	}
263	if route.Policy == nil {	1✔
264	route.Policy = &ovnnb.LogicalRouterStaticRoutePolicyDstIP	×
265	}	×
266
267	staticRoutesMap[createStaticRouteKey(route.RouteTable, *route.Policy, route.IPPrefix)] = route.Nexthop	1✔
268	}
269	routes, err := c.batchListLogicalRouterStaticRoutesForDelete(staticRoutesMap, lr.StaticRoutes)	1✔
270	if err != nil {	1✔
271	klog.Error(err)	×
272	return err	×
273	}	×
274
275	// not found, skip
276	if len(routes) == 0 {	2✔
277	return nil	1✔
278	}	1✔
279
280	uuids := make([]string, 0, len(routes))	1✔
281	for _, route := range routes {	2✔
282	key := createStaticRouteKey(route.RouteTable, *route.Policy, route.IPPrefix)	1✔
283	nexthop, exits := staticRoutesMap[key]	1✔
284	if exits && (nexthop == "" \|\| route.Nexthop == nexthop) {	2✔
285	uuids = append(uuids, route.UUID)	1✔
286	}	1✔
287	}
288
289	// remove static route from logical router
290	ops, err := c.LogicalRouterUpdateStaticRouteOp(lrName, uuids, ovsdb.MutateOperationDelete)	1✔
291	if err != nil {	1✔
292	klog.Error(err)	×
293	return fmt.Errorf("generate operations for removing static routes %v from logical router %s: %w", uuids, lrName, err)	×
294	}	×
295	if err = c.Transact("lr-route-del", ops); err != nil {	1✔
296	klog.Error(err)	×
297	return fmt.Errorf("delete static routes %v from logical router %s: %w", uuids, lrName, err)	×
298	}	×
299
300	return nil	1✔
301	}
302
303	// ClearLogicalRouterStaticRoute clear static route from logical router once
304	func (c *OVNNbClient) ClearLogicalRouterStaticRoute(lrName string) error {	1✔
305	lr, err := c.GetLogicalRouter(lrName, false)	1✔
306	if err != nil {	2✔
307	klog.Error(err)	1✔
308	return fmt.Errorf("get logical router %s: %w", lrName, err)	1✔
309	}	1✔
310
311	// clear static route
312	lr.StaticRoutes = nil	1✔
313	ops, err := c.UpdateLogicalRouterOp(lr, &lr.StaticRoutes)	1✔
314	if err != nil {	1✔
315	klog.Error(err)	×
316	return fmt.Errorf("generate operations for clear logical router %s static route: %w", lrName, err)	×
317	}	×
318	if err = c.Transact("lr-route-clear", ops); err != nil {	1✔
319	klog.Error(err)	×
320	return fmt.Errorf("clear logical router %s static routes: %w", lrName, err)	×
321	}	×
322
323	return nil	1✔
324	}
325
326	// GetLogicalRouterStaticRouteByUUID get logical router static route by UUID
327	func (c OVNNbClient) GetLogicalRouterStaticRouteByUUID(uuid string) (ovnnb.LogicalRouterStaticRoute, error) {	1✔
328	ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)	1✔
329	defer cancel()	1✔
330		1✔
331	route := &ovnnb.LogicalRouterStaticRoute{UUID: uuid}	1✔
332	if err := c.Get(ctx, route); err != nil {	1✔
333	klog.Error(err)	×
334	return nil, err	×
335	}	×
336
337	return route, nil	1✔
338	}
339
340	// GetLogicalRouterStaticRoute get logical router static route by some attribute,
341	// a static route is uniquely identified by router(lrName), policy and ipPrefix when route is not ecmp
342	// a static route is uniquely identified by router(lrName), policy, ipPrefix and nexthop when route is ecmp
343	func (c OVNNbClient) GetLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop string, ignoreNotFound bool) (ovnnb.LogicalRouterStaticRoute, error) {	1✔
344	// this is necessary because may exist same static route in different logical router	1✔
345	if len(lrName) == 0 {	2✔
346	return nil, errors.New("the logical router name is required")	1✔
347	}	1✔
348
349	fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {	2✔
350	return route.RouteTable == routeTable && route.Policy != nil && *route.Policy == policy && route.IPPrefix == ipPrefix && route.Nexthop == nexthop	1✔
351	}	1✔
352	routeList, err := c.listLogicalRouterStaticRoutesByFilter(lrName, fnFilter)	1✔
353	if err != nil {	2✔
354	klog.Error(err)	1✔
355	return nil, fmt.Errorf("get logical router %s static route 'policy %s ip_prefix %s nexthop %s': %w", lrName, policy, ipPrefix, nexthop, err)	1✔
356	}	1✔
357
358	// not found
359	if len(routeList) == 0 {	2✔
360	if ignoreNotFound {	2✔
361	return nil, nil	1✔
362	}	1✔
363	return nil, fmt.Errorf("not found logical router %s static route 'policy %s ip_prefix %s nexthop %s'", lrName, policy, ipPrefix, nexthop)	1✔
364	}
365
366	if len(routeList) > 1 {	2✔
367	return nil, fmt.Errorf("more than one static route 'policy %s ip_prefix %s nexthop %s' in logical router %s", policy, ipPrefix, nexthop, lrName)	1✔
368	}	1✔
369
370	return routeList[0], nil	1✔
371	}
372
373	// ListLogicalRouterStaticRoutes list route which match the given externalIDs
374	func (c OVNNbClient) ListLogicalRouterStaticRoutes(lrName string, routeTable, policy string, ipPrefix string, externalIDs map[string]string) ([]*ovnnb.LogicalRouterStaticRoute, error) {	1✔
375	fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {	2✔
376	if len(route.ExternalIDs) < len(externalIDs) {	2✔
377	return false	1✔
378	}	1✔
379
380	if len(route.ExternalIDs) != 0 {	2✔
381	for k, v := range externalIDs {	2✔
382	// if only key exist but not value in externalIDs, we should include this route,	1✔
383	// it's equal to shell command `ovn-nbctl --columns=xx find logical_router_static_route external_ids:key!=\"\"`	1✔
384	if len(v) == 0 {	2✔
385	if len(route.ExternalIDs[k]) == 0 {	2✔
386	return false	1✔
387	}	1✔
388	} else {	1✔
389	if route.ExternalIDs[k] != v {	2✔
390	return false	1✔
391	}	1✔
392	}
393	}
394	}
395
396	if routeTable != nil && route.RouteTable != *routeTable {	2✔
397	return false	1✔
398	}	1✔
399	if policy != nil {	2✔
400	if route.Policy != nil {	2✔
401	if route.Policy != policy {	2✔
402	return false	1✔
403	}	1✔
404	} else if *policy != ovnnb.LogicalRouterStaticRoutePolicyDstIP {	×
405	return false	×
406	}	×
407	}
408	if ipPrefix != "" && route.IPPrefix != ipPrefix {	2✔
409	return false	1✔
410	}	1✔
411
412	return true	1✔
413	}
414
415	return c.listLogicalRouterStaticRoutesByFilter(lrName, fnFilter)	1✔
416	}
417
418	func (c *OVNNbClient) LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop string) (bool, error) {	1✔
419	route, err := c.GetLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop, true)	1✔
420	return route != nil, err	1✔
421	}	1✔
422
423	// newLogicalRouterStaticRoute return logical router static route with basic information
424	func (c OVNNbClient) newLogicalRouterStaticRoute(lrName, routeTable, policy, ipPrefix, nexthop string, bfdID string, externalIDs map[string]string, options ...func(route ovnnb.LogicalRouterStaticRoute)) (ovnnb.LogicalRouterStaticRoute, error) {	1✔
425	if len(lrName) == 0 {	2✔
426	return nil, errors.New("the logical router name is required")	1✔
427	}	1✔
428
429	if len(policy) == 0 {	2✔
430	policy = ovnnb.LogicalRouterStaticRoutePolicyDstIP	1✔
431	}	1✔
432
433	exists, err := c.LogicalRouterStaticRouteExists(lrName, routeTable, policy, ipPrefix, nexthop)	1✔
434	if err != nil {	1✔
435	klog.Error(err)	×
436	return nil, fmt.Errorf("get logical router %s route: %w", lrName, err)	×
437	}	×
438
439	// found, ignore
440	if exists {	2✔
441	return nil, nil	1✔
442	}	1✔
443
444	route := &ovnnb.LogicalRouterStaticRoute{	1✔
445	UUID: ovsclient.NamedUUID(),	1✔
446	Policy: &policy,	1✔
447	IPPrefix: ipPrefix,	1✔
448	Nexthop: nexthop,	1✔
449	RouteTable: routeTable,	1✔
450	ExternalIDs: externalIDs,	1✔
451	}	1✔
452	for _, option := range options {	2✔
453	option(route)	1✔
454	}	1✔
455
456	if bfdID != nil {	2✔
457	route.BFD = bfdID	1✔
458	if route.Options == nil {	2✔
459	route.Options = make(map[string]string)	1✔
460	}	1✔
461	route.Options[util.StaticRouteBfdEcmp] = "true"	1✔
462	}
463	return route, nil	1✔
464	}
465
466	func (c OVNNbClient) listLogicalRouterStaticRoutesByFilter(lrName string, filter func(route ovnnb.LogicalRouterStaticRoute) bool) ([]*ovnnb.LogicalRouterStaticRoute, error) {	1✔
467	lr, err := c.GetLogicalRouter(lrName, false)	1✔
468	if err != nil {	2✔
469	klog.Error(err)	1✔
470	return nil, err	1✔
471	}	1✔
472
473	routeList := make([]*ovnnb.LogicalRouterStaticRoute, 0, len(lr.StaticRoutes))	1✔
474	for _, uuid := range lr.StaticRoutes {	2✔
475	route, err := c.GetLogicalRouterStaticRouteByUUID(uuid)	1✔
476	if err != nil {	1✔
477	if errors.Is(err, client.ErrNotFound) {	×
478	continue	×
479	}
480	klog.Error(err)	×
481	return nil, err	×
482	}
483	if filter == nil \|\| filter(route) {	2✔
484	routeList = append(routeList, route)	1✔
485	}	1✔
486	}
487
488	return routeList, nil	1✔
489	}
490
491	// batchListLogicalRouterStaticRoutesForDelete batch list route which match the given condition when need delete static route
492	func (c OVNNbClient) batchListLogicalRouterStaticRoutesForDelete(staticRoutes map[string]string, lrStaticRoute []string) ([]ovnnb.LogicalRouterStaticRoute, error) {	1✔
493	lrStaticRouteSet := set.New(lrStaticRoute...)	1✔
494	fnFilter := func(route *ovnnb.LogicalRouterStaticRoute) bool {	2✔
495	if !lrStaticRouteSet.Has(route.UUID) {	1✔
496	return false	×
497	}	×
498
499	if route.Policy == nil {	1✔
500	route.Policy = &ovnnb.LogicalRouterStaticRoutePolicyDstIP	×
501	}	×
502
503	key := createStaticRouteKey(route.RouteTable, *route.Policy, route.IPPrefix)	1✔
504	_, exists := staticRoutes[key]	1✔
505	return exists	1✔
506	}
507
508	ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)	1✔
509	defer cancel()	1✔
510		1✔
511	routeList := make([]*ovnnb.LogicalRouterStaticRoute, 0)	1✔
512	if err := c.ovsDbClient.WhereCache(fnFilter).List(ctx, &routeList); err != nil {	1✔
513	klog.Error(err)	×
514	return nil, fmt.Errorf("batch list logical staric router %v lr staric route %v route: %w", staticRoutes, lrStaticRoute, err)	×
515	}	×
516
517	return routeList, nil	1✔
518	}
519
520	func createStaticRouteKey(routeTable, policy, ipPrefix string) string {	1✔
521	return fmt.Sprintf("%s-%s-%s", routeTable, policy, ipPrefix)	1✔
522	}	1✔

kubeovn / kube-ovn / 16414518284

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