13425935899

Committed 20 Feb 2025 01:32AM UTC coverage: 22.263% (+0.2%) from 22.068%

Build # 13425935899

Build Type

Pull #4991

github

Committed by

zhangzujian

Commit Message

wip

Signed-off-by: zhangzujian <zhangzujian.7@gmail.com>

Pull Request Pull Request #4991: add support for internalTrafficPolicy=Local

Run Details

175 of 617 new or added lines in 13 files covered. (28.36%)

8 existing lines in 5 files now uncovered.

10436 of 46876 relevant lines covered (22.26%)

0.26 hits per line

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

77.27

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

package ovs

import (
        "context"
        "fmt"
        "net"
        "slices"
        "sort"
        "strconv"
        "strings"

        "github.com/ovn-org/libovsdb/model"
        "github.com/ovn-org/libovsdb/ovsdb"
        "k8s.io/klog/v2"

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

// CreateLoadBalancer create loadbalancer
func (c *OVNNbClient) CreateLoadBalancer(lbName, protocol, selectFields string, template bool) error {
        var (
                exist bool
                err   error
        )

        if exist, err = c.LoadBalancerExists(lbName); err != nil {
                klog.Errorf("failed to get lb: %v", err)
                return err
        }
        // found, ignore
        if exist {
                return nil
        }

        var (
                ops []ovsdb.Operation
                lb  *ovnnb.LoadBalancer
        )

        lb = &ovnnb.LoadBalancer{
                UUID:     ovsclient.NamedUUID(),
                Name:     lbName,
                Protocol: &protocol,
        }
        if template {
                lb.Options = map[string]string{"template": "true"}
        }

        if len(selectFields) != 0 {
                lb.SelectionFields = []string{selectFields}
        }

        if ops, err = c.ovsDbClient.Create(lb); err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for creating load balancer %s: %w", lbName, err)
        }

        if err = c.Transact("lb-add", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("create load balancer %s: %w", lbName, err)
        }
        return nil
}

// UpdateLoadBalancer update load balancer
func (c *OVNNbClient) UpdateLoadBalancer(lb *ovnnb.LoadBalancer, fields ...interface{}) error {
        var (
                ops []ovsdb.Operation
                err error
        )

        if ops, err = c.ovsDbClient.Where(lb).Update(lb, fields...); err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for updating load balancer %s: %w", lb.Name, err)
        }

        if err = c.Transact("lb-update", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("update load balancer %s: %w", lb.Name, err)
        }
        return nil
}

// LoadBalancerAddVips adds or updates a vip
func (c *OVNNbClient) LoadBalancerAddVip(lbName, vip string, backends ...string) error {
        var (
                ops []ovsdb.Operation
                err error
        )

        if _, err = c.GetLoadBalancer(lbName, false); err != nil {
                klog.Errorf("failed to get lb health check: %v", err)
                return err
        }

        sort.Strings(backends)
        if ops, err = c.LoadBalancerOp(
                lbName,
                func(lb *ovnnb.LoadBalancer) []model.Mutation {
                        var (
                                mutations = make([]model.Mutation, 0, 2)
                                value     = strings.Join(backends, ",")
                        )

                        if len(lb.Vips) != 0 {
                                if lb.Vips[vip] == value {
                                        return nil
                                }
                                mutations = append(
                                        mutations,
                                        model.Mutation{
                                                Field:   &lb.Vips,
                                                Value:   map[string]string{vip: lb.Vips[vip]},
                                                Mutator: ovsdb.MutateOperationDelete,
                                        },
                                )
                        }
                        mutations = append(
                                mutations,
                                model.Mutation{
                                        Field:   &lb.Vips,
                                        Value:   map[string]string{vip: value},
                                        Mutator: ovsdb.MutateOperationInsert,
                                },
                        )
                        return mutations
                },
        ); err != nil {
                return fmt.Errorf("failed to generate operations when adding vip %s with backends %v to load balancers %s: %w", vip, backends, lbName, err)
        }

        if ops != nil {
                if err = c.Transact("lb-add", ops); err != nil {
                        klog.Error(err)
                        return fmt.Errorf("failed to add vip %s with backends %v to load balancers %s: %w", vip, backends, lbName, err)
                }
        }
        return nil
}

// LoadBalancerDeleteVip deletes load balancer vip
func (c *OVNNbClient) LoadBalancerDeleteVip(lbName, vipEndpoint string, ignoreHealthCheck bool) error {
        var (
                ops  []ovsdb.Operation
                lb   *ovnnb.LoadBalancer
                lbhc *ovnnb.LoadBalancerHealthCheck
                err  error
        )

        lb, lbhc, err = c.GetLoadBalancerHealthCheck(lbName, vipEndpoint, true)
        if err != nil {
                klog.Errorf("failed to get lb health check: %v", err)
                return err
        }
        if !ignoreHealthCheck && lbhc != nil {
                klog.Infof("clean health check for lb %s with vip %s", lbName, vipEndpoint)
                // delete ip port mapping
                if err = c.LoadBalancerDeleteIPPortMapping(lbName, vipEndpoint); err != nil {
                        klog.Errorf("failed to delete lb ip port mapping: %v", err)
                        return err
                }
                if err = c.LoadBalancerDeleteHealthCheck(lbName, lbhc.UUID); err != nil {
                        klog.Errorf("failed to delete lb health check: %v", err)
                        return err
                }
        }
        if lb == nil || len(lb.Vips) == 0 {
                return nil
        }
        if _, ok := lb.Vips[vipEndpoint]; !ok {
                return nil
        }

        ops, err = c.LoadBalancerOp(
                lbName,
                func(lb *ovnnb.LoadBalancer) []model.Mutation {
                        return []model.Mutation{
                                {
                                        Field:   &lb.Vips,
                                        Value:   map[string]string{vipEndpoint: lb.Vips[vipEndpoint]},
                                        Mutator: ovsdb.MutateOperationDelete,
                                },
                        }
                },
        )
        if err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to generate operations when deleting vip %s from load balancers %s: %w", vipEndpoint, lbName, err)
        }
        if len(ops) == 0 {
                return nil
        }

        if err = c.Transact("lb-add", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to delete vip %s from load balancers %s: %w", vipEndpoint, lbName, err)
        }
        return nil
}

