12982588012

Committed 27 Jan 2025 05:23AM UTC coverage: 62.219%. Remained the same

Build # 12982588012

Build Type

Pull #498

github

Committed by

web-flow

Commit Message

chore(deps): bump sigs.k8s.io/controller-runtime from 0.20.0 to 0.20.1

Bumps [sigs.k8s.io/controller-runtime](https://github.com/kubernetes-sigs/controller-runtime) from 0.20.0 to 0.20.1.
- [Release notes](https://github.com/kubernetes-sigs/controller-runtime/releases)
- [Changelog](https://github.com/kubernetes-sigs/controller-runtime/blob/main/RELEASE.md)
- [Commits](https://github.com/kubernetes-sigs/controller-runtime/compare/v0.20.0...v0.20.1)

---
updated-dependencies:
- dependency-name: sigs.k8s.io/controller-runtime
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #498: chore(deps): bump sigs.k8s.io/controller-runtime from 0.20.0 to 0.20.1

Run Details

746 of 1199 relevant lines covered (62.22%)

0.7 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"

        eventloggerv1 "github.com/bakito/k8s-event-logger-operator/api/v1"
        "github.com/bakito/k8s-event-logger-operator/version"
        "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"
)

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(old, new *corev1.Pod) bool {
        if old.Spec.ServiceAccountName != new.Spec.ServiceAccountName {
                return true
        }
        if len(old.Spec.Containers) > 0 && len(new.Spec.Containers) > 0 &&
                old.Spec.Containers[0].Image != new.Spec.Containers[0].Image {
                return true
        }

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

bakito / k8s-event-logger-operator / 12982588012

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