15259297026

Committed 26 May 2025 05:29PM UTC coverage: 54.205%. Remained the same

Build # 15259297026

Build Type

Pull #518

github

Committed by

bakito

Commit Message

fix deprecations

Pull Request Pull Request #518: chore(deps): bump sigs.k8s.io/controller-runtime from 0.20.4 to 0.21.0

Run Details

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

651 of 1201 relevant lines covered (54.2%)

0.62 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,
                LeaderElectionReleaseOnCancel: true,

                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	LeaderElectionReleaseOnCancel: true,	×
NEW 132		×
133	Cache: crtlcache.Options{	×
134	DefaultNamespaces: defaultNamespaces,	×
135	},	×
136	})	×
137	if err != nil {	×
138	setupLog.Error(err, "unable to start manager")	×
139	os.Exit(1)	×
140	}	×
141
142	if enableLoggerMode {	×
143	setupLog.WithValues("configName", configName).Info("Current configuration")	×
144	if err = (&logging.Reconciler{	×
145	Client: mgr.GetClient(),	×
146	Log: ctrl.Log.WithName("controllers").WithName("Event"),	×
147	Scheme: mgr.GetScheme(),	×
148	Config: logging.ConfigFor(configName, podNamespace, watchNamespace),	×
149	LoggerMode: true,	×
150	}).SetupWithManager(mgr, watchNamespace); err != nil {	×
151	setupLog.Error(err, "unable to create controller", "controller", "Event")	×
152	os.Exit(1)	×
153	}	×
154	} else {	×
155	// Setup all Controllers	×
156	if watchNamespace == "" {	×
157	cr := &config.Reconciler{	×
158	Reader: mgr.GetAPIReader(),	×
159	Log: ctrl.Log.WithName("controllers").WithName("Config"),	×
160	Scheme: mgr.GetScheme(),	×
161	}	×
162	if err = (cr).SetupWithManager(mgr); err != nil {	×
163	setupLog.Error(err, "unable to create controller", "controller", "Config")	×
164	os.Exit(1)	×
165	}	×
166	if err = (&setup.Reconciler{	×
167	Client: mgr.GetClient(),	×
168	Log: ctrl.Log.WithName("controllers").WithName("EventLogger"),	×
169	Scheme: mgr.GetScheme(),	×
170	Config: cr.Ctx(),	×
171	}).SetupWithManager(mgr); err != nil {	×
172	setupLog.Error(err, "unable to create controller", "controller", "EventLogger")	×
173	os.Exit(1)	×
174	}	×
175	setupLog.Info("Running in global mode.")	×
176		×
177	if os.Getenv(cnst.EnvEnableWebhook) != "false" {	×
178	if err = (&eventloggerv1.EventLogger{}).SetupWebhookWithManager(mgr); err != nil {	×
179	setupLog.Error(err, "unable to create webhook", "webhook", "EventLogger")	×
180	os.Exit(1)	×
181	}	×
182	}
183	} else {	×
184	if err = (&logging.Reconciler{	×
185	Client: mgr.GetClient(),	×
186	Log: ctrl.Log.WithName("controllers").WithName("Event"),	×
187	Scheme: mgr.GetScheme(),	×
188	Config: logging.ConfigFor(configName, podNamespace, watchNamespace),	×
189	LoggerMode: false,	×
190	}).SetupWithManager(mgr, watchNamespace); err != nil {	×
191	setupLog.Error(err, "unable to create controller", "controller", "Event")	×
192	os.Exit(1)	×
193	}	×
194	setupLog.WithValues("namespace", watchNamespace).Info("Running in single namespace mode.")	×
195	}
196	}
197	// +kubebuilder:scaffold:builder
198
199	if enableProfiling {	×
200	if err = mgr.Add(pprof.New(profilingAddr)); err != nil {	×
201	setupLog.Error(err, "unable to create pprof service")	×
202	os.Exit(1)	×
203	}	×
204	}
205
206	if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil {	×
207	setupLog.Error(err, "unable to set up health check")	×
208	os.Exit(1)	×
209	}	×
210	if err := mgr.AddReadyzCheck("readyz", healthz.Ping); err != nil {	×
211	setupLog.Error(err, "unable to set up ready check")	×
212	os.Exit(1)	×
213	}	×
214
215	setupLog.Info("starting manager")	×
216	if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {	×
217	setupLog.Error(err, "problem running manager")	×
218	os.Exit(1)	×
219	}	×
220	}
221
222	func printVersion() {	×
223	setupLog.Info(fmt.Sprintf("Operator Version: %s", version.Version))	×
224	setupLog.Info(fmt.Sprintf("Go Version: %s", gr.Version()))	×
225	setupLog.Info(fmt.Sprintf("Go OS/Arch: %s/%s", gr.GOOS, gr.GOARCH))	×
226	}	×

bakito / k8s-event-logger-operator / 15259297026

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