// SetLoadBalancerAffinityTimeout sets the LB's affinity timeout in seconds
func (c *OVNNbClient) SetLoadBalancerAffinityTimeout(lbName string, timeout int) error {
        var (
                options map[string]string
                lb      *ovnnb.LoadBalancer
                value   string
                err     error
        )

        if lb, err = c.GetLoadBalancer(lbName, false); err != nil {
                klog.Errorf("failed to get lb: %v", err)
                return err
        }

        if value = strconv.Itoa(timeout); len(lb.Options) != 0 && lb.Options["affinity_timeout"] == value {
                return nil
        }

        options = make(map[string]string, len(lb.Options)+1)
        for k, v := range lb.Options {
                options[k] = v
        }
        options["affinity_timeout"] = value

        lb.Options = options
        if err = c.UpdateLoadBalancer(lb, &lb.Options); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to set affinity timeout of lb %s to %d: %w", lbName, timeout, err)
        }
        return nil
}

// DeleteLoadBalancers delete several loadbalancer once
func (c *OVNNbClient) DeleteLoadBalancers(filter func(lb *ovnnb.LoadBalancer) bool) error {
        var (
                ops []ovsdb.Operation
                err error
        )

        if ops, err = c.ovsDbClient.WhereCache(
                func(lb *ovnnb.LoadBalancer) bool {
                        if filter != nil {
                                return filter(lb)
                        }
                        return true
                },
        ).Delete(); err != nil {
                klog.Error(err)
                return fmt.Errorf("generate operations for delete load balancers: %w", err)
        }

        if err = c.Transact("lb-del", ops); err != nil {
                klog.Errorf("failed to del lbs: %v", err)
                return fmt.Errorf("delete load balancers : %w", err)
        }
        return nil
}

// DeleteLoadBalancer delete loadbalancer
func (c *OVNNbClient) DeleteLoadBalancer(lbName string) error {
        var (
                ops []ovsdb.Operation
                err error
        )

        ops, err = c.DeleteLoadBalancerOp(lbName)
        if err != nil {
                klog.Errorf("failed to get delete lb op: %v", err)
                return err
        }

        if err = c.Transact("lb-del", ops); err != nil {
                klog.Errorf("failed to del lb: %v", err)
                return fmt.Errorf("delete load balancer %s: %w", lbName, err)
        }
        return nil
}

// GetLoadBalancer get load balancer by name,
// it is because of lack name index that does't use OVNNbClient.Get
func (c *OVNNbClient) GetLoadBalancer(lbName string, ignoreNotFound bool) (*ovnnb.LoadBalancer, error) {
        ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
        defer cancel()

        var (
                lbList []ovnnb.LoadBalancer
                err    error
        )

        lbList = make([]ovnnb.LoadBalancer, 0)
        if err = c.ovsDbClient.WhereCache(
                func(lb *ovnnb.LoadBalancer) bool {
                        return lb.Name == lbName
                },
        ).List(ctx, &lbList); err != nil {
                klog.Error(err)
                return nil, fmt.Errorf("failed to list load balancer %q: %w", lbName, err)
        }

        switch {
        // not found
        case len(lbList) == 0:
                if ignoreNotFound {
                        return nil, nil
                }
                return nil, fmt.Errorf("not found load balancer %q", lbName)
        case len(lbList) > 1:
                return nil, fmt.Errorf("more than one load balancer with same name %q", lbName)
        default:
                // #nosec G602
                return &lbList[0], nil
        }
}

func (c *OVNNbClient) LoadBalancerExists(lbName string) (bool, error) {
        lrp, err := c.GetLoadBalancer(lbName, true)
        return lrp != nil, err
}

// ListLoadBalancers list all load balancers
func (c *OVNNbClient) ListLoadBalancers(filter func(lb *ovnnb.LoadBalancer) bool) ([]ovnnb.LoadBalancer, error) {
        ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
        defer cancel()

        var (
                lbList []ovnnb.LoadBalancer
                err    error
        )

        lbList = make([]ovnnb.LoadBalancer, 0)
        if err = c.ovsDbClient.WhereCache(
                func(lb *ovnnb.LoadBalancer) bool {
                        if filter != nil {
                                return filter(lb)
                        }

                        return true
                },
        ).List(ctx, &lbList); err != nil {
                klog.Error(err)
                return nil, fmt.Errorf("failed to list load balancer: %w", err)
        }
        return lbList, nil
}

