9761350290

Committed 02 Jul 2024 12:54PM UTC coverage: 52.629% (-0.02%) from 52.652%

Build # 9761350290

Build Type

Pull #4491

github

Committed by

qinqon

Commit Message

ovnkube-trace: Dump udn vrf table IDs per node

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

Pull Request Pull Request #4491: util: Move route table calculator from egressip

Run Details

3 of 6 new or added lines in 2 files covered. (50.0%)

21 existing lines in 4 files now uncovered.

28921 of 54953 relevant lines covered (52.63%)

99.67 hits per line

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

42.42

/go-controller/pkg/ovn/controller/unidling/unidled_annotation_controller.go

package unidling

import (
        "fmt"
        "strings"
        "time"

        "github.com/ovn-org/ovn-kubernetes/go-controller/pkg/kube"
        kapi "k8s.io/api/core/v1"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        "k8s.io/client-go/tools/cache"
        "k8s.io/klog/v2"
)

const (
        GracePeriodDuration = 30 * time.Second
        IdledAtSuffix       = "/idled-at"
        UnidledAtSuffix     = "/unidled-at"
        UnidledAtAnnotation = "k8s.ovn.org" + UnidledAtSuffix
)

type unidledAtController struct {
        kube kube.Interface
}

// NewUnidledAtController installs a controller on the passed informer. Whenever a service annotation
// like "*/idled-at" is removed from a service, it sets "k8s.ovn.org/unidled-at" with the current time,
// indicating the point in time the service has been unidled.
func NewUnidledAtController(k kube.Interface, serviceInformer cache.SharedIndexInformer) (*unidledAtController, error) {

        uac := &unidledAtController{
                kube: k,
        }

        klog.Info("Setting up event handlers for services")
        _, err := serviceInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
                UpdateFunc: uac.onServiceUpdate,
        })
        if err != nil {
                return nil, err
        }
        return uac, nil
}

// HasIdleAt returns true if the service annotation map contains a key like "*/idled-at"
func HasIdleAt(svc *kapi.Service) bool {
        if svc == nil {
                return false
        }

        if svc.Annotations == nil {
                return false
        }

        for annotationKey := range svc.Annotations {
                if strings.HasSuffix(annotationKey, IdledAtSuffix) {
                        return true
                }
        }

        return false
}

// IsOnGracePeriod return true if the service has been unidled less than 30s (grace period) ago.
func IsOnGracePeriod(svc *kapi.Service) bool {
        ok, unidledAtStr := getUnidleAt(svc)
        if !ok {
                return false
        }

        unidledAtTime, err := time.Parse(time.RFC3339, unidledAtStr)
        if err != nil {
                klog.Warningf("Bad value [%s] for [%s] annotation on service [%s/%s]", unidledAtStr, UnidledAtAnnotation, svc.Namespace, svc.Name)
                return false
        }

        endOfGracePeriod := unidledAtTime.Add(GracePeriodDuration)

        return time.Now().Before(endOfGracePeriod)
}

func (uac *unidledAtController) onServiceUpdate(old, new interface{}) {
        oldSvc := old.(*kapi.Service)
        newSvc := new.(*kapi.Service)

        oldSvcIdleAt := HasIdleAt(oldSvc)
        newSvcIdleAt := HasIdleAt(newSvc)

        if oldSvcIdleAt && !newSvcIdleAt {
                // Service has been unidled, fill the unidled-at annotation with timing
                err := uac.setUnidleAtAnnotation(newSvc)
                if err != nil {
                        utilruntime.HandleError(err)
                }

                return
        }

        if !oldSvcIdleAt && newSvcIdleAt {
                // Service has been idled, remove unidled-at annotation
                err := uac.removeUnidleAtAnnotation(newSvc)
                if err != nil {
                        utilruntime.HandleError(err)
                }

                return
        }

}

