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

0.0

/main.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 main

import (
        "flag"
        "fmt"
        "os"
        gr "runtime"

        eventloggerv1 "github.com/bakito/k8s-event-logger-operator/api/v1"
        "github.com/bakito/k8s-event-logger-operator/controllers/config"
        "github.com/bakito/k8s-event-logger-operator/controllers/logging"
        "github.com/bakito/k8s-event-logger-operator/controllers/setup"
        cnst "github.com/bakito/k8s-event-logger-operator/pkg/constants"
        "github.com/bakito/k8s-event-logger-operator/version"
        "github.com/bakito/operator-utils/pkg/pprof"
        "github.com/go-logr/zapr"
        zap2 "go.uber.org/zap"
        "go.uber.org/zap/zapcore"
        corev1 "k8s.io/api/core/v1"
        "k8s.io/apimachinery/pkg/runtime"
        utilruntime "k8s.io/apimachinery/pkg/util/runtime"
        clientgoscheme "k8s.io/client-go/kubernetes/scheme"
        _ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
        "k8s.io/klog/v2"
        ctrl "sigs.k8s.io/controller-runtime"
        crtlcache "sigs.k8s.io/controller-runtime/pkg/cache"
        "sigs.k8s.io/controller-runtime/pkg/healthz"
        "sigs.k8s.io/controller-runtime/pkg/log/zap"
        "sigs.k8s.io/controller-runtime/pkg/metrics/server"
        "sigs.k8s.io/controller-runtime/pkg/webhook"
)

var (
        scheme   = runtime.NewScheme()
        setupLog = ctrl.Log.WithName("setup")
)

func init() {
        utilruntime.Must(clientgoscheme.AddToScheme(scheme))
        utilruntime.Must(eventloggerv1.AddToScheme(scheme))
        utilruntime.Must(corev1.AddToScheme(scheme))
        // +kubebuilder:scaffold:scheme
}