func (c *OVNNbClient) LoadBalancerOp(lbName string, mutationsFunc ...func(lb *ovnnb.LoadBalancer) []model.Mutation) ([]ovsdb.Operation, error) {
        var (
                mutations []model.Mutation
                ops       []ovsdb.Operation
                lb        *ovnnb.LoadBalancer
                err       error
        )

        if lb, err = c.GetLoadBalancer(lbName, false); err != nil {
                klog.Error(err)
                return nil, err
        }

        if len(mutationsFunc) == 0 {
                return nil, nil
        }

        mutations = make([]model.Mutation, 0, len(mutationsFunc))
        for _, f := range mutationsFunc {
                if mutation := f(lb); mutation != nil {
                        mutations = append(mutations, mutation...)
                }
        }
        if len(mutations) == 0 {
                return nil, nil
        }

        if ops, err = c.ovsDbClient.Where(lb).Mutate(lb, mutations...); err != nil {
                klog.Error(err)
                return nil, fmt.Errorf("generate operations for mutating load balancer %s: %w", lb.Name, err)
        }
        return ops, nil
}

// DeleteLoadBalancerOp create operation which delete load balancer
func (c *OVNNbClient) DeleteLoadBalancerOp(lbName string) ([]ovsdb.Operation, error) {
        var (
                ops []ovsdb.Operation
                lb  *ovnnb.LoadBalancer
                err error
        )

        if lb, err = c.GetLoadBalancer(lbName, true); err != nil {
                klog.Error(err)
                return nil, err
        }
        // not found, skip
        if lb == nil {
                return nil, nil
        }

        if ops, err = c.Where(lb).Delete(); err != nil {
                klog.Error(err)
                return nil, err
        }
        return ops, nil
}

// LoadBalancerAddIPPortMapping add load balancer ip port mapping
func (c *OVNNbClient) LoadBalancerAddIPPortMapping(lbName, vipEndpoint string, mappings map[string]string) error {
        if len(mappings) == 0 {
                return nil
        }

        var (
                ops []ovsdb.Operation
                err error
        )

        if ops, err = c.LoadBalancerOp(
                lbName,
                func(lb *ovnnb.LoadBalancer) []model.Mutation {
                        return []model.Mutation{
                                {
                                        Field:   &lb.IPPortMappings,
                                        Value:   mappings,
                                        Mutator: ovsdb.MutateOperationInsert,
                                },
                        }
                },
        ); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to generate operations when adding ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)
        }

        if err = c.Transact("lb-add", ops); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to add ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)
        }
        return nil
}

// LoadBalancerDeleteIPPortMapping delete load balancer ip port mapping
func (c *OVNNbClient) LoadBalancerDeleteIPPortMapping(lbName, vipEndpoint string) error {
        var (
                ops      []ovsdb.Operation
                lb       *ovnnb.LoadBalancer
                mappings map[string]string
                vip      string
                err      error
        )

        if lb, err = c.GetLoadBalancer(lbName, true); err != nil {
                klog.Errorf("failed to get lb health check: %v", err)
                return err
        }

        if lb == nil {
                klog.Infof("lb %s already deleted", lbName)
                return nil
        }
        if len(lb.IPPortMappings) == 0 {
                klog.Infof("lb %s has no ip port mapping", lbName)
                return nil
        }

        if vip, _, err = net.SplitHostPort(vipEndpoint); err != nil {
                err := fmt.Errorf("failed to split host port: %w", err)
                klog.Error(err)
                return err
        }

        mappings = lb.IPPortMappings
        for portIP, portMapVip := range lb.IPPortMappings {
                splits := strings.Split(portMapVip, ":")
                if len(splits) == 2 && splits[1] == vip {
                        delete(mappings, portIP)
                }
        }

        if ops, err = c.LoadBalancerOp(
                lbName,
                func(lb *ovnnb.LoadBalancer) []model.Mutation {
                        return []model.Mutation{
                                {
                                        Field:   &lb.IPPortMappings,
                                        Value:   mappings,
                                        Mutator: ovsdb.MutateOperationDelete,
                                },
                        }
                },
        ); err != nil {
                klog.Error(err)
                return fmt.Errorf("failed to generate operations when deleting ip port mapping %s from load balancers %s: %w", vipEndpoint, lbName, err)
        }
        if len(ops) == 0 {
                return nil
        }
        if err = c.Transact("lb-del", ops); err != nil {
                return fmt.Errorf("failed to delete ip port mappings %s from load balancer %s: %w", vipEndpoint, lbName, err)
        }
        return nil
}

