19624659587

Committed 24 Nov 2025 05:46AM UTC coverage: 53.67%. Remained the same

Build # 19624659587

Build Type

push

github

Committed by

web-flow

Commit Message

chore(deps): bump go.uber.org/zap from 1.27.0 to 1.27.1 (#551)

Bumps [go.uber.org/zap](https://github.com/uber-go/zap) from 1.27.0 to 1.27.1.
- [Release notes](https://github.com/uber-go/zap/releases)
- [Changelog](https://github.com/uber-go/zap/blob/master/CHANGELOG.md)
- [Commits](https://github.com/uber-go/zap/compare/v1.27.0...v1.27.1)

---
updated-dependencies:
- dependency-name: go.uber.org/zap
  dependency-version: 1.27.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

658 of 1226 relevant lines covered (53.67%)

0.61 hits per line

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

71.55

/controllers/config/config_controller.go

package config

import (
        "context"
        "fmt"
        "os"
        "sync"

        cnst "github.com/bakito/k8s-event-logger-operator/pkg/constants"
        "github.com/bakito/operator-utils/pkg/filter"
        "github.com/go-logr/logr"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/api/resource"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/types"
        "k8s.io/apimachinery/pkg/util/yaml"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/reconcile"
)

type contextKey string

const (
        defaultContainerName            = "k8s-event-logger-operator"
        configKey            contextKey = "config"
)

var (
        defaultPodReqCPU = resource.MustParse("100m")
        defaultPodReqMem = resource.MustParse("64Mi")
        defaultPodMaxCPU = resource.MustParse("200m")
        defaultPodMaxMem = resource.MustParse("128Mi")
)

// Reconciler reconciles a Pod object
type Reconciler struct {
        client.Reader
        Log    logr.Logger
        Scheme *runtime.Scheme

        cfg              *Cfg
        once             sync.Once
        eventLoggerImage string
}

// +kubebuilder:rbac:groups=,resources=configmaps,verbs=get;list;watch

// Reconcile EventLogger to setup event logger pods
func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
        reqLogger := r.Log.WithValues("namespace", req.Namespace, "name", req.Name)
        return reconcile.Result{}, r.readConfig(ctx, reqLogger, req.NamespacedName)
}

func (r *Reconciler) readConfig(ctx context.Context, reqLogger logr.Logger, nn types.NamespacedName) error {
        // Fetch the EventLogger cr
        cm := &corev1.ConfigMap{}
        err := r.Get(ctx, nn, cm)
        if err != nil {
                return err
        }

        reqLogger.Info("Reconciling config")

        noPodTemplate := fmt.Errorf(
                `configmap %q must contain the container template %q`,
                nn.String(),
                cnst.ConfigKeyContainerTemplate,
        )
        if len(cm.Data) == 0 {
                return noPodTemplate
        }
        pt, ok := cm.Data[cnst.ConfigKeyContainerTemplate]
        if !ok {
                return noPodTemplate
        }
        container := corev1.Container{}
        if err := yaml.Unmarshal([]byte(pt), &container); err != nil {
                return err
        }

        if container.Resources.Requests == nil {
                container.Resources.Requests = map[corev1.ResourceName]resource.Quantity{}
        }
        if container.Resources.Limits == nil {
                container.Resources.Limits = map[corev1.ResourceName]resource.Quantity{}
        }

        if _, ok := container.Resources.Requests[corev1.ResourceCPU]; !ok {
                container.Resources.Requests[corev1.ResourceCPU] = defaultPodReqCPU
        }
        if _, ok := container.Resources.Requests[corev1.ResourceMemory]; !ok {
                container.Resources.Requests[corev1.ResourceMemory] = defaultPodReqMem
        }
        if _, ok := container.Resources.Limits[corev1.ResourceCPU]; !ok {
                container.Resources.Limits[corev1.ResourceCPU] = defaultPodMaxCPU
        }
        if _, ok := container.Resources.Limits[corev1.ResourceMemory]; !ok {
                container.Resources.Limits[corev1.ResourceMemory] = defaultPodMaxMem
        }

        if container.Image == "" {
                container.Image = r.eventLoggerImage
        }
        if container.ImagePullPolicy == "" {
                container.ImagePullPolicy = corev1.PullAlways
        }

        r.cfg.ContainerTemplate = container

        return nil
}

func (r *Reconciler) setupEventLoggerImage(nn types.NamespacedName) error {
        if podImage, ok := os.LookupEnv(cnst.EnvEventLoggerImage); ok && podImage != "" {
                r.eventLoggerImage = podImage
                return nil
        }
        p := &corev1.Pod{}
        err := r.Get(context.TODO(), nn, p)
        if err != nil {
                return err
        }

        if len(p.Spec.Containers) == 1 {
                r.eventLoggerImage = p.Spec.Containers[0].Image
                return nil

        }
        for _, c := range p.Spec.Containers {
                if c.Name == defaultContainerName {
                        r.eventLoggerImage = c.Image
                        return nil
                }
        }
        return fmt.Errorf("could not evaluate the event logger image to use")
}

func (r *Reconciler) Ctx() context.Context {
        r.once.Do(func() {
                r.cfg = &Cfg{}
        })
        return context.WithValue(context.Background(), configKey, r.cfg)
}

func GetCfg(ctx context.Context) *Cfg {
        c, ok := ctx.Value(configKey).(*Cfg)
        if !ok {
                return nil
        }
        clone := *c
        return &clone
}

// SetupWithManager setup with manager
func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
        namespace := os.Getenv(cnst.EnvPodNamespace)
        cmName := os.Getenv(cnst.EnvConfigMapName)
        podName := os.Getenv(cnst.EnvPodName)
        configReload := os.Getenv(cnst.EnvConfigReload)

        if err := r.setupEventLoggerImage(types.NamespacedName{
                Namespace: namespace,
                Name:      podName,
        }); err != nil {
                return err
        }

        if err := r.readConfig(r.Ctx(), mgr.GetLogger(), types.NamespacedName{
                Namespace: namespace,
                Name:      cmName,
        }); err != nil {
                return err
        }

        if configReload == "true" {
                return ctrl.NewControllerManagedBy(mgr).
                        For(&corev1.ConfigMap{}).WithEventFilter(filter.NamePredicate{
                        Namespace: namespace,
                        Names:     []string{cmName},
                },
                ).Complete(r)
        }

        return nil
}

type Cfg struct {
        ContainerTemplate corev1.Container
}

1	package config
2
3	import (
4	"context"
5	"fmt"
6	"os"
7	"sync"
8
9	cnst "github.com/bakito/k8s-event-logger-operator/pkg/constants"
10	"github.com/bakito/operator-utils/pkg/filter"
11	"github.com/go-logr/logr"
12	corev1 "k8s.io/api/core/v1"
13	"k8s.io/apimachinery/pkg/api/resource"
14	"k8s.io/apimachinery/pkg/runtime"
15	"k8s.io/apimachinery/pkg/types"
16	"k8s.io/apimachinery/pkg/util/yaml"
17	ctrl "sigs.k8s.io/controller-runtime"
18	"sigs.k8s.io/controller-runtime/pkg/client"
19	"sigs.k8s.io/controller-runtime/pkg/reconcile"
20	)
21
22	type contextKey string
23
24	const (
25	defaultContainerName = "k8s-event-logger-operator"
26	configKey contextKey = "config"
27	)
28
29	var (
30	defaultPodReqCPU = resource.MustParse("100m")
31	defaultPodReqMem = resource.MustParse("64Mi")
32	defaultPodMaxCPU = resource.MustParse("200m")
33	defaultPodMaxMem = resource.MustParse("128Mi")
34	)
35
36	// Reconciler reconciles a Pod object
37	type Reconciler struct {
38	client.Reader
39	Log logr.Logger
40	Scheme *runtime.Scheme
41
42	cfg *Cfg
43	once sync.Once
44	eventLoggerImage string
45	}
46
47	// +kubebuilder:rbac:groups=,resources=configmaps,verbs=get;list;watch
48
49	// Reconcile EventLogger to setup event logger pods
50	func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	1✔
51	reqLogger := r.Log.WithValues("namespace", req.Namespace, "name", req.Name)	1✔
52	return reconcile.Result{}, r.readConfig(ctx, reqLogger, req.NamespacedName)	1✔
53	}	1✔
54
55	func (r *Reconciler) readConfig(ctx context.Context, reqLogger logr.Logger, nn types.NamespacedName) error {	1✔
56	// Fetch the EventLogger cr	1✔
57	cm := &corev1.ConfigMap{}	1✔
58	err := r.Get(ctx, nn, cm)	1✔
59	if err != nil {	1✔
60	return err	×
61	}	×
62
63	reqLogger.Info("Reconciling config")	1✔
64		1✔
65	noPodTemplate := fmt.Errorf(	1✔
66	`configmap %q must contain the container template %q`,	1✔
67	nn.String(),	1✔
68	cnst.ConfigKeyContainerTemplate,	1✔
69	)	1✔
70	if len(cm.Data) == 0 {	2✔
71	return noPodTemplate	1✔
72	}	1✔
73	pt, ok := cm.Data[cnst.ConfigKeyContainerTemplate]	1✔
74	if !ok {	2✔
75	return noPodTemplate	1✔
76	}	1✔
77	container := corev1.Container{}	1✔
78	if err := yaml.Unmarshal([]byte(pt), &container); err != nil {	1✔
79	return err	×
80	}	×
81
82	if container.Resources.Requests == nil {	2✔
83	container.Resources.Requests = map[corev1.ResourceName]resource.Quantity{}	1✔
84	}	1✔
85	if container.Resources.Limits == nil {	2✔
86	container.Resources.Limits = map[corev1.ResourceName]resource.Quantity{}	1✔
87	}	1✔
88
89	if _, ok := container.Resources.Requests[corev1.ResourceCPU]; !ok {	2✔
90	container.Resources.Requests[corev1.ResourceCPU] = defaultPodReqCPU	1✔
91	}	1✔
92	if _, ok := container.Resources.Requests[corev1.ResourceMemory]; !ok {	2✔
93	container.Resources.Requests[corev1.ResourceMemory] = defaultPodReqMem	1✔
94	}	1✔
95	if _, ok := container.Resources.Limits[corev1.ResourceCPU]; !ok {	2✔
96	container.Resources.Limits[corev1.ResourceCPU] = defaultPodMaxCPU	1✔
97	}	1✔
98	if _, ok := container.Resources.Limits[corev1.ResourceMemory]; !ok {	2✔
99	container.Resources.Limits[corev1.ResourceMemory] = defaultPodMaxMem	1✔
100	}	1✔
101
102	if container.Image == "" {	2✔
103	container.Image = r.eventLoggerImage	1✔
104	}	1✔
105	if container.ImagePullPolicy == "" {	2✔
106	container.ImagePullPolicy = corev1.PullAlways	1✔
107	}	1✔
108
109	r.cfg.ContainerTemplate = container	1✔
110		1✔
111	return nil	1✔
112	}
113
114	func (r *Reconciler) setupEventLoggerImage(nn types.NamespacedName) error {	1✔
115	if podImage, ok := os.LookupEnv(cnst.EnvEventLoggerImage); ok && podImage != "" {	2✔
116	r.eventLoggerImage = podImage	1✔
117	return nil	1✔
118	}	1✔
119	p := &corev1.Pod{}	1✔
120	err := r.Get(context.TODO(), nn, p)	1✔
121	if err != nil {	2✔
122	return err	1✔
123	}	1✔
124
125	if len(p.Spec.Containers) == 1 {	2✔
126	r.eventLoggerImage = p.Spec.Containers[0].Image	1✔
127	return nil	1✔
128		1✔
129	}	1✔
130	for _, c := range p.Spec.Containers {	2✔
131	if c.Name == defaultContainerName {	2✔
132	r.eventLoggerImage = c.Image	1✔
133	return nil	1✔
134	}	1✔
135	}
136	return fmt.Errorf("could not evaluate the event logger image to use")	1✔
137	}
138
139	func (r *Reconciler) Ctx() context.Context {	1✔
140	r.once.Do(func() {	2✔
141	r.cfg = &Cfg{}	1✔
142	})	1✔
143	return context.WithValue(context.Background(), configKey, r.cfg)	1✔
144	}
145
146	func GetCfg(ctx context.Context) *Cfg {	1✔
147	c, ok := ctx.Value(configKey).(*Cfg)	1✔
148	if !ok {	1✔
149	return nil	×
150	}	×
151	clone := *c	1✔
152	return &clone	1✔
153	}
154
155	// SetupWithManager setup with manager
156	func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {	×
157	namespace := os.Getenv(cnst.EnvPodNamespace)	×
158	cmName := os.Getenv(cnst.EnvConfigMapName)	×
159	podName := os.Getenv(cnst.EnvPodName)	×
160	configReload := os.Getenv(cnst.EnvConfigReload)	×
161		×
162	if err := r.setupEventLoggerImage(types.NamespacedName{	×
163	Namespace: namespace,	×
164	Name: podName,	×
165	}); err != nil {	×
166	return err	×
167	}	×
168
169	if err := r.readConfig(r.Ctx(), mgr.GetLogger(), types.NamespacedName{	×
170	Namespace: namespace,	×
171	Name: cmName,	×
172	}); err != nil {	×
173	return err	×
174	}	×
175
176	if configReload == "true" {	×
177	return ctrl.NewControllerManagedBy(mgr).	×
178	For(&corev1.ConfigMap{}).WithEventFilter(filter.NamePredicate{	×
179	Namespace: namespace,	×
180	Names: []string{cmName},	×
181	},	×
182	).Complete(r)	×
183	}	×
184
185	return nil	×
186	}
187
188	type Cfg struct {
189	ContainerTemplate corev1.Container
190	}

bakito / k8s-event-logger-operator / 19624659587

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