func main() {
        var metricsAddr string
        var healthAddr string
        var profilingAddr string
        var configName string
        var enableLeaderElection bool
        var enableLoggerMode bool
        var enableProfiling bool
        flag.StringVar(
                &metricsAddr,
                cnst.ArgMetricsAddr,
                cnst.DefaultMetricsAddr,
                "The address the metric endpoint binds to.",
        )
        flag.StringVar(&healthAddr, cnst.ArgHealthAddr, cnst.DefaultHealthAddr, "The address the health endpoint binds to.")
        flag.StringVar(
                &profilingAddr,
                cnst.ArgProfilingAddr,
                cnst.DefaultProfilingAddr,
                "The address the profiling endpoint binds to.",
        )
        flag.BoolVar(
                &enableLeaderElection,
                cnst.ArgEnableLeaderElection,
                false,
                "Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager.",
        )
        flag.BoolVar(&enableLoggerMode, cnst.ArgEnableLoggerMode, false,
                "Enable logger mode. Enabling this will only log events of the current namespace.")
        flag.BoolVar(&enableProfiling, cnst.ArgEnableProfiling, false, "Enable profiling endpoint.")

        flag.StringVar(&configName, cnst.ArgConfigName, "",
                "The name of the eventlogger config to work with.")
        flag.Parse()

        o := func(o *zap.Options) {
                o.DestWriter = os.Stderr
                o.Development = false
                encCfg := zap2.NewProductionEncoderConfig()
                encCfg.EncodeTime = zapcore.ISO8601TimeEncoder
                o.Encoder = zapcore.NewJSONEncoder(encCfg)
        }
        ctrl.SetLogger(zapr.NewLogger(zap.NewRaw(o)))
        klog.SetLogger(ctrl.Log)

        printVersion()

        watchNamespace := os.Getenv(cnst.EnvWatchNamespace)
        podNamespace := os.Getenv(cnst.EnvPodNamespace)

        defaultNamespaces := map[string]crtlcache.Config{
                watchNamespace: {},
        }
        if watchNamespace == "" {
                defaultNamespaces = nil
        }

        mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
                Scheme: scheme,
                Metrics: server.Options{
                        BindAddress: metricsAddr,
                },
                WebhookServer: webhook.NewServer(webhook.Options{
                        Port:    9443,
                        CertDir: "certs",
                }),
                LeaderElection:             enableLeaderElection && !enableLoggerMode,
                LeaderElectionID:           "leader.eventlogger.bakito.ch",
                LeaderElectionResourceLock: os.Getenv(cnst.EnvLeaderElectionResourceLock),
                HealthProbeBindAddress:     healthAddr,
                Cache: crtlcache.Options{
                        DefaultNamespaces: defaultNamespaces,
                },
        })
        if err != nil {
                setupLog.Error(err, "unable to start manager")
                os.Exit(1)
        }

        if enableLoggerMode {
                setupLog.WithValues("configName", configName).Info("Current configuration")
                if err = (&logging.Reconciler{
                        Client:     mgr.GetClient(),
                        Log:        ctrl.Log.WithName("controllers").WithName("Event"),
                        Scheme:     mgr.GetScheme(),
                        Config:     logging.ConfigFor(configName, podNamespace, watchNamespace),
                        LoggerMode: true,
                }).SetupWithManager(mgr, watchNamespace); err != nil {
                        setupLog.Error(err, "unable to create controller", "controller", "Event")
                        os.Exit(1)
                }
        } else {
                // Setup all Controllers
                if watchNamespace == "" {
                        cr := &config.Reconciler{
                                Reader: mgr.GetAPIReader(),
                                Log:    ctrl.Log.WithName("controllers").WithName("Config"),
                                Scheme: mgr.GetScheme(),
                        }
                        if err = (cr).SetupWithManager(mgr); err != nil {
                                setupLog.Error(err, "unable to create controller", "controller", "Config")
                                os.Exit(1)
                        }
                        if err = (&setup.Reconciler{
                                Client: mgr.GetClient(),
                                Log:    ctrl.Log.WithName("controllers").WithName("EventLogger"),
                                Scheme: mgr.GetScheme(),
                                Config: cr.Ctx(),
                        }).SetupWithManager(mgr); err != nil {
                                setupLog.Error(err, "unable to create controller", "controller", "EventLogger")
                                os.Exit(1)
                        }
                        setupLog.Info("Running in global mode.")

                        if os.Getenv(cnst.EnvEnableWebhook) != "false" {
                                if err = (&eventloggerv1.EventLogger{}).SetupWebhookWithManager(mgr); err != nil {
                                        setupLog.Error(err, "unable to create webhook", "webhook", "EventLogger")
                                        os.Exit(1)
                                }
                        }
                } else {
                        if err = (&logging.Reconciler{
                                Client:     mgr.GetClient(),
                                Log:        ctrl.Log.WithName("controllers").WithName("Event"),
                                Scheme:     mgr.GetScheme(),
                                Config:     logging.ConfigFor(configName, podNamespace, watchNamespace),
                                LoggerMode: false,
                        }).SetupWithManager(mgr, watchNamespace); err != nil {
                                setupLog.Error(err, "unable to create controller", "controller", "Event")
                                os.Exit(1)
                        }
                        setupLog.WithValues("namespace", watchNamespace).Info("Running in single namespace mode.")
                }
        }
        // +kubebuilder:scaffold:builder

        if enableProfiling {
                if err = mgr.Add(pprof.New(profilingAddr)); err != nil {
                        setupLog.Error(err, "unable to create pprof service")
                        os.Exit(1)
                }
        }

        if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {
                setupLog.Error(err, "unable to set up health check")
                os.Exit(1)
        }
        if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {
                setupLog.Error(err, "unable to set up ready check")
                os.Exit(1)
        }

        setupLog.Info("starting manager")
        if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {
                setupLog.Error(err, "problem running manager")
                os.Exit(1)
        }
}

