9178738678

Committed 21 May 2024 05:21PM UTC coverage: 62.725% (+0.03%) from 62.693%

Build # 9178738678

Build Type

push

github

Committed by

web-flow

Commit Message

add image pull secrets to the EventLogger api (#439)

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

732 of 1167 relevant lines covered (62.72%)

0.71 hits per line

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

48.72

/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(ctx context.Context, cr eventloggerv1.EventLogger, logger logr.Logger, err error) (reconcile.Result, error) {	1✔
97	if err != nil {	1✔
98	logger.Error(err, "")	×
99	}	×
100	cr.Apply(err)	1✔
101	cr.Status.Hash = cr.Spec.Hash()	1✔
102	cr.Status.OperatorVersion = version.Version	1✔
103	err = r.Update(ctx, cr)	1✔
104	return reconcile.Result{}, err	1✔
105	}
106
107	func (r *Reconciler) saveDelete(ctx context.Context, obj client.Object) error {	1✔
108	err := r.Delete(ctx, obj)	1✔
109	if err != nil {	1✔
110	if !errors.IsNotFound(err) {	×
111	return err	×
112	}	×
113	}
114	return nil	1✔
115	}
116
117	func loggerName(cr *eventloggerv1.EventLogger) string {	1✔
118	return "event-logger-" + cr.Name	1✔
119	}	1✔
120
121	func podChanged(old, new *corev1.Pod) bool {	1✔
122	if old.Spec.ServiceAccountName != new.Spec.ServiceAccountName {	2✔
123	return true	1✔
124	}	1✔
125	if len(old.Spec.Containers) > 0 && len(new.Spec.Containers) > 0 && old.Spec.Containers[0].Image != new.Spec.Containers[0].Image {	×
126	return true	×
127	}	×
128
129	return podEnv(old, "WATCH_NAMESPACE") != podEnv(new, "WATCH_NAMESPACE")	×
130	}
131
132	func podEnv(pod *corev1.Pod, name string) string {	×
133	for _, env := range pod.Spec.Containers[0].Env {	×
134	if env.Name == name {	×
135	return env.Value	×
136	}	×
137	}
138	return "N/A"	×
139	}
140
141	// SetupWithManager setup with manager
142	func (r *Reconciler) SetupWithManager(mgr ctrl.Manager) error {	×
143	return ctrl.NewControllerManagedBy(mgr).	×
144	For(&eventloggerv1.EventLogger{}).	×
145	Owns(&corev1.Pod{}).	×
146	Owns(&corev1.ServiceAccount{}).	×
147	Owns(&rbacv1.Role{}).	×
148	Owns(&rbacv1.RoleBinding{}).	×
149	Complete(r)	×
150	}	×

bakito / k8s-event-logger-operator / 9178738678

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