26508739409

Committed 27 May 2026 11:35AM UTC coverage: 53.586% (+0.09%) from 53.498%

Build # 26508739409

Build Type

push

github

Committed by

web-flow

Commit Message

chore: created local '.github/workflows/govulncheck.yaml' from remote 'workflow/govulncheck.yaml' (#599)

chore: synced local '.golangci.yaml' with remote 'golangci-lint/without-depguard.yaml'

Signed-off-by: bakito <github@bakito.ch>
Co-authored-by: bakito <null>

Coverage Stats

20 of 30 new or added lines in 8 files covered. (66.67%)

650 of 1213 relevant lines covered (53.59%)

0.61 hits per line

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

48.1

/controllers/setup/eventlogger_controller.go

/*


Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package setup

import (
        "context"

        "github.com/go-logr/logr"
        corev1 "k8s.io/api/core/v1"
        rbacv1 "k8s.io/api/rbac/v1"
        "k8s.io/apimachinery/pkg/api/errors"
        "k8s.io/apimachinery/pkg/runtime"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/reconcile"

        eventloggerv1 "github.com/bakito/k8s-event-logger-operator/api/v1"
        "github.com/bakito/k8s-event-logger-operator/version"
)

var gracePeriod int64

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

        Config context.Context
}

// +kubebuilder:rbac:groups=eventlogger.bakito.ch,resources=eventloggers,verbs=get;list;watch;create;update;patch;delete

// 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)

        // Fetch the EventLogger cr
        cr := &eventloggerv1.EventLogger{}
        err := r.Get(ctx, req.NamespacedName, cr)
        if err != nil {
                if errors.IsNotFound(err) {
                        // Request object not found, could have been deleted after reconcile req.
                        // Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.
                        // Return and don't requeue
                        return reconcile.Result{}, nil
                }
                // Error reading the object - requeue the req.
                return r.updateCR(ctx, cr, reqLogger, err)
        }

        if err = cr.Spec.Validate(); err != nil {
                return r.updateCR(ctx, cr, reqLogger, err)
        }

        saccChanged, roleChanged, rbChanged, err := r.setupRbac(ctx, cr)
        if err != nil {
                return r.updateCR(ctx, cr, reqLogger, err)
        }

        // Define a new Pod object
        pod := r.podForCR(cr)

        // set owner reference for pod
        if err := ctrl.SetControllerReference(cr, pod, r.Scheme); err != nil {
                return r.updateCR(ctx, cr, reqLogger, err)
        }

        // Check if this Pod already exists
        podChanged, err := r.createOrReplacePod(ctx, cr, pod, reqLogger)
        if err != nil {
                return r.updateCR(ctx, cr, reqLogger, err)
        }

        if cr.HasChanged() || saccChanged || roleChanged || rbChanged || podChanged {
                reqLogger.Info("Reconciling event logger")
                return r.updateCR(ctx, cr, reqLogger, nil)
        }

        return reconcile.Result{}, nil
}

func (r *Reconciler) updateCR(
        ctx context.Context,
        cr *eventloggerv1.EventLogger,
        logger logr.Logger,
        err error,
) (reconcile.Result, error) {
        if err != nil {
                logger.Error(err, "")
        }
        cr.Apply(err)
        cr.Status.Hash = cr.Spec.Hash()
        cr.Status.OperatorVersion = version.Version
        err = r.Update(ctx, cr)
        return reconcile.Result{}, err
}

func (r *Reconciler) saveDelete(ctx context.Context, obj client.Object) error {
        err := r.Delete(ctx, obj)
        if err != nil {
                if !errors.IsNotFound(err) {
                        return err
                }
        }
        return nil
}

func loggerName(cr *eventloggerv1.EventLogger) string {
        return "event-logger-" + cr.Name
}

func podChanged(oldPod, newPod *corev1.Pod) bool {
        if oldPod.Spec.ServiceAccountName != newPod.Spec.ServiceAccountName {
                return true
        }
        if len(oldPod.Spec.Containers) > 0 && len(newPod.Spec.Containers) > 0 &&
                oldPod.Spec.Containers[0].Image != newPod.Spec.Containers[0].Image {
                return true
        }

        return podEnv(oldPod, "WATCH_NAMESPACE") != podEnv(newPod, "WATCH_NAMESPACE")
}

func podEnv(pod *corev1.Pod, name string) string {
        for _, env := range pod.Spec.Containers[0].Env {
                if env.Name == name {
                        return env.Value
                }
        }
        return "N/A"
}

// SetupWithManager setup with manager.
func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {
        return ctrl.NewControllerManagedBy(mgr).
                For(&eventloggerv1.EventLogger{}).
                Owns(&corev1.Pod{}).
                Owns(&corev1.ServiceAccount{}).
                Owns(&rbacv1.Role{}).
                Owns(&rbacv1.RoleBinding{}).
                Complete(r)
}

1	/*
2
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package setup
18
19	import (
20	"context"
21
22	"github.com/go-logr/logr"
23	corev1 "k8s.io/api/core/v1"
24	rbacv1 "k8s.io/api/rbac/v1"
25	"k8s.io/apimachinery/pkg/api/errors"
26	"k8s.io/apimachinery/pkg/runtime"
27	ctrl "sigs.k8s.io/controller-runtime"
28	"sigs.k8s.io/controller-runtime/pkg/client"
29	"sigs.k8s.io/controller-runtime/pkg/reconcile"
30
31	eventloggerv1 "github.com/bakito/k8s-event-logger-operator/api/v1"
32	"github.com/bakito/k8s-event-logger-operator/version"
33	)
34
35	var gracePeriod int64
36
37	// Reconciler reconciles a Pod object.
38	type Reconciler struct {
39	client.Client
40	Log logr.Logger
41	Scheme *runtime.Scheme
42
43	Config context.Context
44	}
45
46	// +kubebuilder:rbac:groups=eventlogger.bakito.ch,resources=eventloggers,verbs=get;list;watch;create;update;patch;delete
47
48	// Reconcile EventLogger to setup event logger pods.
49	func (r *Reconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	1✔
50	reqLogger := r.Log.WithValues("namespace", req.Namespace, "name", req.Name)	1✔
51		1✔
52	// Fetch the EventLogger cr	1✔
53	cr := &eventloggerv1.EventLogger{}	1✔
54	err := r.Get(ctx, req.NamespacedName, cr)	1✔
55	if err != nil {	1✔
56	if errors.IsNotFound(err) {	×
57	// Request object not found, could have been deleted after reconcile req.	×
58	// Owned objects are automatically garbage collected. For additional cleanup logic use finalizers.	×
59	// Return and don't requeue	×
60	return reconcile.Result{}, nil	×
61	}	×
62	// Error reading the object - requeue the req.
63	return r.updateCR(ctx, cr, reqLogger, err)	×
64	}
65
66	if err = cr.Spec.Validate(); err != nil {	1✔
67	return r.updateCR(ctx, cr, reqLogger, err)	×
68	}	×
69
70	saccChanged, roleChanged, rbChanged, err := r.setupRbac(ctx, cr)	1✔
71	if err != nil {	1✔
72	return r.updateCR(ctx, cr, reqLogger, err)	×
73	}	×
74
75	// Define a new Pod object
76	pod := r.podForCR(cr)	1✔
77		1✔
78	// set owner reference for pod	1✔
79	if err := ctrl.SetControllerReference(cr, pod, r.Scheme); err != nil {	1✔
80	return r.updateCR(ctx, cr, reqLogger, err)	×
81	}	×
82
83	// Check if this Pod already exists
84	podChanged, err := r.createOrReplacePod(ctx, cr, pod, reqLogger)	1✔
85	if err != nil {	1✔
86	return r.updateCR(ctx, cr, reqLogger, err)	×
87	}	×
88
89	if cr.HasChanged() \|\| saccChanged \|\| roleChanged \|\| rbChanged \|\| podChanged {	2✔
90	reqLogger.Info("Reconciling event logger")	1✔
91	return r.updateCR(ctx, cr, reqLogger, nil)	1✔
92	}	1✔
93
94	return reconcile.Result{}, nil	×
95	}
96
97	func (r *Reconciler) updateCR(
98	ctx context.Context,
99	cr *eventloggerv1.EventLogger,
100	logger logr.Logger,
101	err error,
102	) (reconcile.Result, error) {	1✔
103	if err != nil {	1✔
104	logger.Error(err, "")	×
105	}	×
106	cr.Apply(err)	1✔
107	cr.Status.Hash = cr.Spec.Hash()	1✔
108	cr.Status.OperatorVersion = version.Version	1✔
109	err = r.Update(ctx, cr)	1✔
110	return reconcile.Result{}, err	1✔
111	}
112
113	func (r *Reconciler) saveDelete(ctx context.Context, obj client.Object) error {	1✔
114	err := r.Delete(ctx, obj)	1✔
115	if err != nil {	1✔
116	if !errors.IsNotFound(err) {	×
117	return err	×
118	}	×
119	}
120	return nil	1✔
121	}
122
123	func loggerName(cr *eventloggerv1.EventLogger) string {	1✔
124	return "event-logger-" + cr.Name	1✔
125	}	1✔
126
127	func podChanged(oldPod, newPod *corev1.Pod) bool {	1✔
128	if oldPod.Spec.ServiceAccountName != newPod.Spec.ServiceAccountName {	2✔
129	return true	1✔
130	}	1✔
NEW 131	if len(oldPod.Spec.Containers) > 0 && len(newPod.Spec.Containers) > 0 &&	×
NEW 132	oldPod.Spec.Containers[0].Image != newPod.Spec.Containers[0].Image {	×
133	return true	×
134	}	×
135
NEW 136	return podEnv(oldPod, "WATCH_NAMESPACE") != podEnv(newPod, "WATCH_NAMESPACE")	×
137	}
138
139	func podEnv(pod *corev1.Pod, name string) string {	×
140	for _, env := range pod.Spec.Containers[0].Env {	×
141	if env.Name == name {	×
142	return env.Value	×
143	}	×
144	}
145	return "N/A"	×
146	}
147
148	// SetupWithManager setup with manager.
149	func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {	×
150	return ctrl.NewControllerManagedBy(mgr).	×
151	For(&eventloggerv1.EventLogger{}).	×
152	Owns(&corev1.Pod{}).	×
153	Owns(&corev1.ServiceAccount{}).	×
154	Owns(&rbacv1.Role{}).	×
155	Owns(&rbacv1.RoleBinding{}).	×
156	Complete(r)	×
157	}	×

bakito / k8s-event-logger-operator / 26508739409

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