diff --git a/pkg/hook/hook_manager.go b/pkg/hook/hook_manager.go index 2c2a2b86..9bef3492 100644 --- a/pkg/hook/hook_manager.go +++ b/pkg/hook/hook_manager.go @@ -90,13 +90,13 @@ func (hm *Manager) TempDir() string { // Init finds executables in WorkingDir, execute them with --config argument and add them into indices. func (hm *Manager) Init() error { - log.Info("Initialize hooks manager. Search for and load all hooks.") + hm.logger.Info("Initialize hooks manager. Search for and load all hooks.") hm.hooksInOrder = make(map[htypes.BindingType][]*Hook) hm.hooksByName = make(map[string]*Hook) if err := utils_file.RecursiveCheckLibDirectory(hm.workingDir); err != nil { - log.Error("failed to check lib directory", + hm.logger.Error("failed to check lib directory", slog.String("workingDir", hm.workingDir), log.Err(err)) } @@ -108,7 +108,7 @@ func (hm *Manager) Init() error { // sort hooks by path sort.Strings(hooksRelativePaths) - log.Debug("Search hooks in paths", slog.Any("paths", hooksRelativePaths)) + hm.logger.Debug("Search hooks in paths", slog.Any("paths", hooksRelativePaths)) for _, hookPath := range hooksRelativePaths { hook, err := hm.loadHook(hookPath) @@ -141,9 +141,7 @@ func (hm *Manager) loadHook(hookPath string) (*Hook, error) { } hook := NewHook(hookName, hookPath, app.DebugKeepTmpFiles, app.LogProxyHookJSON, app.ProxyJsonLogKey, hm.logger.Named("hook")) - hookEntry := hm.logger.With("hook", hook.Name). - With("phase", "config") - + hookEntry := hm.logger.With(slog.String("hook", hook.Name), slog.String("phase", "config")) hookEntry.Info("Load config", slog.String("path", hookPath)) envs := make([]string, 0) @@ -230,8 +228,7 @@ func (hm *Manager) execCommandOutput(hookName string, dir string, entrypoint str WithCMDStderr(nil). WithLogger(hm.logger.Named("executor")) - debugEntry := hm.logger.With("hook", hookName). - With("cmd", strings.Join(args, " ")) + debugEntry := hm.logger.With(slog.String("hook", hookName), slog.String("cmd", strings.Join(args, " "))) debugEntry.Debug("Executing hook", slog.String("dir", dir)) @@ -250,7 +247,7 @@ func (hm *Manager) GetHook(name string) *Hook { if exists { return hook } - log.Error("Possible bug!!! Hook not found in hook manager", slog.String("name", name)) + hm.logger.Error("Possible bug!!! Hook not found in hook manager", slog.String("name", name)) return nil } @@ -378,7 +375,7 @@ func (hm *Manager) DetectAdmissionEventType(event admission.Event) htypes.Bindin } } - log.Error("Possible bug!!! No linked hook for admission event %s %s kind=%s name=%s ns=%s", + hm.logger.Error("Possible bug!!! No linked hook for admission event", slog.String("configId", event.ConfigurationId), slog.String("webhookId", event.WebhookId), slog.String("kind", event.Request.Kind.String()), diff --git a/pkg/shell-operator/bootstrap.go b/pkg/shell-operator/bootstrap.go index 98f7b1df..dc4522c7 100644 --- a/pkg/shell-operator/bootstrap.go +++ b/pkg/shell-operator/bootstrap.go @@ -213,12 +213,12 @@ func (op *ShellOperator) SetupEventManagers() { // setupHookManagers instantiates different hook managers. func (op *ShellOperator) setupHookManagers(hooksDir string, tempDir string) { // Initialize admission webhooks manager. - op.AdmissionWebhookManager = admission.NewWebhookManager(op.KubeClient) + op.AdmissionWebhookManager = admission.NewWebhookManager(op.KubeClient, admission.WithLogger(op.logger.Named("admission-webhook-manager"))) op.AdmissionWebhookManager.Settings = admission.DefaultSettings op.AdmissionWebhookManager.Namespace = app.Namespace // Initialize conversion webhooks manager. - op.ConversionWebhookManager = conversion.NewWebhookManager() + op.ConversionWebhookManager = conversion.NewWebhookManager(conversion.WithLogger(op.logger.Named("conversion-webhook-manager"))) op.ConversionWebhookManager.KubeClient = op.KubeClient op.ConversionWebhookManager.Settings = conversion.DefaultSettings op.ConversionWebhookManager.Namespace = app.Namespace diff --git a/pkg/shell-operator/operator.go b/pkg/shell-operator/operator.go index 3c7d28f5..e6cf9e99 100644 --- a/pkg/shell-operator/operator.go +++ b/pkg/shell-operator/operator.go @@ -123,7 +123,7 @@ func NewShellOperator(ctx context.Context, metricsStorage, hookMetricStorage met // Start run the operator func (op *ShellOperator) Start() { - log.Info("start shell-operator") + op.logger.Info("start shell-operator") op.APIServer.Start(op.ctx) @@ -258,10 +258,11 @@ func (op *ShellOperator) initValidatingWebhookManager() error { "event": string(eventBindingType), } logEntry := utils.EnrichLoggerWithLabels(op.logger, logLabels) - logEntry.Debug("Handle event", + logEntry = logEntry.With( slog.String("type", string(eventBindingType)), slog.String("configurationId", event.ConfigurationId), slog.String("webhookID", event.WebhookId)) + logEntry.Debug("Handle event") var admissionTask task.Task op.HookManager.HandleAdmissionEvent(ctx, event, func(hook *hook.Hook, info controller.BindingExecutionInfo) { @@ -282,10 +283,7 @@ func (op *ShellOperator) initValidatingWebhookManager() error { // Assert exactly one task is created. if admissionTask == nil { - logEntry.Error("Possible bug!!! No hook found for event", - slog.String("type", string(types.KubernetesValidating)), - slog.String("configurationId", event.ConfigurationId), - slog.String("webhookID", event.WebhookId)) + logEntry.Error("Possible bug!!! No hook found for event") return nil, fmt.Errorf("no hook found for '%s' '%s'", event.ConfigurationId, event.WebhookId) } @@ -440,7 +438,7 @@ func (op *ShellOperator) conversionEventHandler(ctx context.Context, crdName str } return &conversion.Response{ - FailedMessage: fmt.Sprintf("Conversion to %s was not successuful", request.DesiredAPIVersion), + FailedMessage: fmt.Sprintf("Conversion %s to %s was not successful", crdName, request.DesiredAPIVersion), }, nil } @@ -841,7 +839,7 @@ func (op *ShellOperator) CombineBindingContextForHook(q *queue.TaskQueue, t task } else { compactMsg = fmt.Sprintf("are combined to %d contexts", len(combinedContext)) } - log.Info("Binding contexts from tasks. Tasks are dropped from queue", + op.logger.Info("Binding contexts from tasks. Tasks are dropped from queue", slog.Int("count", len(otherTasks)+1), slog.String("tasks", compactMsg), slog.Int("filteredCount", len(tasksFilter)-1), diff --git a/pkg/webhook/admission/handler.go b/pkg/webhook/admission/handler.go index 64409889..8df88b06 100644 --- a/pkg/webhook/admission/handler.go +++ b/pkg/webhook/admission/handler.go @@ -22,12 +22,15 @@ type EventHandlerFn func(ctx context.Context, event Event) (*Response, error) type WebhookHandler struct { Router chi.Router Handler EventHandlerFn + + Logger *log.Logger } -func NewWebhookHandler() *WebhookHandler { +func NewWebhookHandler(logger *log.Logger) *WebhookHandler { rtr := chi.NewRouter() h := &WebhookHandler{ Router: rtr, + Logger: logger, } rtr.Group(func(r chi.Router) { @@ -37,7 +40,7 @@ func NewWebhookHandler() *WebhookHandler { }) rtr.Group(func(r chi.Router) { - r.Use(structuredLogger.NewStructuredLogger(log.NewLogger().Named("admissionWebhook"), "admissionWebhook")) + r.Use(structuredLogger.NewStructuredLogger(logger.Named("admissionWebhook"), "admissionWebhook")) r.Use(middleware.Recoverer) r.Use(middleware.AllowContentType("application/json")) r.Post("/*", h.serveReviewRequest) @@ -53,20 +56,29 @@ func (h *WebhookHandler) serveReviewRequest(w http.ResponseWriter, r *http.Reque var admissionReview v1.AdmissionReview err := json.NewDecoder(r.Body).Decode(&admissionReview) if err != nil { - log.Error("failed to read admission request", log.Err(err)) + h.Logger.Error("failed to decode AdmissionReview body to json", log.Err(err)) w.WriteHeader(http.StatusBadRequest) + _, _ = w.Write([]byte("Invalid JSON payload")) return } if admissionReview.Request == nil { - log.Error("admission request is nil") + h.Logger.Error("AdmissionReview request is nil") w.WriteHeader(http.StatusBadRequest) + _, _ = w.Write([]byte("Missing parameters: request")) return } + logger := h.Logger.With( + slog.String("request", string(admissionReview.Request.UID)), + slog.String("name", admissionReview.Request.Name), + slog.String("namespace", admissionReview.Request.Namespace), + slog.String("kind", admissionReview.Request.Kind.Kind), + ) + admissionResponse, err := h.handleReviewRequest(ctx, r.URL.Path, admissionReview.Request) if err != nil { - log.Error("validation failed", "request", admissionReview.Request.UID, log.Err(err)) + logger.Error("validation failed", log.Err(err)) admissionReview.Response = errored(err) } else { admissionReview.Response = admissionResponse @@ -80,16 +92,20 @@ func (h *WebhookHandler) serveReviewRequest(w http.ResponseWriter, r *http.Reque if err != nil { w.WriteHeader(http.StatusInternalServerError) _, _ = w.Write([]byte("Error json encoding AdmissionReview")) - log.Error("Error json encoding AdmissionReview", log.Err(err)) + logger.Error("error json encoding AdmissionReview", log.Err(err)) return } } func (h *WebhookHandler) handleReviewRequest(ctx context.Context, path string, request *v1.AdmissionRequest) (*v1.AdmissionResponse, error) { configurationID, webhookID := detectConfigurationAndWebhook(path) - log.Info("Got AdmissionReview request", + h.Logger.Info("Got AdmissionReview request", slog.String("configurationID", configurationID), - slog.String("webhookID", webhookID)) + slog.String("webhookID", webhookID), + slog.String("kind", request.Kind.Kind), + slog.String("name", request.Name), + slog.String("namespace", request.Namespace), + ) if h.Handler == nil { return nil, fmt.Errorf("AdmissionReview handler is not defined") @@ -103,7 +119,7 @@ func (h *WebhookHandler) handleReviewRequest(ctx context.Context, path string, r admissionResponse, err := h.Handler(ctx, event) if err != nil { - return nil, err + return nil, fmt.Errorf("handle AdmissionReview: %w", err) } response := &v1.AdmissionResponse{ diff --git a/pkg/webhook/admission/manager.go b/pkg/webhook/admission/manager.go index b34459c0..7858541a 100644 --- a/pkg/webhook/admission/manager.go +++ b/pkg/webhook/admission/manager.go @@ -1,6 +1,7 @@ package admission import ( + "fmt" "os" "github.com/deckhouse/deckhouse/pkg/log" @@ -31,14 +32,34 @@ type WebhookManager struct { ValidatingResources map[string]*ValidatingWebhookResource MutatingResources map[string]*MutatingWebhookResource Handler *WebhookHandler + + Logger *log.Logger +} + +type Option func(manager *WebhookManager) + +func WithLogger(logger *log.Logger) Option { + return func(manager *WebhookManager) { + manager.Logger = logger + } } -func NewWebhookManager(kubeClient *klient.Client) *WebhookManager { - return &WebhookManager{ +func NewWebhookManager(kubeClient *klient.Client, opts ...Option) *WebhookManager { + manager := &WebhookManager{ ValidatingResources: make(map[string]*ValidatingWebhookResource), MutatingResources: make(map[string]*MutatingWebhookResource), KubeClient: kubeClient, } + + for _, opt := range opts { + opt(manager) + } + + if manager.Logger == nil { + manager.Logger = log.NewLogger().Named("admission-webhook-manager") + } + + return manager } func (m *WebhookManager) WithAdmissionEventHandler(handler EventHandlerFn) { @@ -53,7 +74,7 @@ func (m *WebhookManager) WithAdmissionEventHandler(handler EventHandlerFn) { // Init creates dependencies func (m *WebhookManager) Init() error { - log.Info("Initialize admission webhooks manager. Load certificates.") + m.Logger.Info("Initialize admission webhooks manager. Load certificates.") if m.DefaultConfigurationId == "" { m.DefaultConfigurationId = DefaultConfigurationId @@ -61,17 +82,13 @@ func (m *WebhookManager) Init() error { // settings caBundleBytes, err := os.ReadFile(m.Settings.CAPath) if err != nil { - return err + return fmt.Errorf("read CA bundle: %w", err) } m.Settings.CABundle = caBundleBytes - m.Handler = NewWebhookHandler() + m.Handler = NewWebhookHandler(m.Logger) - m.Server = &server.WebhookServer{ - Settings: &m.Settings.Settings, - Namespace: m.Namespace, - Router: m.Handler.Router, - } + m.Server = server.NewWebhookServer(&m.Settings.Settings, m.Namespace, m.Handler.Router, m.Logger) return nil } @@ -91,6 +108,7 @@ func (m *WebhookManager) AddValidatingWebhook(config *ValidatingWebhookConfig) { m.Settings.ServiceName, m.Settings.CABundle, }, + m.Logger, ) m.ValidatingResources[confId] = r } @@ -113,6 +131,7 @@ func (m *WebhookManager) AddMutatingWebhook(config *MutatingWebhookConfig) { m.Settings.ServiceName, m.Settings.CABundle, }, + m.Logger, ) m.MutatingResources[confId] = r } @@ -122,20 +141,20 @@ func (m *WebhookManager) AddMutatingWebhook(config *MutatingWebhookConfig) { func (m *WebhookManager) Start() error { err := m.Server.Start() if err != nil { - return err + return fmt.Errorf("start webhook server: %w", err) } for _, r := range m.ValidatingResources { err = r.Register() if err != nil { - return err + return fmt.Errorf("register validating webhook: %w", err) } } for _, r := range m.MutatingResources { err = r.Register() if err != nil { - return err + return fmt.Errorf("register mutating webhook: %w", err) } } diff --git a/pkg/webhook/admission/resource.go b/pkg/webhook/admission/resource.go index 92431251..cf4d67d4 100644 --- a/pkg/webhook/admission/resource.go +++ b/pkg/webhook/admission/resource.go @@ -2,6 +2,7 @@ package admission import ( "context" + "fmt" "log/slog" "strings" @@ -24,12 +25,15 @@ type WebhookResourceOptions struct { type ValidatingWebhookResource struct { hooks map[string]*ValidatingWebhookConfig opts WebhookResourceOptions + + logger *log.Logger } -func NewValidatingWebhookResource(opts WebhookResourceOptions) *ValidatingWebhookResource { +func NewValidatingWebhookResource(opts WebhookResourceOptions, logger *log.Logger) *ValidatingWebhookResource { return &ValidatingWebhookResource{ - hooks: make(map[string]*ValidatingWebhookConfig), - opts: opts, + hooks: make(map[string]*ValidatingWebhookConfig), + opts: opts, + logger: logger, } } @@ -60,7 +64,7 @@ func (w *ValidatingWebhookResource) Register() error { CABundle: w.opts.CABundle, } - log.Info("Add path to config", + w.logger.Info("Add path to config", slog.String("path", *webhook.ClientConfig.Service.Path), slog.String("configurationName", w.opts.ConfigurationName)) @@ -93,6 +97,7 @@ func createWebhookPath(webhook IWebhookConfig) *string { } func (w *ValidatingWebhookResource) submit(conf *v1.ValidatingWebhookConfiguration) error { + logger := w.logger.With(slog.String("name", conf.Name)) client := w.opts.KubeClient.AdmissionregistrationV1().ValidatingWebhookConfigurations() listOpts := metav1.ListOptions{ @@ -100,23 +105,19 @@ func (w *ValidatingWebhookResource) submit(conf *v1.ValidatingWebhookConfigurati } list, err := client.List(context.TODO(), listOpts) if err != nil { - return err + return fmt.Errorf("list ValidatingWebhookConfiguration: %w", err) } if len(list.Items) == 0 { _, err = client.Create(context.TODO(), conf, pkg.DefaultCreateOptions()) if err != nil { - log.Error("Create ValidatingWebhookConfiguration", - slog.String("name", conf.Name), - log.Err(err)) + logger.Error("Create ValidatingWebhookConfiguration", log.Err(err)) } } else { newConf := list.Items[0] newConf.Webhooks = conf.Webhooks _, err = client.Update(context.TODO(), &newConf, pkg.DefaultUpdateOptions()) if err != nil { - log.Error("Replace ValidatingWebhookConfiguration", - slog.String("name", conf.Name), - log.Err(err)) + logger.Error("Replace ValidatingWebhookConfiguration", log.Err(err)) } } return nil @@ -125,12 +126,15 @@ func (w *ValidatingWebhookResource) submit(conf *v1.ValidatingWebhookConfigurati type MutatingWebhookResource struct { hooks map[string]*MutatingWebhookConfig opts WebhookResourceOptions + + logger *log.Logger } -func NewMutatingWebhookResource(opts WebhookResourceOptions) *MutatingWebhookResource { +func NewMutatingWebhookResource(opts WebhookResourceOptions, logger *log.Logger) *MutatingWebhookResource { return &MutatingWebhookResource{ - hooks: make(map[string]*MutatingWebhookConfig), - opts: opts, + hooks: make(map[string]*MutatingWebhookConfig), + opts: opts, + logger: logger, } } @@ -161,7 +165,7 @@ func (w *MutatingWebhookResource) Register() error { CABundle: w.opts.CABundle, } - log.Info("Add path to config", + w.logger.Info("Add path to config", slog.String("path", *webhook.ClientConfig.Service.Path), slog.String("configurationName", w.opts.ConfigurationName)) @@ -177,6 +181,7 @@ func (w *MutatingWebhookResource) Unregister() error { } func (w *MutatingWebhookResource) submit(conf *v1.MutatingWebhookConfiguration) error { + logger := w.logger.With(slog.String("name", conf.Name)) client := w.opts.KubeClient.AdmissionregistrationV1().MutatingWebhookConfigurations() listOpts := metav1.ListOptions{ @@ -184,23 +189,19 @@ func (w *MutatingWebhookResource) submit(conf *v1.MutatingWebhookConfiguration) } list, err := client.List(context.TODO(), listOpts) if err != nil { - return err + return fmt.Errorf("list MutatingWebhookConfiguration: %w", err) } if len(list.Items) == 0 { _, err = client.Create(context.TODO(), conf, pkg.DefaultCreateOptions()) if err != nil { - log.Error("Create MutatingWebhookConfiguration", - slog.String("name", conf.Name), - log.Err(err)) + logger.Error("Create MutatingWebhookConfiguration", log.Err(err)) } } else { newConf := list.Items[0] newConf.Webhooks = conf.Webhooks _, err = client.Update(context.TODO(), &newConf, pkg.DefaultUpdateOptions()) if err != nil { - log.Error("Replace MutatingWebhookConfiguration", - slog.String("name", conf.Name), - log.Err(err)) + logger.Error("Replace MutatingWebhookConfiguration", log.Err(err)) } } return nil diff --git a/pkg/webhook/conversion/crd_client_config.go b/pkg/webhook/conversion/crd_client_config.go index 128bb40d..af355486 100644 --- a/pkg/webhook/conversion/crd_client_config.go +++ b/pkg/webhook/conversion/crd_client_config.go @@ -2,6 +2,7 @@ package conversion import ( "context" + "fmt" "time" extv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1" @@ -39,7 +40,7 @@ tryToGetCRD: goto tryToGetCRD } - return err + return fmt.Errorf("get CRD: %w", err) } if crd.Spec.Conversion == nil { @@ -63,7 +64,7 @@ tryToGetCRD: _, err = client.ApiExt().CustomResourceDefinitions().Update(ctx, crd, pkg.DefaultUpdateOptions()) if err != nil { - return err + return fmt.Errorf("update CRD: %w", err) } return nil diff --git a/pkg/webhook/conversion/handler.go b/pkg/webhook/conversion/handler.go index f44e9f68..94c4778d 100644 --- a/pkg/webhook/conversion/handler.go +++ b/pkg/webhook/conversion/handler.go @@ -22,12 +22,15 @@ import ( type WebhookHandler struct { Manager *WebhookManager Router chi.Router + + Logger *log.Logger } -func NewWebhookHandler() *WebhookHandler { +func NewWebhookHandler(logger *log.Logger) *WebhookHandler { rtr := chi.NewRouter() h := &WebhookHandler{ Router: rtr, + Logger: logger, } rtr.Group(func(r chi.Router) { @@ -37,7 +40,7 @@ func NewWebhookHandler() *WebhookHandler { }) rtr.Group(func(r chi.Router) { - r.Use(structuredLogger.NewStructuredLogger(log.NewLogger().Named("conversionWebhook"), "conversionWebhook")) + r.Use(structuredLogger.NewStructuredLogger(logger.Named("conversionWebhook"), "conversionWebhook")) r.Use(middleware.Recoverer) r.Use(middleware.AllowContentType("application/json")) r.Post("/*", h.serveReviewRequest) @@ -51,26 +54,33 @@ func (h *WebhookHandler) serveReviewRequest(w http.ResponseWriter, r *http.Reque ctx := r.Context() crdName := detectCrdName(r.URL.Path) - log.Info("Got ConversionReview request for crd", - slog.String("name", crdName)) + + logger := h.Logger.With(slog.String("crd", crdName)) + logger.Info("serving ConversionReview request") var convertReview v1.ConversionReview err := json.NewDecoder(r.Body).Decode(&convertReview) if err != nil { - log.Error("failed to read conversion request", log.Err(err)) + logger.Error("failed to decode ConversionReview body to json", log.Err(err)) w.WriteHeader(http.StatusBadRequest) + _, _ = w.Write([]byte("Invalid JSON payload")) return } if convertReview.Request == nil { - log.Error("conversion request is nil") + logger.Error("ConversionReview request is nil") w.WriteHeader(http.StatusBadRequest) + _, _ = w.Write([]byte("Missing parameters: request")) return } + logger = logger.With( + slog.String("request", string(convertReview.Request.UID)), + slog.String("kind", convertReview.Kind)) + conversionResponse, err := h.handleReviewRequest(ctx, crdName, convertReview.Request) if err != nil { - log.Error("failed to convert", "request", convertReview.Request.UID, log.Err(err)) + logger.Error("conversion failed", log.Err(err)) convertReview.Response = errored(err) } else { convertReview.Response = conversionResponse @@ -84,7 +94,7 @@ func (h *WebhookHandler) serveReviewRequest(w http.ResponseWriter, r *http.Reque if err != nil { w.WriteHeader(http.StatusInternalServerError) _, _ = w.Write([]byte("Error json encoding ConversionReview")) - log.Error("Error json encoding ConversionReview", log.Err(err)) + logger.Error("error json encoding ConversionReview", log.Err(err)) return } } @@ -98,7 +108,7 @@ func (h *WebhookHandler) handleReviewRequest(ctx context.Context, crdName string conversionResponse, err := h.Manager.EventHandlerFn(ctx, crdName, request) if err != nil { - return nil, err + return nil, fmt.Errorf("handle ConversionReview: %w", err) } if conversionResponse.FailedMessage != "" { diff --git a/pkg/webhook/conversion/manager.go b/pkg/webhook/conversion/manager.go index cecc1e3e..83e8ce04 100644 --- a/pkg/webhook/conversion/manager.go +++ b/pkg/webhook/conversion/manager.go @@ -2,6 +2,7 @@ package conversion import ( "context" + "fmt" "os" "github.com/deckhouse/deckhouse/pkg/log" @@ -35,33 +36,49 @@ type WebhookManager struct { Server *server.WebhookServer ClientConfigs map[string]*CrdClientConfig Handler *WebhookHandler + + Logger *log.Logger +} + +type Option func(manager *WebhookManager) + +func WithLogger(logger *log.Logger) Option { + return func(manager *WebhookManager) { + manager.Logger = logger + } } -func NewWebhookManager() *WebhookManager { - return &WebhookManager{ +func NewWebhookManager(opts ...Option) *WebhookManager { + manager := &WebhookManager{ ClientConfigs: make(map[string]*CrdClientConfig), } + + for _, opt := range opts { + opt(manager) + } + + if manager.Logger == nil { + manager.Logger = log.NewLogger().Named("conversion-webhook-manager") + } + + return manager } // Init creates dependencies func (m *WebhookManager) Init() error { - log.Info("Initialize conversion webhooks manager. Load certificates.") + m.Logger.Info("Initialize conversion webhooks manager. Load certificates.") // settings caBundleBytes, err := os.ReadFile(m.Settings.CAPath) if err != nil { - return err + return fmt.Errorf("read CA bundle: %w", err) } m.Settings.CABundle = caBundleBytes - m.Handler = NewWebhookHandler() + m.Handler = NewWebhookHandler(m.Logger) m.Handler.Manager = m - m.Server = &server.WebhookServer{ - Settings: &m.Settings.Settings, - Namespace: m.Namespace, - Router: m.Handler.Router, - } + m.Server = server.NewWebhookServer(&m.Settings.Settings, m.Namespace, m.Handler.Router, m.Logger) return nil } @@ -69,17 +86,17 @@ func (m *WebhookManager) Init() error { // Start webhook server and update spec.conversion in CRDs. func (m *WebhookManager) Start() error { ctx := context.Background() - log.Info("Start conversion webhooks manager. Load certificates.") + m.Logger.Info("Start conversion webhooks manager. Load certificates.") err := m.Server.Start() if err != nil { - return err + return fmt.Errorf("start webhook server: %w", err) } for _, clientCfg := range m.ClientConfigs { err = clientCfg.Update(ctx) if err != nil { - return err + return fmt.Errorf("update CRD: %w", err) } } diff --git a/pkg/webhook/server/server.go b/pkg/webhook/server/server.go index 136a01a5..cb117016 100644 --- a/pkg/webhook/server/server.go +++ b/pkg/webhook/server/server.go @@ -18,6 +18,16 @@ type WebhookServer struct { Settings *Settings Namespace string Router chi.Router + Logger *log.Logger +} + +func NewWebhookServer(settings *Settings, namespace string, router chi.Router, logger *log.Logger) *WebhookServer { + return &WebhookServer{ + Settings: settings, + Namespace: namespace, + Router: router, + Logger: logger, + } } // Start runs https server to listen for AdmissionReview requests from the API-server. @@ -81,10 +91,10 @@ func (s *WebhookServer) Start() error { } go func() { - log.Info("Webhook server listens", slog.String("address", listenAddr)) + s.Logger.Info("Webhook server listens", slog.String("address", listenAddr)) err := srv.ServeTLS(listener, "", "") if err != nil { - log.Error("Error starting Webhook https server", log.Err(err)) + s.Logger.Error("Error starting Webhook https server", log.Err(err)) // Stop process if server can't start. os.Exit(1) } diff --git a/pkg/webhook/server/server_test.go b/pkg/webhook/server/server_test.go index f13e66c8..45ac5a10 100644 --- a/pkg/webhook/server/server_test.go +++ b/pkg/webhook/server/server_test.go @@ -5,6 +5,7 @@ import ( "os" "testing" + "github.com/deckhouse/deckhouse/pkg/log" "github.com/go-chi/chi/v5" ) @@ -16,10 +17,7 @@ func Test_ServerStart(t *testing.T) { rtr := chi.NewRouter() - srv := &WebhookServer{ - Settings: s, - Router: rtr, - } + srv := NewWebhookServer(s, "", rtr, log.NewNop()) err := srv.Start() if err != nil { diff --git a/test/hook/context/context_combiner.go b/test/hook/context/context_combiner.go index 5601bc67..c7d0b107 100644 --- a/test/hook/context/context_combiner.go +++ b/test/hook/context/context_combiner.go @@ -31,11 +31,18 @@ type ContextCombiner struct { } func NewContextCombiner() *ContextCombiner { - op := &shell_operator.ShellOperator{} - op.MetricStorage = metricsstorage.NewMetricStorage( + metricStorage := metricsstorage.NewMetricStorage( metricsstorage.WithLogger(log.NewNop()), ) - op.TaskQueues = queue.NewTaskQueueSet().WithMetricStorage(op.MetricStorage) + + op := shell_operator.NewShellOperator( + context.Background(), + metricStorage, + metricStorage, + shell_operator.WithLogger(log.NewNop()), + ) + + op.TaskQueues = queue.NewTaskQueueSet().WithMetricStorage(metricStorage) op.TaskQueues.WithContext(context.Background()) op.TaskQueues.NewNamedQueue(TestQueueName, nil, queue.WithCompactableTypes(task_metadata.HookRun),