// LoadBalancerUpdateIPPortMapping update load balancer ip port mapping
func (c *OVNNbClient) LoadBalancerUpdateIPPortMapping(lbName, vipEndpoint string, ipPortMappings map[string]string) error {
        if len(ipPortMappings) != 0 {
                ops, err := c.LoadBalancerOp(
                        lbName,
                        func(lb *ovnnb.LoadBalancer) []model.Mutation {
                                return []model.Mutation{
                                        {
                                                Field:   &lb.IPPortMappings,
                                                Value:   ipPortMappings,
                                                Mutator: ovsdb.MutateOperationInsert,
                                        },
                                }
                        },
                )
                if err != nil {
                        return fmt.Errorf("failed to generate operations when adding ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)
                }
                if err = c.Transact("lb-add", ops); err != nil {
                        return fmt.Errorf("failed to add ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)
                }
        }
        return nil
}

// LoadBalancerAddHealthCheck adds health check
func (c *OVNNbClient) LoadBalancerAddHealthCheck(lbName, vipEndpoint string, ignoreHealthCheck bool, ipPortMapping, externals map[string]string) error {
        klog.Infof("lb %s health check use ip port mapping %v", lbName, ipPortMapping)
        if err := c.LoadBalancerUpdateIPPortMapping(lbName, vipEndpoint, ipPortMapping); err != nil {
                klog.Errorf("failed to update lb ip port mapping: %v", err)
                return err
        }
        if !ignoreHealthCheck {
                klog.Infof("add health check for lb %s with vip %s and health check vip maps %v", lbName, vipEndpoint, ipPortMapping)
                if err := c.AddLoadBalancerHealthCheck(lbName, vipEndpoint, externals); err != nil {
                        klog.Errorf("failed to create lb health check: %v", err)
                        return err
                }
        }
        return nil
}

// LoadBalancerDeleteHealthCheck delete load balancer health check
func (c *OVNNbClient) LoadBalancerDeleteHealthCheck(lbName, uuid string) error {
        var (
                ops []ovsdb.Operation
                lb  *ovnnb.LoadBalancer
                err error
        )

        if lb, err = c.GetLoadBalancer(lbName, false); err != nil {
                klog.Errorf("failed to get lb: %v", err)
                return err
        }

        if slices.Contains(lb.HealthCheck, uuid) {
                ops, err = c.LoadBalancerOp(
                        lbName,
                        func(lb *ovnnb.LoadBalancer) []model.Mutation {
                                return []model.Mutation{
                                        {
                                                Field:   &lb.HealthCheck,
                                                Value:   []string{uuid},
                                                Mutator: ovsdb.MutateOperationDelete,
                                        },
                                }
                        },
                )
                if err != nil {
                        return fmt.Errorf("failed to generate operations when deleting health check %s from load balancers %s: %w", uuid, lbName, err)
                }
                if len(ops) == 0 {
                        return nil
                }
                if err = c.Transact("lb-hc-del", ops); err != nil {
                        return fmt.Errorf("failed to delete health check %s from load balancers %s: %w", uuid, lbName, err)
                }
        }

        return nil
}

// LoadBalancerUpdateHealthCheckOp create operations add to or delete health check from it
func (c *OVNNbClient) LoadBalancerUpdateHealthCheckOp(lbName string, lbhcUUIDs []string, op ovsdb.Mutator) ([]ovsdb.Operation, error) {
        if len(lbhcUUIDs) == 0 {
                return nil, nil
        }

        return c.LoadBalancerOp(
                lbName,
                func(lb *ovnnb.LoadBalancer) []model.Mutation {
                        return []model.Mutation{
                                {
                                        Field:   &lb.HealthCheck,
                                        Value:   lbhcUUIDs,
                                        Mutator: op,
                                },
                        }
                },
        )
}

1	package ovs
2
3	import (
4	"context"
5	"fmt"
6	"net"
7	"slices"
8	"sort"
9	"strconv"
10	"strings"
11
12	"github.com/ovn-org/libovsdb/model"
13	"github.com/ovn-org/libovsdb/ovsdb"
14	"k8s.io/klog/v2"
15
16	ovsclient "github.com/kubeovn/kube-ovn/pkg/ovsdb/client"
17	"github.com/kubeovn/kube-ovn/pkg/ovsdb/ovnnb"
18	)
19
20	// CreateLoadBalancer create loadbalancer
21	func (c *OVNNbClient) CreateLoadBalancer(lbName, protocol, selectFields string, template bool) error {	1✔
22	var (	1✔
23	exist bool	1✔
24	err error	1✔
25	)	1✔
26		1✔
27	if exist, err = c.LoadBalancerExists(lbName); err != nil {	2✔
28	klog.Errorf("failed to get lb: %v", err)	1✔
29	return err	1✔
30	}	1✔
31	// found, ignore
32	if exist {	2✔
33	return nil	1✔
34	}	1✔
35
36	var (	1✔
37	ops []ovsdb.Operation	1✔
38	lb *ovnnb.LoadBalancer	1✔
39	)	1✔
40		1✔
41	lb = &ovnnb.LoadBalancer{	1✔
42	UUID: ovsclient.NamedUUID(),	1✔
43	Name: lbName,	1✔
44	Protocol: &protocol,	1✔
45	}	1✔
46	if template {	1✔
NEW 47	lb.Options = map[string]string{"template": "true"}	×
NEW 48	}	×
49
50	if len(selectFields) != 0 {	2✔
51	lb.SelectionFields = []string{selectFields}	1✔
52	}	1✔
53
54	if ops, err = c.ovsDbClient.Create(lb); err != nil {	1✔
55	klog.Error(err)	×
56	return fmt.Errorf("generate operations for creating load balancer %s: %w", lbName, err)	×
57	}	×
58
59	if err = c.Transact("lb-add", ops); err != nil {	1✔
60	klog.Error(err)	×
61	return fmt.Errorf("create load balancer %s: %w", lbName, err)	×
62	}	×
63	return nil	1✔
64	}
65
66	// UpdateLoadBalancer update load balancer
67	func (c OVNNbClient) UpdateLoadBalancer(lb ovnnb.LoadBalancer, fields ...interface{}) error {	1✔
68	var (	1✔
69	ops []ovsdb.Operation	1✔
70	err error	1✔
71	)	1✔
72		1✔
73	if ops, err = c.ovsDbClient.Where(lb).Update(lb, fields...); err != nil {	1✔
74	klog.Error(err)	×
75	return fmt.Errorf("generate operations for updating load balancer %s: %w", lb.Name, err)	×
76	}	×
77
78	if err = c.Transact("lb-update", ops); err != nil {	1✔
79	klog.Error(err)	×
80	return fmt.Errorf("update load balancer %s: %w", lb.Name, err)	×
81	}	×
82	return nil	1✔
83	}
84
85	// LoadBalancerAddVips adds or updates a vip
86	func (c *OVNNbClient) LoadBalancerAddVip(lbName, vip string, backends ...string) error {	1✔
87	var (	1✔
88	ops []ovsdb.Operation	1✔
89	err error	1✔
90	)	1✔
91		1✔
92	if _, err = c.GetLoadBalancer(lbName, false); err != nil {	2✔
93	klog.Errorf("failed to get lb health check: %v", err)	1✔
94	return err	1✔
95	}	1✔
96
97	sort.Strings(backends)	1✔
98	if ops, err = c.LoadBalancerOp(	1✔
99	lbName,	1✔
100	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
101	var (	1✔
102	mutations = make([]model.Mutation, 0, 2)	1✔
103	value = strings.Join(backends, ",")	1✔
104	)	1✔
105		1✔
106	if len(lb.Vips) != 0 {	2✔
107	if lb.Vips[vip] == value {	1✔
108	return nil	×
109	}	×
110	mutations = append(	1✔
111	mutations,	1✔
112	model.Mutation{	1✔
113	Field: &lb.Vips,	1✔
114	Value: map[string]string{vip: lb.Vips[vip]},	1✔
115	Mutator: ovsdb.MutateOperationDelete,	1✔
116	},	1✔
117	)	1✔
118	}
119	mutations = append(	1✔
120	mutations,	1✔
121	model.Mutation{	1✔
122	Field: &lb.Vips,	1✔
123	Value: map[string]string{vip: value},	1✔
124	Mutator: ovsdb.MutateOperationInsert,	1✔
125	},	1✔
126	)	1✔
127	return mutations	1✔
128	},
129	); err != nil {	×
130	return fmt.Errorf("failed to generate operations when adding vip %s with backends %v to load balancers %s: %w", vip, backends, lbName, err)	×
131	}	×
132
133	if ops != nil {	2✔
134	if err = c.Transact("lb-add", ops); err != nil {	1✔
135	klog.Error(err)	×
136	return fmt.Errorf("failed to add vip %s with backends %v to load balancers %s: %w", vip, backends, lbName, err)	×
137	}	×
138	}
139	return nil	1✔
140	}
141
142	// LoadBalancerDeleteVip deletes load balancer vip
143	func (c *OVNNbClient) LoadBalancerDeleteVip(lbName, vipEndpoint string, ignoreHealthCheck bool) error {	1✔
144	var (	1✔
145	ops []ovsdb.Operation	1✔
146	lb *ovnnb.LoadBalancer	1✔
147	lbhc *ovnnb.LoadBalancerHealthCheck	1✔
148	err error	1✔
149	)	1✔
150		1✔
151	lb, lbhc, err = c.GetLoadBalancerHealthCheck(lbName, vipEndpoint, true)	1✔
152	if err != nil {	2✔
153	klog.Errorf("failed to get lb health check: %v", err)	1✔
154	return err	1✔
155	}	1✔
156	if !ignoreHealthCheck && lbhc != nil {	2✔
157	klog.Infof("clean health check for lb %s with vip %s", lbName, vipEndpoint)	1✔
158	// delete ip port mapping	1✔
159	if err = c.LoadBalancerDeleteIPPortMapping(lbName, vipEndpoint); err != nil {	1✔
160	klog.Errorf("failed to delete lb ip port mapping: %v", err)	×
161	return err	×
162	}	×
163	if err = c.LoadBalancerDeleteHealthCheck(lbName, lbhc.UUID); err != nil {	1✔
164	klog.Errorf("failed to delete lb health check: %v", err)	×
165	return err	×
166	}	×
167	}
168	if lb == nil \|\| len(lb.Vips) == 0 {	2✔
169	return nil	1✔
170	}	1✔
171	if _, ok := lb.Vips[vipEndpoint]; !ok {	2✔
172	return nil	1✔
173	}	1✔
174
175	ops, err = c.LoadBalancerOp(	1✔
176	lbName,	1✔
177	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
178	return []model.Mutation{	1✔
179	{	1✔
180	Field: &lb.Vips,	1✔
181	Value: map[string]string{vipEndpoint: lb.Vips[vipEndpoint]},	1✔
182	Mutator: ovsdb.MutateOperationDelete,	1✔
183	},	1✔
184	}	1✔
185	},	1✔
186	)
187	if err != nil {	1✔
188	klog.Error(err)	×
189	return fmt.Errorf("failed to generate operations when deleting vip %s from load balancers %s: %w", vipEndpoint, lbName, err)	×
190	}	×
191	if len(ops) == 0 {	1✔
192	return nil	×
193	}	×
194
195	if err = c.Transact("lb-add", ops); err != nil {	1✔
196	klog.Error(err)	×
197	return fmt.Errorf("failed to delete vip %s from load balancers %s: %w", vipEndpoint, lbName, err)	×
198	}	×
199	return nil	1✔
200	}
201
202	// SetLoadBalancerAffinityTimeout sets the LB's affinity timeout in seconds
203	func (c *OVNNbClient) SetLoadBalancerAffinityTimeout(lbName string, timeout int) error {	1✔
204	var (	1✔
205	options map[string]string	1✔
206	lb *ovnnb.LoadBalancer	1✔
207	value string	1✔
208	err error	1✔
209	)	1✔
210		1✔
211	if lb, err = c.GetLoadBalancer(lbName, false); err != nil {	2✔
212	klog.Errorf("failed to get lb: %v", err)	1✔
213	return err	1✔
214	}	1✔
215
216	if value = strconv.Itoa(timeout); len(lb.Options) != 0 && lb.Options["affinity_timeout"] == value {	2✔
217	return nil	1✔
218	}	1✔
219
220	options = make(map[string]string, len(lb.Options)+1)	1✔
221	for k, v := range lb.Options {	2✔
222	options[k] = v	1✔
223	}	1✔
224	options["affinity_timeout"] = value	1✔
225		1✔
226	lb.Options = options	1✔
227	if err = c.UpdateLoadBalancer(lb, &lb.Options); err != nil {	1✔
228	klog.Error(err)	×
229	return fmt.Errorf("failed to set affinity timeout of lb %s to %d: %w", lbName, timeout, err)	×
230	}	×
231	return nil	1✔
232	}
233
234	// DeleteLoadBalancers delete several loadbalancer once
235	func (c OVNNbClient) DeleteLoadBalancers(filter func(lb ovnnb.LoadBalancer) bool) error {	1✔
236	var (	1✔
237	ops []ovsdb.Operation	1✔
238	err error	1✔
239	)	1✔
240		1✔
241	if ops, err = c.ovsDbClient.WhereCache(	1✔
242	func(lb *ovnnb.LoadBalancer) bool {	2✔
243	if filter != nil {	2✔
244	return filter(lb)	1✔
245	}	1✔
246	return true	×
247	},
248	).Delete(); err != nil {	×
249	klog.Error(err)	×
250	return fmt.Errorf("generate operations for delete load balancers: %w", err)	×
251	}	×
252
253	if err = c.Transact("lb-del", ops); err != nil {	1✔
254	klog.Errorf("failed to del lbs: %v", err)	×
255	return fmt.Errorf("delete load balancers : %w", err)	×
256	}	×
257	return nil	1✔
258	}
259
260	// DeleteLoadBalancer delete loadbalancer
261	func (c *OVNNbClient) DeleteLoadBalancer(lbName string) error {	1✔
262	var (	1✔
263	ops []ovsdb.Operation	1✔
264	err error	1✔
265	)	1✔
266		1✔
267	ops, err = c.DeleteLoadBalancerOp(lbName)	1✔
268	if err != nil {	1✔
269	klog.Errorf("failed to get delete lb op: %v", err)	×
270	return err	×
271	}	×
272
273	if err = c.Transact("lb-del", ops); err != nil {	1✔
274	klog.Errorf("failed to del lb: %v", err)	×
275	return fmt.Errorf("delete load balancer %s: %w", lbName, err)	×
276	}	×
277	return nil	1✔
278	}
279
280	// GetLoadBalancer get load balancer by name,
281	// it is because of lack name index that does't use OVNNbClient.Get
282	func (c OVNNbClient) GetLoadBalancer(lbName string, ignoreNotFound bool) (ovnnb.LoadBalancer, error) {	1✔
283	ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)	1✔
284	defer cancel()	1✔
285		1✔
286	var (	1✔
287	lbList []ovnnb.LoadBalancer	1✔
288	err error	1✔
289	)	1✔
290		1✔
291	lbList = make([]ovnnb.LoadBalancer, 0)	1✔
292	if err = c.ovsDbClient.WhereCache(	1✔
293	func(lb *ovnnb.LoadBalancer) bool {	2✔
294	return lb.Name == lbName	1✔
295	},	1✔
296	).List(ctx, &lbList); err != nil {	×
297	klog.Error(err)	×
298	return nil, fmt.Errorf("failed to list load balancer %q: %w", lbName, err)	×
299	}	×
300
301	switch {	1✔
302	// not found
303	case len(lbList) == 0:	1✔
304	if ignoreNotFound {	2✔
305	return nil, nil	1✔
306	}	1✔
307	return nil, fmt.Errorf("not found load balancer %q", lbName)	1✔
308	case len(lbList) > 1:	1✔
309	return nil, fmt.Errorf("more than one load balancer with same name %q", lbName)	1✔
310	default:	1✔
311	// #nosec G602	1✔
312	return &lbList[0], nil	1✔
313	}
314	}
315
316	func (c *OVNNbClient) LoadBalancerExists(lbName string) (bool, error) {	1✔
317	lrp, err := c.GetLoadBalancer(lbName, true)	1✔
318	return lrp != nil, err	1✔
319	}	1✔
320
321	// ListLoadBalancers list all load balancers
322	func (c OVNNbClient) ListLoadBalancers(filter func(lb ovnnb.LoadBalancer) bool) ([]ovnnb.LoadBalancer, error) {	1✔
323	ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)	1✔
324	defer cancel()	1✔
325		1✔
326	var (	1✔
327	lbList []ovnnb.LoadBalancer	1✔
328	err error	1✔
329	)	1✔
330		1✔
331	lbList = make([]ovnnb.LoadBalancer, 0)	1✔
332	if err = c.ovsDbClient.WhereCache(	1✔
333	func(lb *ovnnb.LoadBalancer) bool {	2✔
334	if filter != nil {	2✔
335	return filter(lb)	1✔
336	}	1✔
337
338	return true	1✔
339	},
340	).List(ctx, &lbList); err != nil {	×
341	klog.Error(err)	×
342	return nil, fmt.Errorf("failed to list load balancer: %w", err)	×
343	}	×
344	return lbList, nil	1✔
345	}
346
347	func (c OVNNbClient) LoadBalancerOp(lbName string, mutationsFunc ...func(lb ovnnb.LoadBalancer) []model.Mutation) ([]ovsdb.Operation, error) {	1✔
348	var (	1✔
349	mutations []model.Mutation	1✔
350	ops []ovsdb.Operation	1✔
351	lb *ovnnb.LoadBalancer	1✔
352	err error	1✔
353	)	1✔
354		1✔
355	if lb, err = c.GetLoadBalancer(lbName, false); err != nil {	2✔
356	klog.Error(err)	1✔
357	return nil, err	1✔
358	}	1✔
359
360	if len(mutationsFunc) == 0 {	2✔
361	return nil, nil	1✔
362	}	1✔
363
364	mutations = make([]model.Mutation, 0, len(mutationsFunc))	1✔
365	for _, f := range mutationsFunc {	2✔
366	if mutation := f(lb); mutation != nil {	2✔
367	mutations = append(mutations, mutation...)	1✔
368	}	1✔
369	}
370	if len(mutations) == 0 {	2✔
371	return nil, nil	1✔
372	}	1✔
373
374	if ops, err = c.ovsDbClient.Where(lb).Mutate(lb, mutations...); err != nil {	1✔
375	klog.Error(err)	×
376	return nil, fmt.Errorf("generate operations for mutating load balancer %s: %w", lb.Name, err)	×
377	}	×
378	return ops, nil	1✔
379	}
380
381	// DeleteLoadBalancerOp create operation which delete load balancer
382	func (c *OVNNbClient) DeleteLoadBalancerOp(lbName string) ([]ovsdb.Operation, error) {	1✔
383	var (	1✔
384	ops []ovsdb.Operation	1✔
385	lb *ovnnb.LoadBalancer	1✔
386	err error	1✔
387	)	1✔
388		1✔
389	if lb, err = c.GetLoadBalancer(lbName, true); err != nil {	2✔
390	klog.Error(err)	1✔
391	return nil, err	1✔
392	}	1✔
393	// not found, skip
394	if lb == nil {	2✔
395	return nil, nil	1✔
396	}	1✔
397
398	if ops, err = c.Where(lb).Delete(); err != nil {	1✔
399	klog.Error(err)	×
400	return nil, err	×
401	}	×
402	return ops, nil	1✔
403	}
404
405	// LoadBalancerAddIPPortMapping add load balancer ip port mapping
406	func (c *OVNNbClient) LoadBalancerAddIPPortMapping(lbName, vipEndpoint string, mappings map[string]string) error {	1✔
407	if len(mappings) == 0 {	2✔
408	return nil	1✔
409	}	1✔
410
411	var (	1✔
412	ops []ovsdb.Operation	1✔
413	err error	1✔
414	)	1✔
415		1✔
416	if ops, err = c.LoadBalancerOp(	1✔
417	lbName,	1✔
418	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
419	return []model.Mutation{	1✔
420	{	1✔
421	Field: &lb.IPPortMappings,	1✔
422	Value: mappings,	1✔
423	Mutator: ovsdb.MutateOperationInsert,	1✔
424	},	1✔
425	}	1✔
426	},	1✔
427	); err != nil {	×
428	klog.Error(err)	×
429	return fmt.Errorf("failed to generate operations when adding ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)	×
430	}	×
431
432	if err = c.Transact("lb-add", ops); err != nil {	1✔
433	klog.Error(err)	×
434	return fmt.Errorf("failed to add ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)	×
435	}	×
436	return nil	1✔
437	}
438
439	// LoadBalancerDeleteIPPortMapping delete load balancer ip port mapping
440	func (c *OVNNbClient) LoadBalancerDeleteIPPortMapping(lbName, vipEndpoint string) error {	1✔
441	var (	1✔
442	ops []ovsdb.Operation	1✔
443	lb *ovnnb.LoadBalancer	1✔
444	mappings map[string]string	1✔
445	vip string	1✔
446	err error	1✔
447	)	1✔
448		1✔
449	if lb, err = c.GetLoadBalancer(lbName, true); err != nil {	1✔
450	klog.Errorf("failed to get lb health check: %v", err)	×
451	return err	×
452	}	×
453
454	if lb == nil {	1✔
455	klog.Infof("lb %s already deleted", lbName)	×
456	return nil	×
457	}	×
458	if len(lb.IPPortMappings) == 0 {	2✔
459	klog.Infof("lb %s has no ip port mapping", lbName)	1✔
460	return nil	1✔
461	}	1✔
462
463	if vip, _, err = net.SplitHostPort(vipEndpoint); err != nil {	1✔
464	err := fmt.Errorf("failed to split host port: %w", err)	×
465	klog.Error(err)	×
466	return err	×
467	}	×
468
469	mappings = lb.IPPortMappings	1✔
470	for portIP, portMapVip := range lb.IPPortMappings {	2✔
471	splits := strings.Split(portMapVip, ":")	1✔
472	if len(splits) == 2 && splits[1] == vip {	1✔
473	delete(mappings, portIP)	×
474	}	×
475	}
476
477	if ops, err = c.LoadBalancerOp(	1✔
478	lbName,	1✔
479	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
480	return []model.Mutation{	1✔
481	{	1✔
482	Field: &lb.IPPortMappings,	1✔
483	Value: mappings,	1✔
484	Mutator: ovsdb.MutateOperationDelete,	1✔
485	},	1✔
486	}	1✔
487	},	1✔
488	); err != nil {	×
489	klog.Error(err)	×
490	return fmt.Errorf("failed to generate operations when deleting ip port mapping %s from load balancers %s: %w", vipEndpoint, lbName, err)	×
491	}	×
492	if len(ops) == 0 {	1✔
493	return nil	×
494	}	×
495	if err = c.Transact("lb-del", ops); err != nil {	1✔
496	return fmt.Errorf("failed to delete ip port mappings %s from load balancer %s: %w", vipEndpoint, lbName, err)	×
497	}	×
498	return nil	1✔
499	}
500
501	// LoadBalancerUpdateIPPortMapping update load balancer ip port mapping
502	func (c *OVNNbClient) LoadBalancerUpdateIPPortMapping(lbName, vipEndpoint string, ipPortMappings map[string]string) error {	1✔
503	if len(ipPortMappings) != 0 {	2✔
504	ops, err := c.LoadBalancerOp(	1✔
505	lbName,	1✔
506	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
507	return []model.Mutation{	1✔
508	{	1✔
509	Field: &lb.IPPortMappings,	1✔
510	Value: ipPortMappings,	1✔
511	Mutator: ovsdb.MutateOperationInsert,	1✔
512	},	1✔
513	}	1✔
514	},	1✔
515	)
516	if err != nil {	1✔
517	return fmt.Errorf("failed to generate operations when adding ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)	×
518	}	×
519	if err = c.Transact("lb-add", ops); err != nil {	1✔
520	return fmt.Errorf("failed to add ip port mapping with vip %v to load balancers %s: %w", vipEndpoint, lbName, err)	×
521	}	×
522	}
523	return nil	1✔
524	}
525
526	// LoadBalancerAddHealthCheck adds health check
527	func (c *OVNNbClient) LoadBalancerAddHealthCheck(lbName, vipEndpoint string, ignoreHealthCheck bool, ipPortMapping, externals map[string]string) error {	1✔
528	klog.Infof("lb %s health check use ip port mapping %v", lbName, ipPortMapping)	1✔
529	if err := c.LoadBalancerUpdateIPPortMapping(lbName, vipEndpoint, ipPortMapping); err != nil {	1✔
530	klog.Errorf("failed to update lb ip port mapping: %v", err)	×
531	return err	×
532	}	×
533	if !ignoreHealthCheck {	2✔
534	klog.Infof("add health check for lb %s with vip %s and health check vip maps %v", lbName, vipEndpoint, ipPortMapping)	1✔
535	if err := c.AddLoadBalancerHealthCheck(lbName, vipEndpoint, externals); err != nil {	1✔
536	klog.Errorf("failed to create lb health check: %v", err)	×
537	return err	×
538	}	×
539	}
540	return nil	1✔
541	}
542
543	// LoadBalancerDeleteHealthCheck delete load balancer health check
544	func (c *OVNNbClient) LoadBalancerDeleteHealthCheck(lbName, uuid string) error {	1✔
545	var (	1✔
546	ops []ovsdb.Operation	1✔
547	lb *ovnnb.LoadBalancer	1✔
548	err error	1✔
549	)	1✔
550		1✔
551	if lb, err = c.GetLoadBalancer(lbName, false); err != nil {	2✔
552	klog.Errorf("failed to get lb: %v", err)	1✔
553	return err	1✔
554	}	1✔
555
556	if slices.Contains(lb.HealthCheck, uuid) {	2✔
557	ops, err = c.LoadBalancerOp(	1✔
558	lbName,	1✔
559	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
560	return []model.Mutation{	1✔
561	{	1✔
562	Field: &lb.HealthCheck,	1✔
563	Value: []string{uuid},	1✔
564	Mutator: ovsdb.MutateOperationDelete,	1✔
565	},	1✔
566	}	1✔
567	},	1✔
568	)
569	if err != nil {	1✔
570	return fmt.Errorf("failed to generate operations when deleting health check %s from load balancers %s: %w", uuid, lbName, err)	×
571	}	×
572	if len(ops) == 0 {	1✔
573	return nil	×
574	}	×
575	if err = c.Transact("lb-hc-del", ops); err != nil {	1✔
576	return fmt.Errorf("failed to delete health check %s from load balancers %s: %w", uuid, lbName, err)	×
577	}	×
578	}
579
580	return nil	1✔
581	}
582
583	// LoadBalancerUpdateHealthCheckOp create operations add to or delete health check from it
584	func (c *OVNNbClient) LoadBalancerUpdateHealthCheckOp(lbName string, lbhcUUIDs []string, op ovsdb.Mutator) ([]ovsdb.Operation, error) {	1✔
585	if len(lbhcUUIDs) == 0 {	2✔
586	return nil, nil	1✔
587	}	1✔
588
589	return c.LoadBalancerOp(	1✔
590	lbName,	1✔
591	func(lb *ovnnb.LoadBalancer) []model.Mutation {	2✔
592	return []model.Mutation{	1✔
593	{	1✔
594	Field: &lb.HealthCheck,	1✔
595	Value: lbhcUUIDs,	1✔
596	Mutator: op,	1✔
597	},	1✔
598	}	1✔
599	},	1✔
600	)
601	}

kubeovn / kube-ovn / 13425935899

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