func printVersion() {
        setupLog.Info(fmt.Sprintf("Operator Version: %s", version.Version))
        setupLog.Info(fmt.Sprintf("Go Version: %s", gr.Version()))
        setupLog.Info(fmt.Sprintf("Go OS/Arch: %s/%s", gr.GOOS, gr.GOARCH))
}

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 main
18
19	import (
20	"flag"
21	"fmt"
22	"os"
23	gr "runtime"
24
25	eventloggerv1 "github.com/bakito/k8s-event-logger-operator/api/v1"
26	"github.com/bakito/k8s-event-logger-operator/controllers/config"
27	"github.com/bakito/k8s-event-logger-operator/controllers/logging"
28	"github.com/bakito/k8s-event-logger-operator/controllers/setup"
29	cnst "github.com/bakito/k8s-event-logger-operator/pkg/constants"
30	"github.com/bakito/k8s-event-logger-operator/version"
31	"github.com/bakito/operator-utils/pkg/pprof"
32	"github.com/go-logr/zapr"
33	zap2 "go.uber.org/zap"
34	"go.uber.org/zap/zapcore"
35	corev1 "k8s.io/api/core/v1"
36	"k8s.io/apimachinery/pkg/runtime"
37	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
38	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
39	_ "k8s.io/client-go/plugin/pkg/client/auth/gcp"
40	"k8s.io/klog/v2"
41	ctrl "sigs.k8s.io/controller-runtime"
42	crtlcache "sigs.k8s.io/controller-runtime/pkg/cache"
43	"sigs.k8s.io/controller-runtime/pkg/healthz"
44	"sigs.k8s.io/controller-runtime/pkg/log/zap"
45	"sigs.k8s.io/controller-runtime/pkg/metrics/server"
46	"sigs.k8s.io/controller-runtime/pkg/webhook"
47	)
48
49	var (
50	scheme = runtime.NewScheme()
51	setupLog = ctrl.Log.WithName("setup")
52	)
53
54	func init() {	×
55	utilruntime.Must(clientgoscheme.AddToScheme(scheme))	×
56	utilruntime.Must(eventloggerv1.AddToScheme(scheme))	×
57	utilruntime.Must(corev1.AddToScheme(scheme))	×
58	// +kubebuilder:scaffold:scheme	×
59	}	×
60
61	func main() {	×
62	var metricsAddr string	×
63	var healthAddr string	×
64	var profilingAddr string	×
65	var configName string	×
66	var enableLeaderElection bool	×
67	var enableLoggerMode bool	×
68	var enableProfiling bool	×
69	flag.StringVar(	×
70	&metricsAddr,	×
71	cnst.ArgMetricsAddr,	×
72	cnst.DefaultMetricsAddr,	×
73	"The address the metric endpoint binds to.",	×
74	)	×
75	flag.StringVar(&healthAddr, cnst.ArgHealthAddr, cnst.DefaultHealthAddr, "The address the health endpoint binds to.")	×
76	flag.StringVar(	×
77	&profilingAddr,	×
78	cnst.ArgProfilingAddr,	×
79	cnst.DefaultProfilingAddr,	×
80	"The address the profiling endpoint binds to.",	×
81	)	×
82	flag.BoolVar(	×
83	&enableLeaderElection,	×
84	cnst.ArgEnableLeaderElection,	×
85	false,	×
86	"Enable leader election for controller manager. Enabling this will ensure there is only one active controller manager.",	×
87	)	×
88	flag.BoolVar(&enableLoggerMode, cnst.ArgEnableLoggerMode, false,	×
89	"Enable logger mode. Enabling this will only log events of the current namespace.")	×
90	flag.BoolVar(&enableProfiling, cnst.ArgEnableProfiling, false, "Enable profiling endpoint.")	×
91		×
92	flag.StringVar(&configName, cnst.ArgConfigName, "",	×
93	"The name of the eventlogger config to work with.")	×
94	flag.Parse()	×
95		×
96	o := func(o *zap.Options) {	×
97	o.DestWriter = os.Stderr	×
98	o.Development = false	×
99	encCfg := zap2.NewProductionEncoderConfig()	×
100	encCfg.EncodeTime = zapcore.ISO8601TimeEncoder	×
101	o.Encoder = zapcore.NewJSONEncoder(encCfg)	×
102	}	×
103	ctrl.SetLogger(zapr.NewLogger(zap.NewRaw(o)))	×
104	klog.SetLogger(ctrl.Log)	×
105		×
106	printVersion()	×
107		×
108	watchNamespace := os.Getenv(cnst.EnvWatchNamespace)	×
109	podNamespace := os.Getenv(cnst.EnvPodNamespace)	×
110		×
111	defaultNamespaces := map[string]crtlcache.Config{	×
112	watchNamespace: {},	×
113	}	×
114	if watchNamespace == "" {	×
115	defaultNamespaces = nil	×
116	}	×
117
118	mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{	×
119	Scheme: scheme,	×
120	Metrics: server.Options{	×
121	BindAddress: metricsAddr,	×
122	},	×
123	WebhookServer: webhook.NewServer(webhook.Options{	×
124	Port: 9443,	×
125	CertDir: "certs",	×
126	}),	×
127	LeaderElection: enableLeaderElection && !enableLoggerMode,	×
128	LeaderElectionID: "leader.eventlogger.bakito.ch",	×
129	LeaderElectionResourceLock: os.Getenv(cnst.EnvLeaderElectionResourceLock),	×
130	HealthProbeBindAddress: healthAddr,	×
131	Cache: crtlcache.Options{	×
132	DefaultNamespaces: defaultNamespaces,	×
133	},	×
134	})	×
135	if err != nil {	×
136	setupLog.Error(err, "unable to start manager")	×
137	os.Exit(1)	×
138	}	×
139
140	if enableLoggerMode {	×
141	setupLog.WithValues("configName", configName).Info("Current configuration")	×
142	if err = (&logging.Reconciler{	×
143	Client: mgr.GetClient(),	×
144	Log: ctrl.Log.WithName("controllers").WithName("Event"),	×
145	Scheme: mgr.GetScheme(),	×
146	Config: logging.ConfigFor(configName, podNamespace, watchNamespace),	×
147	LoggerMode: true,	×
148	}).SetupWithManager(mgr, watchNamespace); err != nil {	×
149	setupLog.Error(err, "unable to create controller", "controller", "Event")	×
150	os.Exit(1)	×
151	}	×
152	} else {	×
153	// Setup all Controllers	×
154	if watchNamespace == "" {	×
155	cr := &config.Reconciler{	×
156	Reader: mgr.GetAPIReader(),	×
157	Log: ctrl.Log.WithName("controllers").WithName("Config"),	×
158	Scheme: mgr.GetScheme(),	×
159	}	×
160	if err = (cr).SetupWithManager(mgr); err != nil {	×
161	setupLog.Error(err, "unable to create controller", "controller", "Config")	×
162	os.Exit(1)	×
163	}	×
164	if err = (&setup.Reconciler{	×
165	Client: mgr.GetClient(),	×
166	Log: ctrl.Log.WithName("controllers").WithName("EventLogger"),	×
167	Scheme: mgr.GetScheme(),	×
168	Config: cr.Ctx(),	×
169	}).SetupWithManager(mgr); err != nil {	×
170	setupLog.Error(err, "unable to create controller", "controller", "EventLogger")	×
171	os.Exit(1)	×
172	}	×
173	setupLog.Info("Running in global mode.")	×
174		×
175	if os.Getenv(cnst.EnvEnableWebhook) != "false" {	×
176	if err = (&eventloggerv1.EventLogger{}).SetupWebhookWithManager(mgr); err != nil {	×
177	setupLog.Error(err, "unable to create webhook", "webhook", "EventLogger")	×
178	os.Exit(1)	×
179	}	×
180	}
181	} else {	×
182	if err = (&logging.Reconciler{	×
183	Client: mgr.GetClient(),	×
184	Log: ctrl.Log.WithName("controllers").WithName("Event"),	×
185	Scheme: mgr.GetScheme(),	×
186	Config: logging.ConfigFor(configName, podNamespace, watchNamespace),	×
187	LoggerMode: false,	×
188	}).SetupWithManager(mgr, watchNamespace); err != nil {	×
189	setupLog.Error(err, "unable to create controller", "controller", "Event")	×
190	os.Exit(1)	×
191	}	×
192	setupLog.WithValues("namespace", watchNamespace).Info("Running in single namespace mode.")	×
193	}
194	}
195	// +kubebuilder:scaffold:builder
196
197	if enableProfiling {	×
198	if err = mgr.Add(pprof.New(profilingAddr)); err != nil {	×
199	setupLog.Error(err, "unable to create pprof service")	×
200	os.Exit(1)	×
201	}	×
202	}
203
204	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {	×
205	setupLog.Error(err, "unable to set up health check")	×
206	os.Exit(1)	×
207	}	×
208	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {	×
209	setupLog.Error(err, "unable to set up ready check")	×
210	os.Exit(1)	×
211	}	×
212
213	setupLog.Info("starting manager")	×
214	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {	×
215	setupLog.Error(err, "problem running manager")	×
216	os.Exit(1)	×
217	}	×
218	}
219
220	func printVersion() {	×
221	setupLog.Info(fmt.Sprintf("Operator Version: %s", version.Version))	×
222	setupLog.Info(fmt.Sprintf("Go Version: %s", gr.Version()))	×
223	setupLog.Info(fmt.Sprintf("Go OS/Arch: %s/%s", gr.GOOS, gr.GOARCH))	×
224	}	×

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