func (uac *unidledAtController) setUnidleAtAnnotation(svc *kapi.Service) error {

        nowStr := time.Now().Format(time.RFC3339)
        err := uac.kube.SetAnnotationsOnService(svc.Namespace, svc.Name, map[string]interface{}{
                UnidledAtAnnotation: nowStr,
        })
        if err != nil {
                return fmt.Errorf("can't set service [%s/%s] unidle-at annotation to [%s]: %w", svc.Namespace, svc.Name, nowStr, err)
        }

        return nil
}

func (uac *unidledAtController) removeUnidleAtAnnotation(svc *kapi.Service) error {

        if svc.Annotations == nil {
                return nil
        }

        _, annotationPresent := svc.Annotations[UnidledAtAnnotation]
        if !annotationPresent {
                klog.V(5).Infof("Service [%s/%s] does not have annotation %s, no need to remove it", svc.Namespace, svc.Name, UnidledAtAnnotation)
                return nil
        }

        err := uac.kube.SetAnnotationsOnService(svc.Namespace, svc.Name, map[string]interface{}{
                UnidledAtAnnotation: nil,
        })
        if err != nil {
                return fmt.Errorf("can't remove service unidle-at annotation: %w", err)
        }

        return nil
}

func getUnidleAt(svc *kapi.Service) (bool, string) {
        if svc == nil {
                return false, ""
        }

        if svc.Annotations == nil {
                return false, ""
        }

        for annotationKey, value := range svc.Annotations {
                if strings.HasSuffix(annotationKey, UnidledAtSuffix) {
                        return true, value
                }
        }

        return false, ""
}

1	package unidling
2
3	import (
4	"fmt"
5	"strings"
6	"time"
7
8	"github.com/ovn-org/ovn-kubernetes/go-controller/pkg/kube"
9	kapi "k8s.io/api/core/v1"
10	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
11	"k8s.io/client-go/tools/cache"
12	"k8s.io/klog/v2"
13	)
14
15	const (
16	GracePeriodDuration = 30 * time.Second
17	IdledAtSuffix = "/idled-at"
18	UnidledAtSuffix = "/unidled-at"
19	UnidledAtAnnotation = "k8s.ovn.org" + UnidledAtSuffix
20	)
21
22	type unidledAtController struct {
23	kube kube.Interface
24	}
25
26	// NewUnidledAtController installs a controller on the passed informer. Whenever a service annotation
27	// like "*/idled-at" is removed from a service, it sets "k8s.ovn.org/unidled-at" with the current time,
28	// indicating the point in time the service has been unidled.
29	func NewUnidledAtController(k kube.Interface, serviceInformer cache.SharedIndexInformer) (*unidledAtController, error) {	1✔
30		1✔
31	uac := &unidledAtController{	1✔
32	kube: k,	1✔
33	}	1✔
34		1✔
35	klog.Info("Setting up event handlers for services")	1✔
36	_, err := serviceInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{	1✔
37	UpdateFunc: uac.onServiceUpdate,	1✔
38	})	1✔
39	if err != nil {	1✔
40	return nil, err	×
41	}	×
42	return uac, nil	1✔
43	}
44
45	// HasIdleAt returns true if the service annotation map contains a key like "*/idled-at"
46	func HasIdleAt(svc *kapi.Service) bool {	2✔
47	if svc == nil {	2✔
48	return false	×
49	}	×
50
51	if svc.Annotations == nil {	3✔
52	return false	1✔
53	}	1✔
54
55	for annotationKey := range svc.Annotations {	2✔
56	if strings.HasSuffix(annotationKey, IdledAtSuffix) {	2✔
57	return true	1✔
58	}	1✔
59	}
60
UNCOV 61	return false	×
62	}
63
64	// IsOnGracePeriod return true if the service has been unidled less than 30s (grace period) ago.
65	func IsOnGracePeriod(svc *kapi.Service) bool {	×
66	ok, unidledAtStr := getUnidleAt(svc)	×
67	if !ok {	×
68	return false	×
69	}	×
70
71	unidledAtTime, err := time.Parse(time.RFC3339, unidledAtStr)	×
72	if err != nil {	×
73	klog.Warningf("Bad value [%s] for [%s] annotation on service [%s/%s]", unidledAtStr, UnidledAtAnnotation, svc.Namespace, svc.Name)	×
74	return false	×
75	}	×
76
77	endOfGracePeriod := unidledAtTime.Add(GracePeriodDuration)	×
78		×
79	return time.Now().Before(endOfGracePeriod)	×
80	}
81
82	func (uac *unidledAtController) onServiceUpdate(old, new interface{}) {	1✔
83	oldSvc := old.(*kapi.Service)	1✔
84	newSvc := new.(*kapi.Service)	1✔
85		1✔
86	oldSvcIdleAt := HasIdleAt(oldSvc)	1✔
87	newSvcIdleAt := HasIdleAt(newSvc)	1✔
88		1✔
89	if oldSvcIdleAt && !newSvcIdleAt {	1✔
UNCOV 90	// Service has been unidled, fill the unidled-at annotation with timing	×
UNCOV 91	err := uac.setUnidleAtAnnotation(newSvc)	×
UNCOV 92	if err != nil {	×
93	utilruntime.HandleError(err)	×
94	}	×
95
96	return	×
97	}
98
99	if !oldSvcIdleAt && newSvcIdleAt {	2✔
100	// Service has been idled, remove unidled-at annotation	1✔
101	err := uac.removeUnidleAtAnnotation(newSvc)	1✔
102	if err != nil {	1✔
103	utilruntime.HandleError(err)	×
104	}	×
105
106	return	1✔
107	}
108
109	}
110
UNCOV 111	func (uac unidledAtController) setUnidleAtAnnotation(svc kapi.Service) error {	×
UNCOV 112		×
UNCOV 113	nowStr := time.Now().Format(time.RFC3339)	×
UNCOV 114	err := uac.kube.SetAnnotationsOnService(svc.Namespace, svc.Name, map[string]interface{}{	×
UNCOV 115	UnidledAtAnnotation: nowStr,	×
UNCOV 116	})	×
UNCOV 117	if err != nil {	×
118	return fmt.Errorf("can't set service [%s/%s] unidle-at annotation to [%s]: %w", svc.Namespace, svc.Name, nowStr, err)	×
119	}	×
120
121	return nil	×
122	}
123
124	func (uac unidledAtController) removeUnidleAtAnnotation(svc kapi.Service) error {	1✔
125		1✔
126	if svc.Annotations == nil {	1✔
127	return nil	×
128	}	×
129
130	_, annotationPresent := svc.Annotations[UnidledAtAnnotation]	1✔
131	if !annotationPresent {	2✔
132	klog.V(5).Infof("Service [%s/%s] does not have annotation %s, no need to remove it", svc.Namespace, svc.Name, UnidledAtAnnotation)	1✔
133	return nil	1✔
134	}	1✔
135
136	err := uac.kube.SetAnnotationsOnService(svc.Namespace, svc.Name, map[string]interface{}{	×
137	UnidledAtAnnotation: nil,	×
138	})	×
139	if err != nil {	×
140	return fmt.Errorf("can't remove service unidle-at annotation: %w", err)	×
141	}	×
142
143	return nil	×
144	}
145
146	func getUnidleAt(svc *kapi.Service) (bool, string) {	×
147	if svc == nil {	×
148	return false, ""	×
149	}	×
150
151	if svc.Annotations == nil {	×
152	return false, ""	×
153	}	×
154
155	for annotationKey, value := range svc.Annotations {	×
156	if strings.HasSuffix(annotationKey, UnidledAtSuffix) {	×
157	return true, value	×
158	}	×
159	}
160
161	return false, ""	×
162	}

ovn-org / ovn-kubernetes / 9761350290

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