diff --git a/.custom-gcl.yml b/.custom-gcl.yml new file mode 100644 index 00000000..6ef11b3b --- /dev/null +++ b/.custom-gcl.yml @@ -0,0 +1,11 @@ +# This file configures golangci-lint with module plugins. +# When you run 'make lint', it will automatically build a custom golangci-lint binary +# with all the plugins listed below. +# +# See: https://golangci-lint.run/plugins/module-plugins/ +version: v2.8.0 +plugins: + # logcheck validates structured logging calls and parameters (e.g., balanced key-value pairs) + - module: "sigs.k8s.io/logtools" + import: "sigs.k8s.io/logtools/logcheck/gclplugin" + version: latest diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 00000000..4f1941f2 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,38 @@ +{ + "name": "Kubebuilder DevContainer", + "image": "golang:1.25", + "features": { + "ghcr.io/devcontainers/features/docker-in-docker:2": { + "moby": false, + "dockerDefaultAddressPool": "base=172.30.0.0/16,size=24" + }, + "ghcr.io/devcontainers/features/git:1": {}, + "ghcr.io/devcontainers/features/common-utils:2": { + "upgradePackages": true + } + }, + "runArgs": [ + "--privileged", + "--init" + ], + "customizations": { + "vscode": { + "settings": { + "terminal.integrated.profiles.linux": { + "bash": { + "path": "/bin/bash" + } + }, + "terminal.integrated.defaultProfile.linux": "bash" + }, + "extensions": [ + "ms-kubernetes-tools.vscode-kubernetes-tools", + "ms-azuretools.vscode-docker" + ] + } + }, + "remoteEnv": { + "GO111MODULE": "on" + }, + "onCreateCommand": "bash .devcontainer/post-install.sh" +} \ No newline at end of file diff --git a/.devcontainer/post-install.sh b/.devcontainer/post-install.sh new file mode 100644 index 00000000..6d75a49c --- /dev/null +++ b/.devcontainer/post-install.sh @@ -0,0 +1,153 @@ +#!/bin/bash +set -euo pipefail + +echo "====================================" +echo "Kubebuilder DevContainer Setup" +echo "====================================" + +# Verify running as root (required for installing to /usr/local/bin and /etc) +if [ "$(id -u)" -ne 0 ]; then + echo "ERROR: This script must be run as root" + exit 1 +fi + +echo "" +echo "Detecting system architecture..." +# Detect architecture using uname +MACHINE=$(uname -m) +case "${MACHINE}" in + x86_64) + ARCH="amd64" + ;; + aarch64|arm64) + ARCH="arm64" + ;; + *) + echo "WARNING: Unsupported architecture ${MACHINE}, defaulting to amd64" + ARCH="amd64" + ;; +esac +echo "Architecture: ${ARCH}" + +echo "" +echo "------------------------------------" +echo "Setting up bash completion..." +echo "------------------------------------" + +BASH_COMPLETIONS_DIR="/usr/share/bash-completion/completions" + +# Enable bash-completion in root's .bashrc (devcontainer runs as root) +if ! grep -q "source /usr/share/bash-completion/bash_completion" ~/.bashrc 2>/dev/null; then + echo 'source /usr/share/bash-completion/bash_completion' >> ~/.bashrc + echo "Added bash-completion to .bashrc" +fi + +echo "" +echo "------------------------------------" +echo "Installing development tools..." +echo "------------------------------------" + +# Install kind +if ! command -v kind &> /dev/null; then + echo "Installing kind..." + curl -Lo /usr/local/bin/kind "https://kind.sigs.k8s.io/dl/latest/kind-linux-${ARCH}" + chmod +x /usr/local/bin/kind + echo "kind installed successfully" +fi + +# Generate kind bash completion +if command -v kind &> /dev/null; then + if kind completion bash > "${BASH_COMPLETIONS_DIR}/kind" 2>/dev/null; then + echo "kind completion installed" + else + echo "WARNING: Failed to generate kind completion" + fi +fi + +# Install kubebuilder +if ! command -v kubebuilder &> /dev/null; then + echo "Installing kubebuilder..." + curl -Lo /usr/local/bin/kubebuilder "https://go.kubebuilder.io/dl/latest/linux/${ARCH}" + chmod +x /usr/local/bin/kubebuilder + echo "kubebuilder installed successfully" +fi + +# Generate kubebuilder bash completion +if command -v kubebuilder &> /dev/null; then + if kubebuilder completion bash > "${BASH_COMPLETIONS_DIR}/kubebuilder" 2>/dev/null; then + echo "kubebuilder completion installed" + else + echo "WARNING: Failed to generate kubebuilder completion" + fi +fi + +# Install kubectl +if ! command -v kubectl &> /dev/null; then + echo "Installing kubectl..." + KUBECTL_VERSION=$(curl -Ls https://dl.k8s.io/release/stable.txt) + curl -Lo /usr/local/bin/kubectl "https://dl.k8s.io/release/${KUBECTL_VERSION}/bin/linux/${ARCH}/kubectl" + chmod +x /usr/local/bin/kubectl + echo "kubectl installed successfully" +fi + +# Generate kubectl bash completion +if command -v kubectl &> /dev/null; then + if kubectl completion bash > "${BASH_COMPLETIONS_DIR}/kubectl" 2>/dev/null; then + echo "kubectl completion installed" + else + echo "WARNING: Failed to generate kubectl completion" + fi +fi + +# Generate Docker bash completion +if command -v docker &> /dev/null; then + if docker completion bash > "${BASH_COMPLETIONS_DIR}/docker" 2>/dev/null; then + echo "docker completion installed" + else + echo "WARNING: Failed to generate docker completion" + fi +fi + +echo "" +echo "------------------------------------" +echo "Configuring Docker environment..." +echo "------------------------------------" + +# Wait for Docker to be ready +echo "Waiting for Docker to be ready..." +for i in {1..30}; do + if docker info >/dev/null 2>&1; then + echo "Docker is ready" + break + fi + if [ "$i" -eq 30 ]; then + echo "WARNING: Docker not ready after 30s" + fi + sleep 1 +done + +# Create kind network (ignore if already exists) +if ! docker network inspect kind >/dev/null 2>&1; then + if docker network create kind >/dev/null 2>&1; then + echo "Created kind network" + else + echo "WARNING: Failed to create kind network (may already exist)" + fi +fi + +echo "" +echo "------------------------------------" +echo "Verifying installations..." +echo "------------------------------------" +kind version +kubebuilder version +kubectl version --client +docker --version +go version + +echo "" +echo "====================================" +echo "DevContainer ready!" +echo "====================================" +echo "All development tools installed successfully." +echo "You can now start building Kubernetes operators." diff --git a/.golangci.yml b/.golangci.yml index 1cf83bec..a5585005 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -22,7 +22,12 @@ linters: - unconvert - unparam - unused + - logcheck settings: + custom: + logcheck: + type: "module" + description: Checks Go logging calls for Kubernetes logging conventions. revive: rules: - name: comment-spacings diff --git a/AGENTS.md b/AGENTS.md index 5a17db01..73d57251 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,177 +1,320 @@ -## Purpose +# metal-operator - AI Agent Guide + +## Project Structure + +**Single-group layout (default):** +``` +cmd/main.go Manager entry (registers controllers/webhooks) +api//*_types.go CRD schemas (+kubebuilder markers) +api//zz_generated.* Auto-generated (DO NOT EDIT) +internal/controller/* Reconciliation logic +internal/webhook/* Validation/defaulting (if present) +config/crd/bases/* Generated CRDs (DO NOT EDIT) +config/rbac/role.yaml Generated RBAC (DO NOT EDIT) +config/samples/* Example CRs (edit these) +Makefile Build/test/deploy commands +PROJECT Kubebuilder metadata Auto-generated (DO NOT EDIT) +``` + +**Multi-group layout** (for projects with multiple API groups): +``` +api///*_types.go CRD schemas by group +internal/controller//* Controllers by group +internal/webhook///* Webhooks by group and version (if present) +``` + +Multi-group layout organizes APIs by group name (e.g., `batch`, `apps`). Check the `PROJECT` file for `multigroup: true`. + +**To convert to multi-group layout:** +1. Run: `kubebuilder edit --multigroup=true` +2. Move APIs: `mkdir -p api/ && mv api/ api//` +3. Move controllers: `mkdir -p internal/controller/ && mv internal/controller/*.go internal/controller//` +4. Move webhooks (if present): `mkdir -p internal/webhook/ && mv internal/webhook/ internal/webhook//` +5. Update import paths in all files +6. Fix `path` in `PROJECT` file for each resource +7. Update test suite CRD paths (add one more `..` to relative paths) + +## Critical Rules + +### Never Edit These (Auto-Generated) +- `config/crd/bases/*.yaml` - from `make manifests` +- `config/rbac/role.yaml` - from `make manifests` +- `config/webhook/manifests.yaml` - from `make manifests` +- `**/zz_generated.*.go` - from `make generate` +- `PROJECT` - from `kubebuilder [OPTIONS]` + +### Never Remove Scaffold Markers +Do NOT delete `// +kubebuilder:scaffold:*` comments. CLI injects code at these markers. + +### Keep Project Structure +Do not move files around. The CLI expects files in specific locations. + +### Always Use CLI Commands +Always use `kubebuilder create api` and `kubebuilder create webhook` to scaffold. Do NOT create files manually. + +### E2E Tests Require an Isolated Kind Cluster +The e2e tests are designed to validate the solution in an isolated environment (similar to GitHub Actions CI). +Ensure you run them against a dedicated [Kind](https://kind.sigs.k8s.io/) cluster (not your “real” dev/prod cluster). + +## After Making Changes + +**After editing `*_types.go` or markers:** +``` +make manifests # Regenerate CRDs/RBAC from markers +make generate # Regenerate DeepCopy methods +``` + +**After editing `*.go` files:** +``` +make lint-fix # Auto-fix code style +make test # Run unit tests +``` + +## CLI Commands Cheat Sheet + +### Create API (your own types) +```bash +kubebuilder create api --group --version --kind +``` + +### Deploy Image Plugin (scaffold to deploy/manage ANY container image) + +Generate a controller that deploys and manages a container image (nginx, redis, memcached, your app, etc.): + +```bash +# Example: deploying memcached +kubebuilder create api --group example.com --version v1alpha1 --kind Memcached \ + --image=memcached:alpine \ + --plugins=deploy-image.go.kubebuilder.io/v1-alpha +``` + +Scaffolds good-practice code: reconciliation logic, status conditions, finalizers, RBAC. Use as a reference implementation. + + +### Create Webhooks +```bash +# Validation + defaulting +kubebuilder create webhook --group --version --kind \ + --defaulting --programmatic-validation + +# Conversion webhook (for multi-version APIs) +kubebuilder create webhook --group --version v1 --kind \ + --conversion --spoke v2 +``` + +### Controller for Core Kubernetes Types +```bash +# Watch Pods +kubebuilder create api --group core --version v1 --kind Pod \ + --controller=true --resource=false + +# Watch Deployments +kubebuilder create api --group apps --version v1 --kind Deployment \ + --controller=true --resource=false +``` + +### Controller for External Types (e.g., from other operators) + +Watch resources from external APIs (cert-manager, Argo CD, Istio, etc.): + +```bash +# Example: watching cert-manager Certificate resources +kubebuilder create api \ + --group cert-manager --version v1 --kind Certificate \ + --controller=true --resource=false \ + --external-api-path=github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1 \ + --external-api-domain=io \ + --external-api-module=github.com/cert-manager/cert-manager +``` + +**Note:** Use `--external-api-module=@` only if you need a specific version. Otherwise, omit `@` to use what's in go.mod. + +### Webhook for External Types + +```bash +# Example: validating external resources +kubebuilder create webhook \ + --group cert-manager --version v1 --kind Issuer \ + --defaulting \ + --external-api-path=github.com/cert-manager/cert-manager/pkg/apis/certmanager/v1 \ + --external-api-domain=io \ + --external-api-module=github.com/cert-manager/cert-manager +``` -This document defines review guidelines for automated and human reviewers of this repository. +## Testing & Development -The project is a **Kubernetes controller** built using **Kubebuilder** and **controller-runtime**. -Reviews must prioritize correctness, maintainability, and alignment with Kubernetes and Go community standards. +```bash +make test # Run unit tests (uses envtest: real K8s API + etcd) +make run # Run locally (uses current kubeconfig context) +``` ---- +Tests use **Ginkgo + Gomega** (BDD style). Check `suite_test.go` for setup. -## Primary References +## Deployment Workflow -Reviewers **must** be familiar with and evaluate changes against the following: +```bash +# 1. Regenerate manifests +make manifests generate -* Kubernetes API Conventions - [https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md](https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md) +# 2. Build & deploy +export IMG=/:tag +make docker-build docker-push IMG=$IMG # Or: kind load docker-image $IMG --name +make deploy IMG=$IMG + +# 3. Test +kubectl apply -k config/samples/ -* Kubebuilder Book - [https://book.kubebuilder.io/](https://book.kubebuilder.io/) +# 4. Debug +kubectl logs -n -system deployment/-controller-manager -c manager -f +``` -* controller-runtime documentation - [https://pkg.go.dev/sigs.k8s.io/controller-runtime](https://pkg.go.dev/sigs.k8s.io/controller-runtime) +### API Design -* Go Code Review Comments - [https://github.com/golang/go/wiki/CodeReviewComments](https://github.com/golang/go/wiki/CodeReviewComments) +**Key markers for** `api//*_types.go`: ---- - -## High-Level Review Principles - -* Prefer **declarative**, **idempotent**, and **level-based** reconciliation logic -* Follow Kubernetes API and controller patterns rather than inventing new abstractions -* Optimize for **clarity and correctness over cleverness** -* Ensure behavior is predictable under retries, restarts, and partial failures - ---- - -## Kubernetes API Review Checklist - -### API Types (CRDs) - -Reviewers should verify: - -* Fields follow Kubernetes naming conventions (camelCase JSON, PascalCase Go) -* `Spec` is declarative and user-facing; `Status` is controller-owned -* No mutable fields in `Spec` that belong in `Status` -* Clear separation of: - * Desired state (`Spec`) - * Observed state (`Status`) -* Use of standard types where applicable: - * `metav1.Time` - * `metav1.Condition` - * `resource.Quantity` -* Conditions follow Kubernetes conventions: - * Stable, well-defined `Type` - * Correct `Status`, `Reason`, and `Message` -* Defaulting and validation are implemented via: - * Webhooks (preferred) - * OpenAPI schema where applicable - -### Backward Compatibility - -* No breaking changes to existing fields without versioning -* Additive-only changes for existing API versions -* Deprecated fields are clearly marked and documented - ---- - -## Controller / Reconciler Review Checklist - -### Reconcile Logic - -Ensure the controller: - -* Is **idempotent** -* Can be safely re-run at any time -* Reconciles based on **current cluster state**, not assumptions -* Handles: - * NotFound errors correctly - * Partial failures gracefully - * Retries via requeue or error return, not loops - -### Error Handling - -* Errors are propagated correctly to trigger retries -* Transient vs permanent errors are distinguished where possible -* No silent failures -* Logging includes enough context (namespaced name, resource identifiers) - -### Controller Runtime Usage - -* Proper use of: - * `client.Client` - * `controllerutil.CreateOrUpdate` - * OwnerReferences -* Avoid direct API calls when controller-runtime helpers exist -* Watches are minimal and intentional -* Predicates are used to reduce unnecessary reconciliations - ---- - -## Status Management - -Reviewers should ensure: - -* Status updates are: - * Performed via `Status().Update()` or `Status().Patch()` - * Separated from spec mutations -* Status reflects **observed state**, not desired state -* Conditions are updated consistently and deterministically -* No hot loops caused by status-only changes triggering reconciliation - ---- - -## Go Style and Project Structure - -### Go Idioms - -* Code follows standard Go formatting and idioms -* Clear, explicit error handling -* Minimal use of global state -* Small, focused functions -* Interfaces are introduced only when justified - -### Project Layout - -* Standard Kubebuilder layout is preserved -* API types, controllers, and internal logic are clearly separated -* Helpers and utilities are reusable and well-scoped - ---- - -## Testing Expectations - -Reviewers should check for: - -* Unit tests for: - * Reconcile logic - * Pure functions -* Envtest-based tests for: - * Controller behavior - * API interactions -* Tests are deterministic and do not rely on timing assumptions -* Fake clients are used appropriately - ---- - -## Logging and Observability - -* Structured logging using controller-runtime logger -* No excessive log noise in hot paths -* Logs include relevant identifiers -* Events are emitted for meaningful user-facing state changes - ---- - -## What to Flag Explicitly - -Reviewers **should flag**: - -* Non-idempotent reconcile logic -* Spec mutations during reconciliation -* Custom patterns that duplicate standard Kubernetes behavior -* Hidden coupling between controllers -* Over-engineered abstractions -* Ignoring API conventions or Go idioms - ---- - -## Final Guideline - -When in doubt, prefer the approach that: - -* Matches upstream Kubernetes patterns -* Is easiest to reason about during failure scenarios -* Would be familiar to an experienced Kubernetes contributor - -Consistency with the Kubernetes ecosystem is more important than local preference. +```go +// +kubebuilder:object:root=true +// +kubebuilder:subresource:status +// +kubebuilder:resource:scope=Namespaced +// +kubebuilder:printcolumn:name="Status",type=string,JSONPath=".status.conditions[?(@.type=='Ready')].status" + +// On fields: +// +kubebuilder:validation:Required +// +kubebuilder:validation:Minimum=1 +// +kubebuilder:validation:MaxLength=100 +// +kubebuilder:validation:Pattern="^[a-z]+$" +// +kubebuilder:default="value" +``` + +- **Use** `metav1.Condition` for status (not custom string fields) +- **Use predefined types**: `metav1.Time` instead of `string` for dates +- **Follow K8s API conventions**: Standard field names (`spec`, `status`, `metadata`) + +### Controller Design + +**RBAC markers in** `internal/controller/*_controller.go`: + +```go +// +kubebuilder:rbac:groups=mygroup.example.com,resources=mykinds,verbs=get;list;watch;create;update;patch;delete +// +kubebuilder:rbac:groups=mygroup.example.com,resources=mykinds/status,verbs=get;update;patch +// +kubebuilder:rbac:groups=mygroup.example.com,resources=mykinds/finalizers,verbs=update +// +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch +// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete +``` + +**Implementation rules:** +- **Idempotent reconciliation**: Safe to run multiple times +- **Re-fetch before updates**: `r.Get(ctx, req.NamespacedName, obj)` before `r.Update` to avoid conflicts +- **Structured logging**: `log := log.FromContext(ctx); log.Info("msg", "key", val)` +- **Owner references**: Enable automatic garbage collection (`SetControllerReference`) +- **Watch secondary resources**: Use `.Owns()` or `.Watches()`, not just `RequeueAfter` +- **Finalizers**: Clean up external resources (buckets, VMs, DNS entries) + +### Logging + +**Follow Kubernetes logging message style guidelines:** + +- Start from a capital letter +- Do not end the message with a period +- Active voice: subject present (`"Deployment could not create Pod"`) or omitted (`"Could not create Pod"`) +- Past tense: `"Could not delete Pod"` not `"Cannot delete Pod"` +- Specify object type: `"Deleted Pod"` not `"Deleted"` +- Balanced key-value pairs + +```go +log.Info("Starting reconciliation") +log.Info("Created Deployment", "name", deploy.Name) +log.Error(err, "Failed to create Pod", "name", name) +``` + +**Reference:** https://github.com/kubernetes/community/blob/master/contributors/devel/sig-instrumentation/logging.md#message-style-guidelines + +### Webhooks +- **Create all types together**: `--defaulting --programmatic-validation --conversion` +- **When`--force`is used**: Backup custom logic first, then restore after scaffolding +- **For multi-version APIs**: Use hub-and-spoke pattern (`--conversion --spoke v2`) + - Hub version: Usually oldest stable version (v1) + - Spoke versions: Newer versions that convert to/from hub (v2, v3) + - Example: `--group crew --version v1 --kind Captain --conversion --spoke v2` (v1 is hub, v2 is spoke) + +### Learning from Examples + +The **deploy-image plugin** scaffolds a complete controller following good practices. Use it as a reference implementation: + +```bash +kubebuilder create api --group example --version v1alpha1 --kind MyApp \ + --image= --plugins=deploy-image.go.kubebuilder.io/v1-alpha +``` + +Generated code includes: status conditions (`metav1.Condition`), finalizers, owner references, events, idempotent reconciliation. + +## Distribution Options + +### Option 1: YAML Bundle (Kustomize) + +```bash +# Generate dist/install.yaml from Kustomize manifests +make build-installer IMG=/:tag +``` + +**Key points:** +- The `dist/install.yaml` is generated from Kustomize manifests (CRDs, RBAC, Deployment) +- Commit this file to your repository for easy distribution +- Users only need `kubectl` to install (no additional tools required) + +**Example:** Users install with a single command: +```bash +kubectl apply -f https://raw.githubusercontent.com////dist/install.yaml +``` + +### Option 2: Helm Chart + +```bash +kubebuilder edit --plugins=helm/v2-alpha # Generates dist/chart/ (default) +kubebuilder edit --plugins=helm/v2-alpha --output-dir=charts # Generates charts/chart/ +``` + +**For development:** +```bash +make helm-deploy IMG=/: # Deploy manager via Helm +make helm-deploy IMG=$IMG HELM_EXTRA_ARGS="--set ..." # Deploy with custom values +make helm-status # Show release status +make helm-uninstall # Remove release +make helm-history # View release history +make helm-rollback # Rollback to previous version +``` + +**For end users/production:** +```bash +helm install my-release .//chart/ --namespace --create-namespace +``` + +**Important:** If you add webhooks or modify manifests after initial chart generation: +1. Backup any customizations in `/chart/values.yaml` and `/chart/manager/manager.yaml` +2. Re-run: `kubebuilder edit --plugins=helm/v2-alpha --force` (use same `--output-dir` if customized) +3. Manually restore your custom values from the backup + +### Publish Container Image + +```bash +export IMG=/: +make docker-build docker-push IMG=$IMG +``` + +## References + +### Essential Reading +- **Kubebuilder Book**: https://book.kubebuilder.io (comprehensive guide) +- **controller-runtime FAQ**: https://github.com/kubernetes-sigs/controller-runtime/blob/main/FAQ.md (common patterns and questions) +- **Good Practices**: https://book.kubebuilder.io/reference/good-practices.html (why reconciliation is idempotent, status conditions, etc.) +- **Logging Conventions**: https://github.com/kubernetes/community/blob/master/contributors/devel/sig-instrumentation/logging.md#message-style-guidelines (message style, verbosity levels) + +### API Design & Implementation +- **API Conventions**: https://github.com/kubernetes/community/blob/master/contributors/devel/sig-architecture/api-conventions.md +- **Operator Pattern**: https://kubernetes.io/docs/concepts/extend-kubernetes/operator/ +- **Markers Reference**: https://book.kubebuilder.io/reference/markers.html + +### Tools & Libraries +- **controller-runtime**: https://github.com/kubernetes-sigs/controller-runtime +- **controller-tools**: https://github.com/kubernetes-sigs/controller-tools +- **Kubebuilder Repo**: https://github.com/kubernetes-sigs/kubebuilder diff --git a/Makefile b/Makefile index 4c663980..14e0b243 100644 --- a/Makefile +++ b/Makefile @@ -272,14 +272,14 @@ METALCTL ?= $(LOCALBIN)/metalctl GINKGO ?= $(LOCALBIN)/ginkgo ## Tool Versions -KUSTOMIZE_VERSION ?= v5.7.1 -CONTROLLER_TOOLS_VERSION ?= v0.20.0 +KUSTOMIZE_VERSION ?= v5.8.1 +CONTROLLER_TOOLS_VERSION ?= v0.20.1 #ENVTEST_VERSION is the version of controller-runtime release branch to fetch the envtest setup script (i.e. release-0.20) ENVTEST_VERSION ?= $(shell go list -m -f "{{ .Version }}" sigs.k8s.io/controller-runtime | awk -F'[v.]' '{printf "release-%d.%d", $$2, $$3}') #ENVTEST_K8S_VERSION is the version of Kubernetes to use for setting up ENVTEST binaries (i.e. 1.31) ENVTEST_K8S_VERSION ?= $(shell go list -m -f "{{ .Version }}" k8s.io/api | awk -F'[v.]' '{printf "1.%d.%d",$$3, $$2}') -GOLANGCI_LINT_VERSION ?= v2.8 +GOLANGCI_LINT_VERSION ?= v2.8.0 GOIMPORTS_VERSION ?= v0.38.0 CRD_REF_DOCS_VERSION ?= v0.2.0 KUBEBUILDER_VERSION ?= v4.11.1 @@ -308,7 +308,6 @@ $(KUBECTL): $(LOCALBIN) ln -sf "$(KUBECTL)" "$(KUBECTL_BIN)" chmod +x "$(KUBECTL_BIN)" "$(KUBECTL)" - .PHONY: controller-gen controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary. $(CONTROLLER_GEN): $(LOCALBIN) @@ -330,7 +329,12 @@ $(ENVTEST): $(LOCALBIN) .PHONY: golangci-lint golangci-lint: $(GOLANGCI_LINT) ## Download golangci-lint locally if necessary. $(GOLANGCI_LINT): $(LOCALBIN) - $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/v2/cmd/golangci-lint,${GOLANGCI_LINT_VERSION}) + $(call go-install-tool,$(GOLANGCI_LINT),github.com/golangci/golangci-lint/v2/cmd/golangci-lint,$(GOLANGCI_LINT_VERSION)) + @test -f .custom-gcl.yml && { \ + echo "Building custom golangci-lint with plugins..." && \ + $(GOLANGCI_LINT) custom --destination $(LOCALBIN) --name golangci-lint-custom && \ + mv -f $(LOCALBIN)/golangci-lint-custom $(GOLANGCI_LINT); \ + } || true .PHONY: goimports goimports: $(GOIMPORTS) ## Download goimports locally if necessary. diff --git a/PROJECT b/PROJECT index 2c67b04e..3ac489dd 100644 --- a/PROJECT +++ b/PROJECT @@ -2,7 +2,7 @@ # This file is used to track the info used to scaffold your project # and allow the plugins properly work. # More info: https://book.kubebuilder.io/reference/project-config.html -cliVersion: 4.11.1 +cliVersion: 4.12.0 domain: ironcore.dev layout: - go.kubebuilder.io/v4 diff --git a/REUSE.toml b/REUSE.toml index 8e78df05..c651f9ff 100644 --- a/REUSE.toml +++ b/REUSE.toml @@ -5,10 +5,12 @@ SPDX-PackageDownloadLocation = "https://github.com/ironcore-dev/metal-operator" [[annotations]] path = [ + ".devcontainer/**", ".github/**", ".gitignore", ".dockerignore", ".golangci.yml", + ".custom-gcl.yml", "CODEOWNERS", "Dockerfile", "Makefile", diff --git a/bmc/redfish.go b/bmc/redfish.go index 46a48687..5ff37c9c 100644 --- a/bmc/redfish.go +++ b/bmc/redfish.go @@ -943,8 +943,6 @@ func (r *RedfishBMC) UpgradeBiosVersion(ctx context.Context, manufacturer string taskMonitorURI, err := oemInterface.GetUpdateTaskMonitorURI(resp) if err != nil { - log.V(1).Error(err, - "failed to extract Task created for upgrade. However, upgrade might be running on server.") return "", true, fmt.Errorf("failed to read task monitor URI. %v", err) } @@ -1052,18 +1050,11 @@ func (r *RedfishBMC) UpgradeBMCVersion(ctx context.Context, manufacturer string, resp.StatusCode, ) } - return "", - true, - fmt.Errorf("failed to accept the upgrade request %v, statusCode %v", - string(bmcRawBody), - resp.StatusCode, - ) + return "", true, fmt.Errorf("failed to accept the upgrade request %v, statusCode %v", string(bmcRawBody), resp.StatusCode) } taskMonitorURI, err := oemInterface.GetUpdateTaskMonitorURI(resp) if err != nil { - log.V(1).Error(err, - "failed to extract Task created for upgrade. However, upgrade might be running on server.") return "", true, fmt.Errorf("failed to read task monitor URI. %v", err) } diff --git a/cmd/main.go b/cmd/main.go index f1b8e287..25c2ca81 100644 --- a/cmd/main.go +++ b/cmd/main.go @@ -14,7 +14,7 @@ import ( "github.com/ironcore-dev/controller-utils/conditionutils" "github.com/ironcore-dev/metal-operator/internal/cmd/dns" - webhookmetalv1alpha1 "github.com/ironcore-dev/metal-operator/internal/webhook/v1alpha1" + webhookv1alpha1 "github.com/ironcore-dev/metal-operator/internal/webhook/v1alpha1" "sigs.k8s.io/controller-runtime/pkg/manager" // Import all Kubernetes client auth plugins (e.g. Azure, GCP, OIDC, etc.) @@ -212,7 +212,7 @@ func main() { // nolint: gocyclo // - https://github.com/advisories/GHSA-qppj-fm5r-hxr3 // - https://github.com/advisories/GHSA-4374-p667-p6c8 disableHTTP2 := func(c *tls.Config) { - setupLog.Info("disabling http/2") + setupLog.Info("Disabling HTTP/2") c.NextProtos = []string{"http/1.1"} } @@ -317,7 +317,7 @@ func main() { // nolint: gocyclo // LeaderElectionReleaseOnCancel: true, }) if err != nil { - setupLog.Error(err, "unable to start manager") + setupLog.Error(err, "Failed to start manager") os.Exit(1) } @@ -327,23 +327,16 @@ func main() { // nolint: gocyclo MACPrefixes: macPRefixes, Insecure: insecure, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "Endpoints") + setupLog.Error(err, "Failed to create controller", "controller", "Endpoint") os.Exit(1) } if err = (&controller.BMCSecretReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BMCSecret") + setupLog.Error(err, "Failed to create controller", "controller", "BMCSecret") os.Exit(1) } - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupBMCSecretWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "BMCSecret") - os.Exit(1) - } - } if err = (&controller.BMCReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), @@ -358,7 +351,7 @@ func main() { // nolint: gocyclo BasicAuth: true, }, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BMC") + setupLog.Error(err, "Failed to create controller", "controller", "BMC") os.Exit(1) } if err = (&controller.ServerReconciler{ @@ -384,14 +377,14 @@ func main() { // nolint: gocyclo }, DiscoveryTimeout: discoveryTimeout, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "Server") + setupLog.Error(err, "Failed to create controller", "controller", "Server") os.Exit(1) } if err = (&controller.ServerBootConfigurationReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "ServerBootConfiguration") + setupLog.Error(err, "Failed to create controller", "controller", "ServerBootConfiguration") os.Exit(1) } if err = (&controller.ServerClaimReconciler{ @@ -400,24 +393,16 @@ func main() { // nolint: gocyclo Scheme: mgr.GetScheme(), MaxConcurrentReconciles: serverClaimMaxConcurrentReconciles, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "ServerClaim") + setupLog.Error(err, "Failed to create controller", "controller", "ServerClaim") os.Exit(1) } if err = (&controller.ServerMaintenanceReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "ServerMaintenance") + setupLog.Error(err, "Failed to create controller", "controller", "ServerMaintenance") os.Exit(1) } - - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupEndpointWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "Endpoint") - os.Exit(1) - } - } if err = (&controller.BIOSSettingsReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), @@ -434,16 +419,9 @@ func main() { // nolint: gocyclo }, TimeoutExpiry: biosSettingsApplyTimeout, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BIOSSettings") + setupLog.Error(err, "Failed to create controller", "controller", "BIOSSettings") os.Exit(1) } - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupBIOSSettingsWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "BIOSSettings") - os.Exit(1) - } - } if err = (&controller.BIOSVersionReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), @@ -459,16 +437,9 @@ func main() { // nolint: gocyclo ResourcePollingTimeout: resourcePollingTimeout, }, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BIOSVersion") + setupLog.Error(err, "Failed to create controller", "controller", "BIOSVersion") os.Exit(1) } - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupBIOSVersionWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "BIOSVersion") - os.Exit(1) - } - } if err = (&controller.BMCSettingsReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), @@ -484,16 +455,9 @@ func main() { // nolint: gocyclo ResourcePollingTimeout: resourcePollingTimeout, }, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BMCSettings") + setupLog.Error(err, "Failed to create controller", "controller", "BMCSettings") os.Exit(1) } - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupBMCSettingsWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "BMCSettings") - os.Exit(1) - } - } if err = (&controller.BMCVersionReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), @@ -509,49 +473,35 @@ func main() { // nolint: gocyclo ResourcePollingTimeout: resourcePollingTimeout, }, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BMCVersion") + setupLog.Error(err, "Failed to create controller", "controller", "BMCVersion") os.Exit(1) } - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupBMCVersionWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "BMCVersion") - os.Exit(1) - } - } if err = (&controller.BIOSVersionSetReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BIOSVersionSet") + setupLog.Error(err, "Failed to create controller", "controller", "BIOSVersionSet") os.Exit(1) } - // nolint:goconst - if os.Getenv("ENABLE_WEBHOOKS") != "false" { - if err = webhookmetalv1alpha1.SetupServerWebhookWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create webhook", "webhook", "Server") - os.Exit(1) - } - } - if err = (&controller.BMCVersionSetReconciler{ + if err = (&controller.BIOSSettingsSetReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BMCVersionSet") + setupLog.Error(err, "Failed to create controller", "controller", "BIOSSettingsSet") os.Exit(1) } - if err = (&controller.BIOSSettingsSetReconciler{ + if err = (&controller.BMCVersionSetReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BIOSSettingsSet") + setupLog.Error(err, "Failed to create controller", "controller", "BMCVersionSet") os.Exit(1) } if err := (&controller.BMCSettingsSetReconciler{ Client: mgr.GetClient(), Scheme: mgr.GetScheme(), }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "BMCSettingsSet") + setupLog.Error(err, "Failed to create controller", "controller", "BMCSettingsSet") os.Exit(1) } if err = (&controller.BMCUserReconciler{ @@ -566,17 +516,67 @@ func main() { // nolint: gocyclo ResourcePollingTimeout: resourcePollingTimeout, }, }).SetupWithManager(mgr); err != nil { - setupLog.Error(err, "unable to create controller", "controller", "User") + setupLog.Error(err, "Failed to create controller", "controller", "BMCUser") os.Exit(1) } + + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupEndpointWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "Endpoint") + os.Exit(1) + } + } + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupBMCSecretWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "BMCSecret") + os.Exit(1) + } + } + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupServerWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "Server") + os.Exit(1) + } + } + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupBIOSSettingsWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "BIOSSettings") + os.Exit(1) + } + } + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupBIOSVersionWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "BIOSVersion") + os.Exit(1) + } + } + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupBMCSettingsWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "BMCSettings") + os.Exit(1) + } + } + // nolint:goconst + if os.Getenv("ENABLE_WEBHOOKS") != "false" { + if err := webhookv1alpha1.SetupBMCVersionWebhookWithManager(mgr); err != nil { + setupLog.Error(err, "Failed to create webhook", "webhook", "BMCVersion") + os.Exit(1) + } + } // +kubebuilder:scaffold:builder if err := mgr.AddHealthzCheck("healthz", healthz.Ping); err != nil { - setupLog.Error(err, "unable to set up health check") + setupLog.Error(err, "Failed 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") + setupLog.Error(err, "Failed to set up ready check") os.Exit(1) } @@ -600,9 +600,9 @@ func main() { // nolint: gocyclo os.Exit(1) } - setupLog.Info("starting manager") + setupLog.Info("Starting manager") if err := mgr.Start(ctx); err != nil { - setupLog.Error(err, "problem running manager") + setupLog.Error(err, "Failed to run manager") os.Exit(1) } } diff --git a/config/crd/bases/metal.ironcore.dev_biossettings.yaml b/config/crd/bases/metal.ironcore.dev_biossettings.yaml index 2a8caf4d..921c60aa 100644 --- a/config/crd/bases/metal.ironcore.dev_biossettings.yaml +++ b/config/crd/bases/metal.ironcore.dev_biossettings.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biossettings.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_biossettingssets.yaml b/config/crd/bases/metal.ironcore.dev_biossettingssets.yaml index a96259d3..c5d51900 100644 --- a/config/crd/bases/metal.ironcore.dev_biossettingssets.yaml +++ b/config/crd/bases/metal.ironcore.dev_biossettingssets.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biossettingssets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_biosversions.yaml b/config/crd/bases/metal.ironcore.dev_biosversions.yaml index fc933b80..3bf21a9e 100644 --- a/config/crd/bases/metal.ironcore.dev_biosversions.yaml +++ b/config/crd/bases/metal.ironcore.dev_biosversions.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biosversions.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_biosversionsets.yaml b/config/crd/bases/metal.ironcore.dev_biosversionsets.yaml index a7621703..6093758a 100644 --- a/config/crd/bases/metal.ironcore.dev_biosversionsets.yaml +++ b/config/crd/bases/metal.ironcore.dev_biosversionsets.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biosversionsets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcs.yaml b/config/crd/bases/metal.ironcore.dev_bmcs.yaml index eadd521a..06bc378f 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcs.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcs.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcs.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcsecrets.yaml b/config/crd/bases/metal.ironcore.dev_bmcsecrets.yaml index 5f4bbc63..e853cc8d 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcsecrets.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcsecrets.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcsecrets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcsettings.yaml b/config/crd/bases/metal.ironcore.dev_bmcsettings.yaml index d4e0a1a3..13d2c712 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcsettings.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcsettings.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcsettings.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcsettingssets.yaml b/config/crd/bases/metal.ironcore.dev_bmcsettingssets.yaml index e49c5786..32e3eabf 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcsettingssets.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcsettingssets.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcsettingssets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcusers.yaml b/config/crd/bases/metal.ironcore.dev_bmcusers.yaml index aeb2aedd..648e9918 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcusers.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcusers.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcusers.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcversions.yaml b/config/crd/bases/metal.ironcore.dev_bmcversions.yaml index 20c5301d..8f68ab2c 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcversions.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcversions.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcversions.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_bmcversionsets.yaml b/config/crd/bases/metal.ironcore.dev_bmcversionsets.yaml index 28702ccf..a8c387a8 100644 --- a/config/crd/bases/metal.ironcore.dev_bmcversionsets.yaml +++ b/config/crd/bases/metal.ironcore.dev_bmcversionsets.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcversionsets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_endpoints.yaml b/config/crd/bases/metal.ironcore.dev_endpoints.yaml index b1589a61..3989effd 100644 --- a/config/crd/bases/metal.ironcore.dev_endpoints.yaml +++ b/config/crd/bases/metal.ironcore.dev_endpoints.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: endpoints.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_serverbootconfigurations.yaml b/config/crd/bases/metal.ironcore.dev_serverbootconfigurations.yaml index 192d9655..ed475059 100644 --- a/config/crd/bases/metal.ironcore.dev_serverbootconfigurations.yaml +++ b/config/crd/bases/metal.ironcore.dev_serverbootconfigurations.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: serverbootconfigurations.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_serverclaims.yaml b/config/crd/bases/metal.ironcore.dev_serverclaims.yaml index da3ed319..8466defa 100644 --- a/config/crd/bases/metal.ironcore.dev_serverclaims.yaml +++ b/config/crd/bases/metal.ironcore.dev_serverclaims.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: serverclaims.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_servermaintenances.yaml b/config/crd/bases/metal.ironcore.dev_servermaintenances.yaml index 006e0ca5..025beceb 100644 --- a/config/crd/bases/metal.ironcore.dev_servermaintenances.yaml +++ b/config/crd/bases/metal.ironcore.dev_servermaintenances.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: servermaintenances.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/config/crd/bases/metal.ironcore.dev_servers.yaml b/config/crd/bases/metal.ironcore.dev_servers.yaml index 5ff51980..40eb8d2d 100644 --- a/config/crd/bases/metal.ironcore.dev_servers.yaml +++ b/config/crd/bases/metal.ironcore.dev_servers.yaml @@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1 kind: CustomResourceDefinition metadata: annotations: - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: servers.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_biossettings.yaml b/dist/chart/templates/crd/metal.ironcore.dev_biossettings.yaml index 635e73ae..e88bbc5f 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_biossettings.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_biossettings.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biossettings.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_biossettingssets.yaml b/dist/chart/templates/crd/metal.ironcore.dev_biossettingssets.yaml index 5cae142c..fca16362 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_biossettingssets.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_biossettingssets.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biossettingssets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_biosversions.yaml b/dist/chart/templates/crd/metal.ironcore.dev_biosversions.yaml index 776536cc..b6b47f32 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_biosversions.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_biosversions.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biosversions.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_biosversionsets.yaml b/dist/chart/templates/crd/metal.ironcore.dev_biosversionsets.yaml index 57ec6e3b..10cadb67 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_biosversionsets.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_biosversionsets.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: biosversionsets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcs.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcs.yaml index e5864922..889848b9 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcs.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcs.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcs.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcsecrets.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcsecrets.yaml index c5454616..a814c3f2 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcsecrets.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcsecrets.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcsecrets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcsettings.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcsettings.yaml index 6467f1ce..4a430ff0 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcsettings.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcsettings.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcsettings.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcsettingssets.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcsettingssets.yaml index f4e05cad..0400d77f 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcsettingssets.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcsettingssets.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcsettingssets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcusers.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcusers.yaml index 4aa07591..f5866798 100644 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcusers.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcusers.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcusers.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcversions.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcversions.yaml index 2601275a..1983ee66 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcversions.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcversions.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcversions.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_bmcversionsets.yaml b/dist/chart/templates/crd/metal.ironcore.dev_bmcversionsets.yaml index c84dd39c..c306d037 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_bmcversionsets.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_bmcversionsets.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: bmcversionsets.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_endpoints.yaml b/dist/chart/templates/crd/metal.ironcore.dev_endpoints.yaml index a11b447e..6221f86f 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_endpoints.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_endpoints.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: endpoints.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_serverbootconfigurations.yaml b/dist/chart/templates/crd/metal.ironcore.dev_serverbootconfigurations.yaml index 2b07a05e..0d08670d 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_serverbootconfigurations.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_serverbootconfigurations.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: serverbootconfigurations.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_serverclaims.yaml b/dist/chart/templates/crd/metal.ironcore.dev_serverclaims.yaml index 770adbae..fb238e27 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_serverclaims.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_serverclaims.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: serverclaims.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_servermaintenances.yaml b/dist/chart/templates/crd/metal.ironcore.dev_servermaintenances.yaml index 9dd970bc..ea3874e2 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_servermaintenances.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_servermaintenances.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: servermaintenances.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/dist/chart/templates/crd/metal.ironcore.dev_servers.yaml b/dist/chart/templates/crd/metal.ironcore.dev_servers.yaml index d14b1c50..33399845 100755 --- a/dist/chart/templates/crd/metal.ironcore.dev_servers.yaml +++ b/dist/chart/templates/crd/metal.ironcore.dev_servers.yaml @@ -9,7 +9,7 @@ metadata: {{- if .Values.crd.keep }} "helm.sh/resource-policy": keep {{- end }} - controller-gen.kubebuilder.io/version: v0.20.0 + controller-gen.kubebuilder.io/version: v0.20.1 name: servers.metal.ironcore.dev spec: group: metal.ironcore.dev diff --git a/internal/controller/biossettings_controller.go b/internal/controller/biossettings_controller.go index cb0f9fe3..55e83f41 100644 --- a/internal/controller/biossettings_controller.go +++ b/internal/controller/biossettings_controller.go @@ -25,7 +25,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/handler" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/conditionutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" @@ -95,22 +94,22 @@ type BIOSSettingsReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *BIOSSettingsReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) biosSettings := &metalv1alpha1.BIOSSettings{} if err := r.Get(ctx, req.NamespacedName, biosSettings); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, biosSettings) + return r.reconcileExists(ctx, biosSettings) } -func (r *BIOSSettingsReconciler) reconcileExists(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings) (ctrl.Result, error) { - if r.shouldDelete(log, settings) { - return r.delete(ctx, log, settings) +func (r *BIOSSettingsReconciler) reconcileExists(ctx context.Context, settings *metalv1alpha1.BIOSSettings) (ctrl.Result, error) { + if r.shouldDelete(ctx, settings) { + return r.delete(ctx, settings) } - return r.reconcile(ctx, log, settings) + return r.reconcile(ctx, settings) } -func (r *BIOSSettingsReconciler) shouldDelete(log logr.Logger, settings *metalv1alpha1.BIOSSettings) bool { +func (r *BIOSSettingsReconciler) shouldDelete(ctx context.Context, settings *metalv1alpha1.BIOSSettings) bool { + log := ctrl.LoggerFrom(ctx) if settings.DeletionTimestamp.IsZero() { return false } @@ -123,9 +122,10 @@ func (r *BIOSSettingsReconciler) shouldDelete(log logr.Logger, settings *metalv1 return true } -func (r *BIOSSettingsReconciler) delete(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings) (ctrl.Result, error) { +func (r *BIOSSettingsReconciler) delete(ctx context.Context, settings *metalv1alpha1.BIOSSettings) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting BIOSSettings") - if err := r.cleanupReferences(ctx, log, settings); err != nil { + if err := r.cleanupReferences(ctx, settings); err != nil { return ctrl.Result{}, fmt.Errorf("failed to cleanup references: %w", err) } log.V(1).Info("Ensured references were removed") @@ -140,7 +140,8 @@ func (r *BIOSSettingsReconciler) delete(ctx context.Context, log logr.Logger, se return ctrl.Result{}, nil } -func (r *BIOSSettingsReconciler) removeServerMaintenance(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings) error { +func (r *BIOSSettingsReconciler) removeServerMaintenance(ctx context.Context, settings *metalv1alpha1.BIOSSettings) error { + log := ctrl.LoggerFrom(ctx) if settings.Spec.ServerMaintenanceRef == nil { return nil } @@ -181,7 +182,8 @@ func (r *BIOSSettingsReconciler) removeServerMaintenance(ctx context.Context, lo return nil } -func (r *BIOSSettingsReconciler) cleanupReferences(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings) (err error) { +func (r *BIOSSettingsReconciler) cleanupReferences(ctx context.Context, settings *metalv1alpha1.BIOSSettings) (err error) { + log := ctrl.LoggerFrom(ctx) if settings.Spec.ServerRef == nil { log.V(1).Info("BIOSSettings does not have a ServerRef") return nil @@ -208,7 +210,8 @@ func (r *BIOSSettingsReconciler) cleanupReferences(ctx context.Context, log logr return r.patchBIOSSettingsRefForServer(ctx, server, nil) } -func (r *BIOSSettingsReconciler) reconcile(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings) (ctrl.Result, error) { +func (r *BIOSSettingsReconciler) reconcile(ctx context.Context, settings *metalv1alpha1.BIOSSettings) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if shouldIgnoreReconciliation(settings) { log.V(1).Info("Skipping BIOSSettings reconciliation") return ctrl.Result{}, nil @@ -265,25 +268,26 @@ func (r *BIOSSettingsReconciler) reconcile(ctx context.Context, log logr.Logger, } defer bmcClient.Logout() - return r.ensureBIOSSettingsStateTransition(ctx, log, bmcClient, settings, server) + return r.ensureBIOSSettingsStateTransition(ctx, bmcClient, settings, server) } -func (r *BIOSSettingsReconciler) ensureBIOSSettingsStateTransition(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { +func (r *BIOSSettingsReconciler) ensureBIOSSettingsStateTransition(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { switch settings.Status.State { case "", metalv1alpha1.BIOSSettingsStatePending: - return r.handleSettingPendingState(ctx, log, bmcClient, settings, server) + return r.handleSettingPendingState(ctx, bmcClient, settings, server) case metalv1alpha1.BIOSSettingsStateInProgress: - return r.handleSettingInProgressState(ctx, log, bmcClient, settings, server) + return r.handleSettingInProgressState(ctx, bmcClient, settings, server) case metalv1alpha1.BIOSSettingsStateApplied: - return r.handleAppliedState(ctx, log, bmcClient, settings, server) + return r.handleAppliedState(ctx, bmcClient, settings, server) case metalv1alpha1.BIOSSettingsStateFailed: - return r.handleFailedState(ctx, log, settings, server) + return r.handleFailedState(ctx, settings, server) default: return ctrl.Result{}, fmt.Errorf("invalid BIOSSettings state: %s", settings.Status.State) } } -func (r *BIOSSettingsReconciler) handleSettingPendingState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { +func (r *BIOSSettingsReconciler) handleSettingPendingState(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if len(settings.Spec.SettingsFlow) == 0 { log.V(1).Info("Skipping BIOSSettings because no settings flow found") return ctrl.Result{}, r.updateStatus(ctx, settings, metalv1alpha1.BIOSSettingsStateApplied, nil) @@ -350,7 +354,7 @@ func (r *BIOSSettingsReconciler) handleSettingPendingState(ctx context.Context, } // Check if all settings have been applied - biosVersion, settingsDiff, err := r.getBIOSVersionAndSettingsDiff(ctx, log, bmcClient, settings, server) + biosVersion, settingsDiff, err := r.getBIOSVersionAndSettingsDiff(ctx, bmcClient, settings, server) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to get BIOSSettings: %w", err) } @@ -399,17 +403,18 @@ func (r *BIOSSettingsReconciler) handleSettingPendingState(ctx context.Context, return ctrl.Result{}, r.updateStatus(ctx, settings, state, condition) } -func (r *BIOSSettingsReconciler) handleSettingInProgressState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { - if req, err := r.requestMaintenanceForServer(ctx, log, settings, server); err != nil || req { +func (r *BIOSSettingsReconciler) handleSettingInProgressState(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) + if req, err := r.requestMaintenanceForServer(ctx, settings, server); err != nil || req { return ctrl.Result{}, err } - if ok := r.isServerInMaintenance(log, settings, server); !ok { + if ok := r.isServerInMaintenance(ctx, settings, server); !ok { log.V(1).Info("Server is not yet in Maintenance status, skipping") return ctrl.Result{}, nil } - if ok, err := r.handleBMCReset(ctx, log, bmcClient, settings, server); !ok || err != nil { + if ok, err := r.handleBMCReset(ctx, bmcClient, settings, server); !ok || err != nil { return ctrl.Result{}, err } @@ -476,8 +481,8 @@ func (r *BIOSSettingsReconciler) handleSettingInProgressState(ctx context.Contex } } - if ok, err := r.applySettingUpdate(ctx, log, bmcClient, settings, &settingsFlowItem, currentSettingsFlowStatus, server); ok && err == nil { - if requeue, err := r.verifySettingsUpdateComplete(ctx, log, bmcClient, settings, &settingsFlowItem, currentSettingsFlowStatus, server); requeue && err == nil { + if ok, err := r.applySettingUpdate(ctx, bmcClient, settings, &settingsFlowItem, currentSettingsFlowStatus, server); ok && err == nil { + if requeue, err := r.verifySettingsUpdateComplete(ctx, bmcClient, settings, &settingsFlowItem, currentSettingsFlowStatus, server); requeue && err == nil { return ctrl.Result{RequeueAfter: r.ResyncInterval}, err } return ctrl.Result{}, err @@ -489,7 +494,8 @@ func (r *BIOSSettingsReconciler) handleSettingInProgressState(ctx context.Contex return ctrl.Result{}, r.updateStatus(ctx, settings, metalv1alpha1.BIOSSettingsStateApplied, nil) } -func (r *BIOSSettingsReconciler) handleBMCReset(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (bool, error) { +func (r *BIOSSettingsReconciler) handleBMCReset(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) resetBMC, err := GetCondition(r.Conditions, settings.Status.Conditions, BMCConditionReset) if err != nil { return false, fmt.Errorf("failed to get condition for reset of BMC of server %v", err) @@ -499,7 +505,7 @@ func (r *BIOSSettingsReconciler) handleBMCReset(ctx context.Context, log logr.Lo // once the server is powered on, reset the BMC to make sure its in stable state // this avoids problems with some BMCs that hang up in subsequent operations if resetBMC.Reason != BMCReasonReset { - if err := resetBMCOfServer(ctx, log, r.Client, server, bmcClient); err == nil { + if err := resetBMCOfServer(ctx, r.Client, server, bmcClient); err == nil { // mark reset to be issued, wait for next reconcile if err := r.Conditions.Update( resetBMC, @@ -540,8 +546,9 @@ func (r *BIOSSettingsReconciler) handleBMCReset(ctx context.Context, log logr.Lo return true, nil } -func (r *BIOSSettingsReconciler) applySettingUpdate(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, flowItem *metalv1alpha1.SettingsFlowItem, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server) (bool, error) { - if modified, err := r.setTimeoutForAppliedSettings(ctx, log, settings, flowStatus); modified || err != nil { +func (r *BIOSSettingsReconciler) applySettingUpdate(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, flowItem *metalv1alpha1.SettingsFlowItem, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) + if modified, err := r.setTimeoutForAppliedSettings(ctx, settings, flowStatus); modified || err != nil { return false, err } turnOnServer, err := GetCondition(r.Conditions, flowStatus.Conditions, BIOSSettingsConditionServerPowerOn) @@ -564,12 +571,12 @@ func (r *BIOSSettingsReconciler) applySettingUpdate(ctx context.Context, log log // we need to request maintenance to get the server to power-On to apply the BIOS settings if settings.Spec.ServerMaintenanceRef == nil { log.V(1).Info("Server powered off, request maintenance to turn the server On") - if requeue, err := r.requestMaintenanceForServer(ctx, log, settings, server); err != nil || requeue { + if requeue, err := r.requestMaintenanceForServer(ctx, settings, server); err != nil || requeue { return false, err } } - if err := r.patchPowerState(ctx, log, settings, metalv1alpha1.PowerOn); err != nil { + if err := r.patchPowerState(ctx, settings, metalv1alpha1.PowerOn); err != nil { return false, fmt.Errorf("failed to power on Server %w", err) } log.V(1).Info("Reconciled BIOSSettings at TurnOnServer Condition") @@ -595,7 +602,7 @@ func (r *BIOSSettingsReconciler) applySettingUpdate(ctx context.Context, log log resetReq, err := bmcClient.CheckBiosAttributes(settingsDiff) if err != nil { - log.V(1).Error(err, "could not validate settings and determine if reboot needed") + log.Error(err, "could not validate settings and determine if reboot needed") var invalidSettingsErr *bmc.InvalidBIOSSettingsError if errors.As(err, &invalidSettingsErr) { inValidSettings, errCond := GetCondition(r.Conditions, flowStatus.Conditions, BIOSSettingsConditionWrongSettings) @@ -653,7 +660,7 @@ func (r *BIOSSettingsReconciler) applySettingUpdate(ctx context.Context, log log } if issueBiosUpdate.Status != metav1.ConditionTrue { - return false, r.applyBIOSSettings(ctx, log, bmcClient, settings, flowItem, flowStatus, server, issueBiosUpdate) + return false, r.applyBIOSSettings(ctx, bmcClient, settings, flowItem, flowStatus, server, issueBiosUpdate) } skipReboot, err := GetCondition(r.Conditions, flowStatus.Conditions, BIOSSettingsConditionRebootPostUpdate) @@ -668,13 +675,14 @@ func (r *BIOSSettingsReconciler) applySettingUpdate(ctx context.Context, log log } // reboot is not yet completed if rebootPowerOnCondition.Status != metav1.ConditionTrue { - return false, r.rebootServer(ctx, log, settings, flowStatus, server) + return false, r.rebootServer(ctx, settings, flowStatus, server) } } return true, nil } -func (r *BIOSSettingsReconciler) setTimeoutForAppliedSettings(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus) (bool, error) { +func (r *BIOSSettingsReconciler) setTimeoutForAppliedSettings(ctx context.Context, settings *metalv1alpha1.BIOSSettings, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus) (bool, error) { + log := ctrl.LoggerFrom(ctx) timeoutCheck, err := GetCondition(r.Conditions, flowStatus.Conditions, BIOSSettingConditionUpdateStartTime) if err != nil { return false, fmt.Errorf("failed to get condition for TimeOut during setting update %v", err) @@ -712,7 +720,8 @@ func (r *BIOSSettingsReconciler) setTimeoutForAppliedSettings(ctx context.Contex return false, nil } -func (r *BIOSSettingsReconciler) verifySettingsUpdateComplete(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, biosSettings *metalv1alpha1.BIOSSettings, flowItem *metalv1alpha1.SettingsFlowItem, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server) (bool, error) { +func (r *BIOSSettingsReconciler) verifySettingsUpdateComplete(ctx context.Context, bmcClient bmc.BMC, biosSettings *metalv1alpha1.BIOSSettings, flowItem *metalv1alpha1.SettingsFlowItem, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) verifySettingUpdate, err := GetCondition(r.Conditions, flowStatus.Conditions, BIOSSettingsConditionVerifySettings) if err != nil { return false, fmt.Errorf("failed to get Condition for Verification condition %w", err) @@ -747,7 +756,8 @@ func (r *BIOSSettingsReconciler) verifySettingsUpdateComplete(ctx context.Contex return false, nil } -func (r *BIOSSettingsReconciler) rebootServer(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server) error { +func (r *BIOSSettingsReconciler) rebootServer(ctx context.Context, settings *metalv1alpha1.BIOSSettings, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) rebootPowerOffCondition, err := GetCondition(r.Conditions, flowStatus.Conditions, BIOSSettingsConditionRebootPowerOff) if err != nil { return fmt.Errorf("failed to get PowerOff condition: %w", err) @@ -756,7 +766,7 @@ func (r *BIOSSettingsReconciler) rebootServer(ctx context.Context, log logr.Logg if rebootPowerOffCondition.Status != metav1.ConditionTrue { // expected state it to be off and initial state is to be on. if r.isServerInPowerState(server, metalv1alpha1.ServerOnPowerState) { - if err := r.patchPowerState(ctx, log, settings, metalv1alpha1.PowerOff); err != nil { + if err := r.patchPowerState(ctx, settings, metalv1alpha1.PowerOff); err != nil { return fmt.Errorf("failed to reboot %w", err) } } @@ -783,7 +793,7 @@ func (r *BIOSSettingsReconciler) rebootServer(ctx context.Context, log logr.Logg if rebootPowerOnCondition.Status != metav1.ConditionTrue { // expected power state it to be on and initial state is to be off. if r.isServerInPowerState(server, metalv1alpha1.ServerOffPowerState) { - if err := r.patchPowerState(ctx, log, settings, metalv1alpha1.PowerOn); err != nil { + if err := r.patchPowerState(ctx, settings, metalv1alpha1.PowerOn); err != nil { return fmt.Errorf("failed to reboot server: %w", err) } } @@ -805,7 +815,8 @@ func (r *BIOSSettingsReconciler) rebootServer(ctx context.Context, log logr.Logg return nil } -func (r *BIOSSettingsReconciler) applyBIOSSettings(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, flowItem *metalv1alpha1.SettingsFlowItem, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server, issueBiosUpdate *metav1.Condition) error { +func (r *BIOSSettingsReconciler) applyBIOSSettings(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, flowItem *metalv1alpha1.SettingsFlowItem, flowStatus *metalv1alpha1.BIOSSettingsFlowStatus, server *metalv1alpha1.Server, issueBiosUpdate *metav1.Condition) error { + log := ctrl.LoggerFrom(ctx) settingsDiff, err := r.getSettingsDiff(ctx, bmcClient, flowItem.Settings, server) if err != nil { return fmt.Errorf("failed to get BIOS settings difference: %w", err) @@ -926,8 +937,9 @@ func (r *BIOSSettingsReconciler) ensureNoStrandedStatus(ctx context.Context, set return false, nil } -func (r *BIOSSettingsReconciler) handleAppliedState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { - if err := r.removeServerMaintenance(ctx, log, settings); err != nil { +func (r *BIOSSettingsReconciler) handleAppliedState(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) + if err := r.removeServerMaintenance(ctx, settings); err != nil { return ctrl.Result{}, err } @@ -935,7 +947,7 @@ func (r *BIOSSettingsReconciler) handleAppliedState(ctx context.Context, log log return ctrl.Result{}, err } - _, settingsDiff, err := r.getBIOSVersionAndSettingsDiff(ctx, log, bmcClient, settings, server) + _, settingsDiff, err := r.getBIOSVersionAndSettingsDiff(ctx, bmcClient, settings, server) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to get BIOS version and settings diff: %w", err) } @@ -948,7 +960,8 @@ func (r *BIOSSettingsReconciler) handleAppliedState(ctx context.Context, log log return ctrl.Result{}, nil } -func (r *BIOSSettingsReconciler) handleFailedState(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { +func (r *BIOSSettingsReconciler) handleFailedState(ctx context.Context, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if shouldRetryReconciliation(settings) { log.V(1).Info("Retrying reconciliation") biosSettingsBase := settings.DeepCopy() @@ -972,7 +985,7 @@ func (r *BIOSSettingsReconciler) handleFailedState(ctx context.Context, log logr // Check if the failure is due to pending settings for _, condition := range settings.Status.Conditions { if condition.Type == BIOSPendingSettingConditionCheck && condition.Status == metav1.ConditionTrue { - if _, err := r.requestMaintenanceForServer(ctx, log, settings, server); err != nil { + if _, err := r.requestMaintenanceForServer(ctx, settings, server); err != nil { return ctrl.Result{}, err } break @@ -1036,7 +1049,8 @@ func (r *BIOSSettingsReconciler) getSettingsDiff(ctx context.Context, bmcClient return diff, errors.Join(errs...) } -func (r *BIOSSettingsReconciler) getBIOSVersionAndSettingsDiff(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (string, redfish.SettingsAttributes, error) { +func (r *BIOSSettingsReconciler) getBIOSVersionAndSettingsDiff(ctx context.Context, bmcClient bmc.BMC, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (string, redfish.SettingsAttributes, error) { + log := ctrl.LoggerFrom(ctx) completeSettings := make(map[string]string) for _, flowItem := range settings.Spec.SettingsFlow { maps.Copy(completeSettings, flowItem.Settings) @@ -1062,7 +1076,8 @@ func (r *BIOSSettingsReconciler) isServerInPowerState(server *metalv1alpha1.Serv return server.Status.PowerState == state } -func (r *BIOSSettingsReconciler) isServerInMaintenance(log logr.Logger, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) bool { +func (r *BIOSSettingsReconciler) isServerInMaintenance(ctx context.Context, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) bool { + log := ctrl.LoggerFrom(ctx) if settings.Spec.ServerMaintenanceRef == nil { return false } @@ -1080,7 +1095,8 @@ func (r *BIOSSettingsReconciler) isServerInMaintenance(log logr.Logger, settings return true } -func (r *BIOSSettingsReconciler) requestMaintenanceForServer(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (bool, error) { +func (r *BIOSSettingsReconciler) requestMaintenanceForServer(ctx context.Context, settings *metalv1alpha1.BIOSSettings, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if settings.Spec.ServerMaintenanceRef != nil { return false, nil } @@ -1191,7 +1207,8 @@ func (r *BIOSSettingsReconciler) patchMaintenanceRef(ctx context.Context, settin return nil } -func (r *BIOSSettingsReconciler) patchPowerState(ctx context.Context, log logr.Logger, settings *metalv1alpha1.BIOSSettings, powerState metalv1alpha1.Power) error { +func (r *BIOSSettingsReconciler) patchPowerState(ctx context.Context, settings *metalv1alpha1.BIOSSettings, powerState metalv1alpha1.Power) error { + log := ctrl.LoggerFrom(ctx) if settings == nil { return fmt.Errorf("BIOSSettings is nil") } diff --git a/internal/controller/biossettingsset_controller.go b/internal/controller/biossettingsset_controller.go index 40d66937..10724455 100644 --- a/internal/controller/biossettingsset_controller.go +++ b/internal/controller/biossettingsset_controller.go @@ -20,7 +20,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/predicate" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" ) @@ -40,22 +39,22 @@ type BIOSSettingsSetReconciler struct { // +kubebuilder:rbac:groups=metal.ironcore.dev,resources=servers,verbs=get;list;watch func (r *BIOSSettingsSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) biosSettingsSet := &metalv1alpha1.BIOSSettingsSet{} if err := r.Get(ctx, req.NamespacedName, biosSettingsSet); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, biosSettingsSet) + return r.reconcileExists(ctx, biosSettingsSet) } -func (r *BIOSSettingsSetReconciler) reconcileExists(ctx context.Context, log logr.Logger, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { +func (r *BIOSSettingsSetReconciler) reconcileExists(ctx context.Context, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { if !set.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, set) + return r.delete(ctx, set) } - return r.reconcile(ctx, log, set) + return r.reconcile(ctx, set) } -func (r *BIOSSettingsSetReconciler) delete(ctx context.Context, log logr.Logger, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { +func (r *BIOSSettingsSetReconciler) delete(ctx context.Context, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting BIOSSettingsSet") if !controllerutil.ContainsFinalizer(set, biosSettingsSetFinalizer) { @@ -64,7 +63,7 @@ func (r *BIOSSettingsSetReconciler) delete(ctx context.Context, log logr.Logger, // Handle propagation of ignore annotation to child resources when parent is being deleted. // That way the deleted annotations can be passed to children before parent is deleted. - if err := r.handleIgnoreAnnotationPropagation(ctx, log, set); err != nil { + if err := r.handleIgnoreAnnotationPropagation(ctx, set); err != nil { return ctrl.Result{}, err } @@ -93,7 +92,7 @@ func (r *BIOSSettingsSetReconciler) delete(ctx context.Context, log logr.Logger, // Handle propagation of retry annotation to child when parent is being deleted. // That way the deleted annotations can be passed to children before parent is deleted. - if err := r.handleRetryAnnotationPropagation(ctx, log, set); err != nil { + if err := r.handleRetryAnnotationPropagation(ctx, set); err != nil { return ctrl.Result{}, err } @@ -111,7 +110,8 @@ func (r *BIOSSettingsSetReconciler) delete(ctx context.Context, log logr.Logger, return ctrl.Result{}, nil } -func (r *BIOSSettingsSetReconciler) handleIgnoreAnnotationPropagation(ctx context.Context, log logr.Logger, set *metalv1alpha1.BIOSSettingsSet) error { +func (r *BIOSSettingsSetReconciler) handleIgnoreAnnotationPropagation(ctx context.Context, set *metalv1alpha1.BIOSSettingsSet) error { + log := ctrl.LoggerFrom(ctx) ownedBiosSettings, err := r.getOwnedBIOSSettings(ctx, set) if err != nil { return err @@ -122,10 +122,11 @@ func (r *BIOSSettingsSetReconciler) handleIgnoreAnnotationPropagation(ctx contex return nil } - return handleIgnoreAnnotationPropagation(ctx, log, r.Client, set, ownedBiosSettings) + return handleIgnoreAnnotationPropagation(ctx, r.Client, set, ownedBiosSettings) } -func (r *BIOSSettingsSetReconciler) handleRetryAnnotationPropagation(ctx context.Context, log logr.Logger, set *metalv1alpha1.BIOSSettingsSet) error { +func (r *BIOSSettingsSetReconciler) handleRetryAnnotationPropagation(ctx context.Context, set *metalv1alpha1.BIOSSettingsSet) error { + log := ctrl.LoggerFrom(ctx) ownedBiosSettings, err := r.getOwnedBIOSSettings(ctx, set) if err != nil { return err @@ -137,13 +138,14 @@ func (r *BIOSSettingsSetReconciler) handleRetryAnnotationPropagation(ctx context } log.V(1).Info("Propagating retry annotation to owned BIOSSettings resources") - return handleRetryAnnotationPropagation(ctx, log, r.Client, set, ownedBiosSettings) + return handleRetryAnnotationPropagation(ctx, r.Client, set, ownedBiosSettings) } -func (r *BIOSSettingsSetReconciler) reconcile(ctx context.Context, log logr.Logger, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { +func (r *BIOSSettingsSetReconciler) reconcile(ctx context.Context, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling BIOSSettingsSet") - if err := r.handleIgnoreAnnotationPropagation(ctx, log, set); err != nil { + if err := r.handleIgnoreAnnotationPropagation(ctx, set); err != nil { return ctrl.Result{}, err } @@ -160,27 +162,28 @@ func (r *BIOSSettingsSetReconciler) reconcile(ctx context.Context, log logr.Logg if err != nil { return ctrl.Result{}, fmt.Errorf("failed to get Servers for label selector %w", err) } - return r.handleBIOSSettings(ctx, log, serverList, set) + return r.handleBIOSSettings(ctx, serverList, set) } -func (r *BIOSSettingsSetReconciler) handleBIOSSettings(ctx context.Context, log logr.Logger, servers *metalv1alpha1.ServerList, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { +func (r *BIOSSettingsSetReconciler) handleBIOSSettings(ctx context.Context, servers *metalv1alpha1.ServerList, set *metalv1alpha1.BIOSSettingsSet) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) ownedBiosSettings, err := r.getOwnedBIOSSettings(ctx, set) if err != nil { return ctrl.Result{}, err } - if err := r.createMissingBIOSSettings(ctx, log, servers, ownedBiosSettings, set); err != nil { + if err := r.createMissingBIOSSettings(ctx, servers, ownedBiosSettings, set); err != nil { return ctrl.Result{}, fmt.Errorf("failed to create missing BIOSSettings: %w", err) } log.V(1).Info("Summary of Servers and BIOSSettings", "ServerCount", len(servers.Items), "BIOSSettingsCount", len(ownedBiosSettings.Items)) - if err := r.deleteOrphanBIOSSettings(ctx, log, servers, ownedBiosSettings); err != nil { + if err := r.deleteOrphanBIOSSettings(ctx, servers, ownedBiosSettings); err != nil { return ctrl.Result{}, fmt.Errorf("failed to delete orphaned BIOSSettings: %w", err) } - if err := r.patchBIOSSettingsFromTemplate(ctx, log, &set.Spec.BIOSSettingsTemplate, ownedBiosSettings); err != nil { + if err := r.patchBIOSSettingsFromTemplate(ctx, &set.Spec.BIOSSettingsTemplate, ownedBiosSettings); err != nil { return ctrl.Result{}, fmt.Errorf("failed to patch BIOSSettings spec from template: %w", err) } @@ -194,14 +197,15 @@ func (r *BIOSSettingsSetReconciler) handleBIOSSettings(ctx context.Context, log log.V(1).Info("Updated BIOSSettingsSet state", "Status", status) // handle retry annotation - remove the annotation after retrying reconciliation - if err := r.handleRetryAnnotationPropagation(ctx, log, set); err != nil { + if err := r.handleRetryAnnotationPropagation(ctx, set); err != nil { return ctrl.Result{}, err } return ctrl.Result{}, nil } -func (r *BIOSSettingsSetReconciler) createMissingBIOSSettings(ctx context.Context, log logr.Logger, servers *metalv1alpha1.ServerList, settings *metalv1alpha1.BIOSSettingsList, set *metalv1alpha1.BIOSSettingsSet) error { +func (r *BIOSSettingsSetReconciler) createMissingBIOSSettings(ctx context.Context, servers *metalv1alpha1.ServerList, settings *metalv1alpha1.BIOSSettingsList, set *metalv1alpha1.BIOSSettingsSet) error { + log := ctrl.LoggerFrom(ctx) serverWithSettings := make(map[string]struct{}) for _, settings := range settings.Items { serverWithSettings[settings.Spec.ServerRef.Name] = struct{}{} @@ -244,7 +248,8 @@ func (r *BIOSSettingsSetReconciler) createMissingBIOSSettings(ctx context.Contex return errors.Join(errs...) } -func (r *BIOSSettingsSetReconciler) deleteOrphanBIOSSettings(ctx context.Context, log logr.Logger, servers *metalv1alpha1.ServerList, settings *metalv1alpha1.BIOSSettingsList) error { +func (r *BIOSSettingsSetReconciler) deleteOrphanBIOSSettings(ctx context.Context, servers *metalv1alpha1.ServerList, settings *metalv1alpha1.BIOSSettingsList) error { + log := ctrl.LoggerFrom(ctx) serverMap := make(map[string]bool) for _, server := range servers.Items { serverMap[server.Name] = true @@ -265,7 +270,8 @@ func (r *BIOSSettingsSetReconciler) deleteOrphanBIOSSettings(ctx context.Context return errors.Join(errs...) } -func (r *BIOSSettingsSetReconciler) patchBIOSSettingsFromTemplate(ctx context.Context, log logr.Logger, template *metalv1alpha1.BIOSSettingsTemplate, settingsList *metalv1alpha1.BIOSSettingsList) error { +func (r *BIOSSettingsSetReconciler) patchBIOSSettingsFromTemplate(ctx context.Context, template *metalv1alpha1.BIOSSettingsTemplate, settingsList *metalv1alpha1.BIOSSettingsList) error { + log := ctrl.LoggerFrom(ctx) if len(settingsList.Items) == 0 { log.V(1).Info("No BIOSSettings found, skipping template update") return nil diff --git a/internal/controller/biosversion_controller.go b/internal/controller/biosversion_controller.go index 9b497b51..e1f6bb1c 100644 --- a/internal/controller/biosversion_controller.go +++ b/internal/controller/biosversion_controller.go @@ -9,7 +9,6 @@ import ( "fmt" "time" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/conditionutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" @@ -75,17 +74,18 @@ func (r *BIOSVersionReconciler) Reconcile(ctx context.Context, req ctrl.Request) } log.V(1).Info("Reconciling BIOSVersion") - return r.reconcileExists(ctx, log, biosVersion) + return r.reconcileExists(ctx, biosVersion) } -func (r *BIOSVersionReconciler) reconcileExists(ctx context.Context, log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion) (ctrl.Result, error) { - if r.shouldDelete(log, biosVersion) { - return r.delete(ctx, log, biosVersion) +func (r *BIOSVersionReconciler) reconcileExists(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion) (ctrl.Result, error) { + if r.shouldDelete(ctx, biosVersion) { + return r.delete(ctx, biosVersion) } - return r.reconcile(ctx, log, biosVersion) + return r.reconcile(ctx, biosVersion) } -func (r *BIOSVersionReconciler) shouldDelete(log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion) bool { +func (r *BIOSVersionReconciler) shouldDelete(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion) bool { + log := ctrl.LoggerFrom(ctx) if biosVersion.DeletionTimestamp.IsZero() { return false } @@ -99,7 +99,8 @@ func (r *BIOSVersionReconciler) shouldDelete(log logr.Logger, biosVersion *metal return true } -func (r *BIOSVersionReconciler) delete(ctx context.Context, log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion) (ctrl.Result, error) { +func (r *BIOSVersionReconciler) delete(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting BIOSVersion") defer log.V(1).Info("Deleted BIOSVersion") @@ -115,7 +116,8 @@ func (r *BIOSVersionReconciler) delete(ctx context.Context, log logr.Logger, bio return ctrl.Result{}, nil } -func (r *BIOSVersionReconciler) cleanupServerMaintenanceReferences(ctx context.Context, log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion) error { +func (r *BIOSVersionReconciler) cleanupServerMaintenanceReferences(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion) error { + log := ctrl.LoggerFrom(ctx) if biosVersion.Spec.ServerMaintenanceRef == nil { return nil } @@ -145,7 +147,8 @@ func (r *BIOSVersionReconciler) cleanupServerMaintenanceReferences(ctx context.C return nil } -func (r *BIOSVersionReconciler) reconcile(ctx context.Context, log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion) (ctrl.Result, error) { +func (r *BIOSVersionReconciler) reconcile(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if shouldIgnoreReconciliation(biosVersion) { log.V(1).Info("Skipped BIOSVersion reconciliation") return ctrl.Result{}, nil @@ -155,7 +158,7 @@ func (r *BIOSVersionReconciler) reconcile(ctx context.Context, log logr.Logger, return ctrl.Result{}, err } - requeue, err := r.transitionState(ctx, log, biosVersion) + requeue, err := r.transitionState(ctx, biosVersion) if err != nil { return ctrl.Result{}, err } @@ -167,7 +170,8 @@ func (r *BIOSVersionReconciler) reconcile(ctx context.Context, log logr.Logger, return ctrl.Result{}, nil } -func (r *BIOSVersionReconciler) transitionState(ctx context.Context, log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion) (bool, error) { +func (r *BIOSVersionReconciler) transitionState(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion) (bool, error) { + log := ctrl.LoggerFrom(ctx) if biosVersion.Spec.ServerRef == nil { return false, fmt.Errorf("BIOSVersion does not have a ServerRef") } @@ -189,10 +193,10 @@ func (r *BIOSVersionReconciler) transitionState(ctx context.Context, log logr.Lo switch biosVersion.Status.State { case "", metalv1alpha1.BIOSVersionStatePending: - return false, r.cleanup(ctx, log, bmcClient, biosVersion, server) + return false, r.cleanup(ctx, bmcClient, biosVersion, server) case metalv1alpha1.BIOSVersionStateInProgress: if biosVersion.Spec.ServerMaintenanceRef == nil { - if requeue, err := r.requestServerMaintenance(ctx, log, biosVersion, server); err != nil || requeue { + if requeue, err := r.requestServerMaintenance(ctx, biosVersion, server); err != nil || requeue { return false, err } } @@ -207,13 +211,13 @@ func (r *BIOSVersionReconciler) transitionState(ctx context.Context, log logr.Lo return false, nil } - if ok, err := r.handleBMCReset(ctx, log, bmcClient, biosVersion, server); !ok || err != nil { + if ok, err := r.handleBMCReset(ctx, bmcClient, biosVersion, server); !ok || err != nil { return false, err } - return r.processInProgressState(ctx, log, bmcClient, biosVersion, server) + return r.processInProgressState(ctx, bmcClient, biosVersion, server) case metalv1alpha1.BIOSVersionStateCompleted: - return false, r.cleanup(ctx, log, bmcClient, biosVersion, server) + return false, r.cleanup(ctx, bmcClient, biosVersion, server) case metalv1alpha1.BIOSVersionStateFailed: if shouldRetryReconciliation(biosVersion) { log.V(1).Info("Retrying ...") @@ -237,7 +241,8 @@ func (r *BIOSVersionReconciler) transitionState(ctx context.Context, log logr.Lo return false, nil } -func (r *BIOSVersionReconciler) processInProgressState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server) (bool, error) { +func (r *BIOSVersionReconciler) processInProgressState(ctx context.Context, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) issuedCondition, err := GetCondition(r.Conditions, biosVersion.Status.Conditions, ConditionBIOSUpgradeIssued) if err != nil { return false, err @@ -249,7 +254,7 @@ func (r *BIOSVersionReconciler) processInProgressState(ctx context.Context, log log.V(1).Info("Server in powered off state. Retrying ...", "Server", server.Name) return false, nil } - return false, r.upgradeBIOSVersion(ctx, log, bmcClient, biosVersion, server, issuedCondition) + return false, r.upgradeBIOSVersion(ctx, bmcClient, biosVersion, server, issuedCondition) } completedCondition, err := GetCondition(r.Conditions, biosVersion.Status.Conditions, ConditionBIOSUpgradeCompleted) @@ -259,7 +264,7 @@ func (r *BIOSVersionReconciler) processInProgressState(ctx context.Context, log if completedCondition.Status != metav1.ConditionTrue { log.V(1).Info("Check BIOS version upgrade task status") - return r.checkUpdateBiosUpgradeStatus(ctx, log, bmcClient, biosVersion, server, completedCondition) + return r.checkUpdateBiosUpgradeStatus(ctx, bmcClient, biosVersion, server, completedCondition) } rebootPowerOffCondition, err := GetCondition(r.Conditions, biosVersion.Status.Conditions, ConditionBIOSUpgradePowerOff) @@ -357,11 +362,11 @@ func (r *BIOSVersionReconciler) processInProgressState(ctx context.Context, log func (r *BIOSVersionReconciler) handleBMCReset( ctx context.Context, - log logr.Logger, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server, ) (bool, error) { + log := ctrl.LoggerFrom(ctx) // reset BMC if not already done resetBMC, err := GetCondition(r.Conditions, biosVersion.Status.Conditions, BMCConditionReset) if err != nil { @@ -372,7 +377,7 @@ func (r *BIOSVersionReconciler) handleBMCReset( // once the server is powered on, reset the BMC to make sure its in stable state // this avoids problems with some BMCs that hang up in subsequent operations if resetBMC.Reason != BMCReasonReset { - if err := resetBMCOfServer(ctx, log, r.Client, server, bmcClient); err == nil { + if err := resetBMCOfServer(ctx, r.Client, server, bmcClient); err == nil { // mark reset to be issued, wait for next reconcile if err := r.Conditions.Update( resetBMC, @@ -384,14 +389,14 @@ func (r *BIOSVersionReconciler) handleBMCReset( } return false, r.updateStatus(ctx, biosVersion, biosVersion.Status.State, nil, resetBMC) } else { - log.V(1).Error(err, "failed to reset BMC of the server") + log.Error(err, "failed to reset BMC of the server") return false, err } } else if server.Spec.BMCRef != nil { // we need to wait until the BMC resource annotation is removed bmcObj := &metalv1alpha1.BMC{} if err := r.Get(ctx, client.ObjectKey{Name: server.Spec.BMCRef.Name}, bmcObj); err != nil { - log.V(1).Error(err, "failed to get referred server's Manager") + log.Error(err, "failed to get referred server's Manager") return false, err } annotations := bmcObj.GetAnnotations() @@ -426,14 +431,15 @@ func (r *BIOSVersionReconciler) getBIOSVersionFromBMC(ctx context.Context, bmcCl return currentBiosVersion, nil } -func (r *BIOSVersionReconciler) cleanup(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server) error { +func (r *BIOSVersionReconciler) cleanup(ctx context.Context, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) currentBiosVersion, err := r.getBIOSVersionFromBMC(ctx, bmcClient, server) if err != nil { return err } if currentBiosVersion == biosVersion.Spec.Version { - if err := r.cleanupServerMaintenanceReferences(ctx, log, biosVersion); err != nil { + if err := r.cleanupServerMaintenanceReferences(ctx, biosVersion); err != nil { return err } @@ -533,7 +539,8 @@ func (r *BIOSVersionReconciler) ensurePowerState(ctx context.Context, biosVersio return nil } -func (r *BIOSVersionReconciler) requestServerMaintenance(ctx context.Context, log logr.Logger, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server) (bool, error) { +func (r *BIOSVersionReconciler) requestServerMaintenance(ctx context.Context, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if biosVersion.Spec.ServerMaintenanceRef != nil { return false, nil } @@ -569,12 +576,12 @@ func (r *BIOSVersionReconciler) requestServerMaintenance(ctx context.Context, lo func (r *BIOSVersionReconciler) checkUpdateBiosUpgradeStatus( ctx context.Context, - log logr.Logger, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server, completedCondition *metav1.Condition, ) (bool, error) { + log := ctrl.LoggerFrom(ctx) taskURI := biosVersion.Status.UpgradeTask.URI taskCurrentStatus, err := func() (*redfish.Task, error) { if taskURI == "" { @@ -666,12 +673,12 @@ func (r *BIOSVersionReconciler) checkUpdateBiosUpgradeStatus( func (r *BIOSVersionReconciler) upgradeBIOSVersion( ctx context.Context, - log logr.Logger, bmcClient bmc.BMC, biosVersion *metalv1alpha1.BIOSVersion, server *metalv1alpha1.Server, issuedCondition *metav1.Condition, ) error { + log := ctrl.LoggerFrom(ctx) var username, password string if biosVersion.Spec.Image.SecretRef != nil { var err error @@ -701,14 +708,14 @@ func (r *BIOSVersionReconciler) upgradeBIOSVersion( upgradeCurrentTaskStatus := &metalv1alpha1.Task{URI: taskMonitor} if isFatal { - log.V(1).Error(err, "failed to issue bios upgrade", "Version", biosVersion.Spec.Version, "Server", server.Name) + log.Error(err, "failed to issue bios upgrade", "Version", biosVersion.Spec.Version, "Server", server.Name) if errCond := r.Conditions.Update( issuedCondition, conditionutils.UpdateStatus(corev1.ConditionFalse), conditionutils.UpdateReason(ReasonUpgradeIssueFailed), conditionutils.UpdateMessage("Fatal error occurred. Upgrade might still go through on server."), ); errCond != nil { - log.V(1).Error(errCond, "failed to update conditions") + log.Error(errCond, "failed to update conditions") err := r.updateStatus(ctx, biosVersion, metalv1alpha1.BIOSVersionStateFailed, upgradeCurrentTaskStatus, issuedCondition) return errors.Join(errCond, err) } @@ -716,7 +723,7 @@ func (r *BIOSVersionReconciler) upgradeBIOSVersion( return r.updateStatus(ctx, biosVersion, metalv1alpha1.BIOSVersionStateFailed, upgradeCurrentTaskStatus, issuedCondition) } if err != nil { - log.V(1).Error(err, "failed to issue bios upgrade", "Version", biosVersion.Spec.Version, "Server", server.Name) + log.Error(err, "failed to issue bios upgrade", "Version", biosVersion.Spec.Version, "Server", server.Name) return err } if errCond := r.Conditions.Update( @@ -725,14 +732,14 @@ func (r *BIOSVersionReconciler) upgradeBIOSVersion( conditionutils.UpdateReason(ReasonUpgradeIssued), conditionutils.UpdateMessage(fmt.Sprintf("Task to upgrade has been created %v", taskMonitor)), ); errCond != nil { - log.V(1).Error(errCond, "failed to update conditions") + log.Error(errCond, "failed to update conditions") if errCond := r.Conditions.Update( issuedCondition, conditionutils.UpdateStatus(corev1.ConditionTrue), conditionutils.UpdateReason(ReasonUpgradeIssued), conditionutils.UpdateMessage(fmt.Sprintf("Task to upgrade has been created %v", taskMonitor)), ); errCond != nil { - log.V(1).Error(errCond, "failed to update conditions") + log.Error(errCond, "failed to update conditions") err := r.updateStatus(ctx, biosVersion, metalv1alpha1.BIOSVersionStateFailed, upgradeCurrentTaskStatus, issuedCondition) return errors.Join(errCond, err) } @@ -791,7 +798,7 @@ func (r *BIOSVersionReconciler) enqueueBiosSettingsByBMC(ctx context.Context, ob server := object.(*metalv1alpha1.Server) return server.Spec.BMCRef != nil && server.Spec.BMCRef.Name == bmcObj.Name, nil }); err != nil { - log.V(1).Error(err, "failed to list Server created by this BMC resources", "BMC", bmcObj.Name) + log.Error(err, "failed to list Server created by this BMC resources", "BMC", bmcObj.Name) return nil } @@ -808,7 +815,7 @@ func (r *BIOSVersionReconciler) enqueueBiosSettingsByBMC(ctx context.Context, ob } return true, nil }); err != nil { - log.V(1).Error(err, "failed to list Server created by this BMC resources", "BMC", bmcObj.Name) + log.Error(err, "failed to list Server created by this BMC resources", "BMC", bmcObj.Name) return nil } @@ -817,7 +824,7 @@ func (r *BIOSVersionReconciler) enqueueBiosSettingsByBMC(ctx context.Context, ob if biosVersion.Status.State == metalv1alpha1.BIOSVersionStateInProgress { resetBMC, err := GetCondition(r.Conditions, biosVersion.Status.Conditions, BMCConditionReset) if err != nil { - log.V(1).Error(err, "failed to get reset BMC condition") + log.Error(err, "failed to get reset BMC condition") continue } if resetBMC.Status == metav1.ConditionTrue { diff --git a/internal/controller/biosversionset_controller.go b/internal/controller/biosversionset_controller.go index 34d58d8e..eb09ec46 100644 --- a/internal/controller/biosversionset_controller.go +++ b/internal/controller/biosversionset_controller.go @@ -20,7 +20,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/predicate" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" ) @@ -42,28 +41,28 @@ type BIOSVersionSetReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *BIOSVersionSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) versionSet := &metalv1alpha1.BIOSVersionSet{} if err := r.Get(ctx, req.NamespacedName, versionSet); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, versionSet) + return r.reconcileExists(ctx, versionSet) } -func (r *BIOSVersionSetReconciler) reconcileExists(ctx context.Context, log logr.Logger, versionSet *metalv1alpha1.BIOSVersionSet) (ctrl.Result, error) { +func (r *BIOSVersionSetReconciler) reconcileExists(ctx context.Context, versionSet *metalv1alpha1.BIOSVersionSet) (ctrl.Result, error) { if !versionSet.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, versionSet) + return r.delete(ctx, versionSet) } - return r.reconcile(ctx, log, versionSet) + return r.reconcile(ctx, versionSet) } -func (r *BIOSVersionSetReconciler) delete(ctx context.Context, log logr.Logger, versionSet *metalv1alpha1.BIOSVersionSet) (ctrl.Result, error) { +func (r *BIOSVersionSetReconciler) delete(ctx context.Context, versionSet *metalv1alpha1.BIOSVersionSet) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting BIOSVersionSet") if !controllerutil.ContainsFinalizer(versionSet, BIOSVersionSetFinalizer) { return ctrl.Result{}, nil } - if err := r.handleIgnoreAnnotationPropagation(ctx, log, versionSet); err != nil { + if err := r.handleIgnoreAnnotationPropagation(ctx, versionSet); err != nil { return ctrl.Result{}, err } @@ -80,7 +79,7 @@ func (r *BIOSVersionSetReconciler) delete(ctx context.Context, log logr.Logger, } log.V(1).Info("BIOSVersionSet status patched", "Status", status) - if err := r.handleRetryAnnotationPropagation(ctx, log, versionSet); err != nil { + if err := r.handleRetryAnnotationPropagation(ctx, versionSet); err != nil { return ctrl.Result{}, err } log.Info("Waiting on the created BIOSVersion to reach terminal status") @@ -96,7 +95,8 @@ func (r *BIOSVersionSetReconciler) delete(ctx context.Context, log logr.Logger, return ctrl.Result{}, nil } -func (r *BIOSVersionSetReconciler) handleIgnoreAnnotationPropagation(ctx context.Context, log logr.Logger, versionSet *metalv1alpha1.BIOSVersionSet) error { +func (r *BIOSVersionSetReconciler) handleIgnoreAnnotationPropagation(ctx context.Context, versionSet *metalv1alpha1.BIOSVersionSet) error { + log := ctrl.LoggerFrom(ctx) versions, err := r.getOwnedBIOSVersions(ctx, versionSet) if err != nil { return err @@ -106,10 +106,11 @@ func (r *BIOSVersionSetReconciler) handleIgnoreAnnotationPropagation(ctx context log.V(1).Info("No BIOSVersions found, skipping ignore annotation propagation") return nil } - return handleIgnoreAnnotationPropagation(ctx, log, r.Client, versionSet, versions) + return handleIgnoreAnnotationPropagation(ctx, r.Client, versionSet, versions) } -func (r *BIOSVersionSetReconciler) handleRetryAnnotationPropagation(ctx context.Context, log logr.Logger, versionSet *metalv1alpha1.BIOSVersionSet) error { +func (r *BIOSVersionSetReconciler) handleRetryAnnotationPropagation(ctx context.Context, versionSet *metalv1alpha1.BIOSVersionSet) error { + log := ctrl.LoggerFrom(ctx) versions, err := r.getOwnedBIOSVersions(ctx, versionSet) if err != nil { return err @@ -119,12 +120,13 @@ func (r *BIOSVersionSetReconciler) handleRetryAnnotationPropagation(ctx context. log.V(1).Info("No BIOSVersion found, skipping retry annotation propagation") return nil } - return handleRetryAnnotationPropagation(ctx, log, r.Client, versionSet, versions) + return handleRetryAnnotationPropagation(ctx, r.Client, versionSet, versions) } -func (r *BIOSVersionSetReconciler) reconcile(ctx context.Context, log logr.Logger, versionSet *metalv1alpha1.BIOSVersionSet) (ctrl.Result, error) { +func (r *BIOSVersionSetReconciler) reconcile(ctx context.Context, versionSet *metalv1alpha1.BIOSVersionSet) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling BIOSVersionSet") - if err := r.handleIgnoreAnnotationPropagation(ctx, log, versionSet); err != nil { + if err := r.handleIgnoreAnnotationPropagation(ctx, versionSet); err != nil { return ctrl.Result{}, err } @@ -150,16 +152,16 @@ func (r *BIOSVersionSetReconciler) reconcile(ctx context.Context, log logr.Logge log.V(1).Info("Summary of Servers and BIOSVersions", "ServerCount", len(servers.Items), "BIOSVersionCount", len(versions.Items)) // Create BIOSVersion for servers which do not have one yet - if err := r.ensureBIOSVersionsForServers(ctx, log, servers, versions, versionSet); err != nil { + if err := r.ensureBIOSVersionsForServers(ctx, servers, versions, versionSet); err != nil { return ctrl.Result{}, fmt.Errorf("failed to create BIOSVersions: %w", err) } // Delete BIOSVersions which no longer have a matching server - if err := r.deleteOrphanBIOSVersions(ctx, log, servers, versions); err != nil { + if err := r.deleteOrphanBIOSVersions(ctx, servers, versions); err != nil { return ctrl.Result{}, fmt.Errorf("failed to delete orphaned BIOSVersions: %w", err) } - if err := r.patchBIOSVersionFromTemplate(ctx, log, &versionSet.Spec.BIOSVersionTemplate, versions); err != nil { + if err := r.patchBIOSVersionFromTemplate(ctx, &versionSet.Spec.BIOSVersionTemplate, versions); err != nil { return ctrl.Result{}, fmt.Errorf("failed to patch BIOSVersion spec from template: %w", err) } @@ -172,7 +174,7 @@ func (r *BIOSVersionSetReconciler) reconcile(ctx context.Context, log logr.Logge } log.V(1).Info("Patched BIOSVersionSet status", "Status", status) - if err := r.handleRetryAnnotationPropagation(ctx, log, versionSet); err != nil { + if err := r.handleRetryAnnotationPropagation(ctx, versionSet); err != nil { return ctrl.Result{}, err } @@ -180,7 +182,8 @@ func (r *BIOSVersionSetReconciler) reconcile(ctx context.Context, log logr.Logge return ctrl.Result{}, nil } -func (r *BIOSVersionSetReconciler) ensureBIOSVersionsForServers(ctx context.Context, log logr.Logger, servers *metalv1alpha1.ServerList, versions *metalv1alpha1.BIOSVersionList, versionSet *metalv1alpha1.BIOSVersionSet) error { +func (r *BIOSVersionSetReconciler) ensureBIOSVersionsForServers(ctx context.Context, servers *metalv1alpha1.ServerList, versions *metalv1alpha1.BIOSVersionList, versionSet *metalv1alpha1.BIOSVersionSet) error { + log := ctrl.LoggerFrom(ctx) withBiosVersion := make(map[string]bool) for _, version := range versions.Items { withBiosVersion[version.Spec.ServerRef.Name] = true @@ -218,7 +221,8 @@ func (r *BIOSVersionSetReconciler) ensureBIOSVersionsForServers(ctx context.Cont return errors.Join(errs...) } -func (r *BIOSVersionSetReconciler) deleteOrphanBIOSVersions(ctx context.Context, log logr.Logger, servers *metalv1alpha1.ServerList, versions *metalv1alpha1.BIOSVersionList) error { +func (r *BIOSVersionSetReconciler) deleteOrphanBIOSVersions(ctx context.Context, servers *metalv1alpha1.ServerList, versions *metalv1alpha1.BIOSVersionList) error { + log := ctrl.LoggerFrom(ctx) serverMap := make(map[string]bool) for _, server := range servers.Items { serverMap[server.Name] = true @@ -239,7 +243,8 @@ func (r *BIOSVersionSetReconciler) deleteOrphanBIOSVersions(ctx context.Context, return errors.Join(errs...) } -func (r *BIOSVersionSetReconciler) patchBIOSVersionFromTemplate(ctx context.Context, log logr.Logger, template *metalv1alpha1.BIOSVersionTemplate, versions *metalv1alpha1.BIOSVersionList) error { +func (r *BIOSVersionSetReconciler) patchBIOSVersionFromTemplate(ctx context.Context, template *metalv1alpha1.BIOSVersionTemplate, versions *metalv1alpha1.BIOSVersionList) error { + log := ctrl.LoggerFrom(ctx) if len(versions.Items) == 0 { log.V(1).Info("No BIOSVersion found, skipping spec template update") return nil @@ -318,14 +323,14 @@ func (r *BIOSVersionSetReconciler) enqueueByServer(ctx context.Context, obj clie setList := &metalv1alpha1.BIOSVersionSetList{} if err := r.List(ctx, setList); err != nil { - log.V(1).Error(err, "failed to list BIOSVersionSet") + log.Error(err, "failed to list BIOSVersionSet") return nil } reqs := make([]ctrl.Request, 0) for _, set := range setList.Items { selector, err := metav1.LabelSelectorAsSelector(&set.Spec.ServerSelector) if err != nil { - log.V(1).Error(err, "failed to convert label selector") + log.Error(err, "failed to convert label selector") return nil } // If the Server label matches the selector, enqueue the request @@ -334,7 +339,7 @@ func (r *BIOSVersionSetReconciler) enqueueByServer(ctx context.Context, obj clie } else { // if the label has been removed versions, err := r.getOwnedBIOSVersions(ctx, &set) if err != nil { - log.V(1).Error(err, "failed to get owned BIOSVersions") + log.Error(err, "failed to get owned BIOSVersions") return nil } for _, version := range versions.Items { diff --git a/internal/controller/bmc_controller.go b/internal/controller/bmc_controller.go index 1a20260c..357cf51c 100644 --- a/internal/controller/bmc_controller.go +++ b/internal/controller/bmc_controller.go @@ -18,7 +18,6 @@ import ( "k8s.io/apimachinery/pkg/util/yaml" "sigs.k8s.io/controller-runtime/pkg/handler" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/conditionutils" "github.com/ironcore-dev/controller-utils/metautils" @@ -81,23 +80,23 @@ type BMCReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *BMCReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) bmcObj := &metalv1alpha1.BMC{} if err := r.Get(ctx, req.NamespacedName, bmcObj); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, bmcObj) + return r.reconcileExists(ctx, bmcObj) } -func (r *BMCReconciler) reconcileExists(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC) (ctrl.Result, error) { +func (r *BMCReconciler) reconcileExists(ctx context.Context, bmcObj *metalv1alpha1.BMC) (ctrl.Result, error) { if !bmcObj.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, bmcObj) + return r.delete(ctx, bmcObj) } - return r.reconcile(ctx, log, bmcObj) + return r.reconcile(ctx, bmcObj) } -func (r *BMCReconciler) delete(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC) (ctrl.Result, error) { +func (r *BMCReconciler) delete(ctx context.Context, bmcObj *metalv1alpha1.BMC) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting BMC") if bmcObj.Spec.BMCSettingRef != nil { bmcSettings := &metalv1alpha1.BMCSettings{} @@ -117,7 +116,8 @@ func (r *BMCReconciler) delete(ctx context.Context, log logr.Logger, bmcObj *met return ctrl.Result{}, nil } -func (r *BMCReconciler) reconcile(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC) (ctrl.Result, error) { +func (r *BMCReconciler) reconcile(ctx context.Context, bmcObj *metalv1alpha1.BMC) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling BMC") if shouldIgnoreReconciliation(bmcObj) { log.V(1).Info("Skipped BMC reconciliation") @@ -137,7 +137,7 @@ func (r *BMCReconciler) reconcile(ctx context.Context, log logr.Logger, bmcObj * if err != nil { if r.shouldResetBMC(bmcObj) { log.V(1).Info("BMC needs reset, resetting", "BMC", bmcObj.Name) - if err := r.resetBMC(ctx, log, bmcObj, bmcClient, bmcAutoResetReason, bmcAutoResetMessage); err != nil { + if err := r.resetBMC(ctx, bmcObj, bmcClient, bmcAutoResetReason, bmcAutoResetMessage); err != nil { return ctrl.Result{}, fmt.Errorf("failed to reset BMC: %w", err) } log.V(1).Info("BMC reset initiated", "BMC", bmcObj.Name) @@ -153,11 +153,11 @@ func (r *BMCReconciler) reconcile(ctx context.Context, log logr.Logger, bmcObj * defer bmcClient.Logout() // if BMC reset was issued and is successful, ensure to remove previous reset annotation - if modified, err := r.handlePreviousBMCResetAnnotations(ctx, log, bmcObj); err != nil || modified { + if modified, err := r.handlePreviousBMCResetAnnotations(ctx, bmcObj); err != nil || modified { return ctrl.Result{}, err } - if modified, err := r.handleAnnotationOperations(ctx, log, bmcObj, bmcClient); err != nil || modified { + if modified, err := r.handleAnnotationOperations(ctx, bmcObj, bmcClient); err != nil || modified { return ctrl.Result{}, err } @@ -168,19 +168,19 @@ func (r *BMCReconciler) reconcile(ctx context.Context, log logr.Logger, bmcObj * return ctrl.Result{}, fmt.Errorf("failed to set BMC reset complete condition: %w", err) } - if err := r.updateBMCStatusDetails(ctx, log, bmcClient, bmcObj); err != nil { + if err := r.updateBMCStatusDetails(ctx, bmcClient, bmcObj); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update BMC status: %w", err) } log.V(1).Info("Updated BMC status", "State", bmcObj.Status.State) // Create DNS record for the bmc if template is configured if r.ManagerNamespace != "" && r.DNSRecordTemplate != "" { - if err := r.createDNSRecord(ctx, log, bmcObj); err != nil { + if err := r.createDNSRecord(ctx, bmcObj); err != nil { return ctrl.Result{}, fmt.Errorf("failed to create DNS record for BMC %s: %w", bmcObj.Name, err) } } - if err := r.discoverServers(ctx, log, bmcClient, bmcObj); err != nil && !apierrors.IsNotFound(err) { + if err := r.discoverServers(ctx, bmcClient, bmcObj); err != nil && !apierrors.IsNotFound(err) { return ctrl.Result{}, fmt.Errorf("failed to discover servers: %w", err) } log.V(1).Info("Discovered servers") @@ -189,7 +189,8 @@ func (r *BMCReconciler) reconcile(ctx context.Context, log logr.Logger, bmcObj * return ctrl.Result{}, nil } -func (r *BMCReconciler) updateBMCStatusDetails(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, bmcObj *metalv1alpha1.BMC) error { +func (r *BMCReconciler) updateBMCStatusDetails(ctx context.Context, bmcClient bmc.BMC, bmcObj *metalv1alpha1.BMC) error { + log := ctrl.LoggerFrom(ctx) var ( ip metalv1alpha1.IP macAddress string @@ -256,7 +257,8 @@ func (r *BMCReconciler) updateBMCStatusDetails(ctx context.Context, log logr.Log return nil } -func (r *BMCReconciler) discoverServers(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, bmcObj *metalv1alpha1.BMC) error { +func (r *BMCReconciler) discoverServers(ctx context.Context, bmcClient bmc.BMC, bmcObj *metalv1alpha1.BMC) error { + log := ctrl.LoggerFrom(ctx) servers, err := bmcClient.GetSystems(ctx) if err != nil { return fmt.Errorf("failed to get servers from BMC %s: %w", bmcObj.Name, err) @@ -295,7 +297,8 @@ type DNSRecordTemplateData struct { } // createDNSRecord creates a DNS record resource from a YAML template loaded from ConfigMap -func (r *BMCReconciler) createDNSRecord(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC) error { +func (r *BMCReconciler) createDNSRecord(ctx context.Context, bmcObj *metalv1alpha1.BMC) error { + log := ctrl.LoggerFrom(ctx) templateData := DNSRecordTemplateData{ Namespace: r.ManagerNamespace, Name: bmcObj.Name, @@ -343,7 +346,8 @@ func (r *BMCReconciler) createDNSRecord(ctx context.Context, log logr.Logger, bm return nil } -func (r *BMCReconciler) handleAnnotationOperations(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC, bmcClient bmc.BMC) (bool, error) { +func (r *BMCReconciler) handleAnnotationOperations(ctx context.Context, bmcObj *metalv1alpha1.BMC, bmcClient bmc.BMC) (bool, error) { + log := ctrl.LoggerFrom(ctx) operation, ok := bmcObj.GetAnnotations()[metalv1alpha1.OperationAnnotation] if !ok { return false, nil @@ -356,10 +360,10 @@ func (r *BMCReconciler) handleAnnotationOperations(ctx context.Context, log logr switch value { case redfish.GracefulRestartResetType: log.V(1).Info("Handling operation", "Operation", operation, "RedfishResetType", value) - if err := r.resetBMC(ctx, log, bmcObj, bmcClient, bmcUserResetReason, bmcUserResetMessage); err != nil { + if err := r.resetBMC(ctx, bmcObj, bmcClient, bmcUserResetReason, bmcUserResetMessage); err != nil { return false, fmt.Errorf("failed to reset BMC: %w", err) } - log.V(0).Info("Handled operation", "Operation", operation) + log.Info("Handled operation", "Operation", operation) default: log.V(1).Info("Unsupported operation annotation", "Operation", operation, "RedfishResetType", value) return false, nil @@ -422,7 +426,8 @@ func (r *BMCReconciler) waitForBMCReset(bmcObj *metalv1alpha1.BMC, delay time.Du return false } -func (r *BMCReconciler) handlePreviousBMCResetAnnotations(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC) (bool, error) { +func (r *BMCReconciler) handlePreviousBMCResetAnnotations(ctx context.Context, bmcObj *metalv1alpha1.BMC) (bool, error) { + log := ctrl.LoggerFrom(ctx) condition := &metav1.Condition{} found, err := r.Conditions.FindSlice(bmcObj.Status.Conditions, bmcResetConditionType, condition) if err != nil || !found { @@ -476,7 +481,8 @@ func (r *BMCReconciler) updateBMCState(ctx context.Context, bmcObj *metalv1alpha return nil } -func (r *BMCReconciler) resetBMC(ctx context.Context, log logr.Logger, bmcObj *metalv1alpha1.BMC, bmcClient bmc.BMC, reason, message string) error { +func (r *BMCReconciler) resetBMC(ctx context.Context, bmcObj *metalv1alpha1.BMC, bmcClient bmc.BMC, reason, message string) error { + log := ctrl.LoggerFrom(ctx) if err := r.updateConditions(ctx, bmcObj, true, bmcResetConditionType, corev1.ConditionTrue, reason, message); err != nil { return fmt.Errorf("failed to set BMC resetting condition: %w", err) } diff --git a/internal/controller/bmcsettings_controller.go b/internal/controller/bmcsettings_controller.go index 3cc1135c..97638b13 100644 --- a/internal/controller/bmcsettings_controller.go +++ b/internal/controller/bmcsettings_controller.go @@ -20,7 +20,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/handler" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/conditionutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" @@ -62,14 +61,14 @@ func (r *BMCSettingsReconciler) Reconcile( ctx context.Context, req ctrl.Request, ) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) bmcSetting := &metalv1alpha1.BMCSettings{} if err := r.Get(ctx, req.NamespacedName, bmcSetting); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling BMCSettings") - return r.reconcileExists(ctx, log, bmcSetting) + return r.reconcileExists(ctx, bmcSetting) } // Determine whether reconciliation is required. It's not required if: @@ -78,20 +77,20 @@ func (r *BMCSettingsReconciler) Reconcile( // - object contains reference to server, but server references to another object with lower version; func (r *BMCSettingsReconciler) reconcileExists( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) // if object is being deleted - reconcile deletion - if r.shouldDelete(log, bmcSetting) { + if r.shouldDelete(ctx, bmcSetting) { log.V(1).Info("Object is being deleted") - return r.delete(ctx, log, bmcSetting) + return r.delete(ctx, bmcSetting) } - return r.reconcile(ctx, log, bmcSetting) + return r.reconcile(ctx, bmcSetting) } func (r *BMCSettingsReconciler) shouldDelete( - log logr.Logger, + ctx context.Context, bmcSetting *metalv1alpha1.BMCSettings, ) bool { if bmcSetting.DeletionTimestamp.IsZero() { @@ -100,6 +99,7 @@ func (r *BMCSettingsReconciler) shouldDelete( if controllerutil.ContainsFinalizer(bmcSetting, BMCSettingFinalizer) && bmcSetting.Status.State == metalv1alpha1.BMCSettingsStateInProgress { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("postponing delete as Settings update is in progress") return false } @@ -108,10 +108,10 @@ func (r *BMCSettingsReconciler) shouldDelete( func (r *BMCSettingsReconciler) delete( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, ) (ctrl.Result, error) { - if err := r.cleanupReferences(ctx, log, bmcSetting); err != nil { + log := ctrl.LoggerFrom(ctx) + if err := r.cleanupReferences(ctx, bmcSetting); err != nil { log.Error(err, "failed to cleanup references") return ctrl.Result{}, err } @@ -128,14 +128,14 @@ func (r *BMCSettingsReconciler) delete( func (r *BMCSettingsReconciler) cleanupServerMaintenanceReferences( ctx context.Context, - log logr.Logger, bmcSettings *metalv1alpha1.BMCSettings, ) error { + log := ctrl.LoggerFrom(ctx) if bmcSettings.Spec.ServerMaintenanceRefs == nil { return nil } // try to get the serverMaintenances created - serverMaintenances, errs := r.getReferredServerMaintenances(ctx, log, bmcSettings.Spec.ServerMaintenanceRefs) + serverMaintenances, errs := r.getReferredServerMaintenances(ctx, bmcSettings.Spec.ServerMaintenanceRefs) var finalErr []error var missingServerMaintenanceRef []error @@ -172,7 +172,7 @@ func (r *BMCSettingsReconciler) cleanupServerMaintenanceReferences( if len(finalErr) == 0 { // all serverMaintenance are deleted - err := r.patchMaintenanceRequestRefOnBMCSettings(ctx, log, bmcSettings, nil) + err := r.patchMaintenanceRequestRefOnBMCSettings(ctx, bmcSettings, nil) if err != nil { return fmt.Errorf("failed to clean up serverMaintenance ref in bmcSetting status: %w", err) } @@ -183,11 +183,10 @@ func (r *BMCSettingsReconciler) cleanupServerMaintenanceReferences( func (r *BMCSettingsReconciler) cleanupReferences( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, ) (err error) { if bmcSetting.Spec.BMCRef != nil { - BMC, err := r.getBMC(ctx, log, bmcSetting) + BMC, err := r.getBMC(ctx, bmcSetting) if err != nil && !apierrors.IsNotFound(err) { return err } @@ -201,7 +200,7 @@ func (r *BMCSettingsReconciler) cleanupReferences( if BMC.Spec.BMCSettingRef.Name != bmcSetting.Name { return nil } - return r.patchBMCSettingsRefOnBMC(ctx, log, BMC, nil) + return r.patchBMCSettingsRefOnBMC(ctx, BMC, nil) } else { // nothing else to clean up return nil @@ -214,9 +213,9 @@ func (r *BMCSettingsReconciler) cleanupReferences( func (r *BMCSettingsReconciler) reconcile( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if shouldIgnoreReconciliation(bmcSetting) { log.V(1).Info("Skipped BMCSettings reconciliation") return ctrl.Result{}, nil @@ -230,18 +229,18 @@ func (r *BMCSettingsReconciler) reconcile( } // if referred BMC contains reference to different BMCSettings object - stop reconciliation - BMC, err := r.getBMC(ctx, log, bmcSetting) + BMC, err := r.getBMC(ctx, bmcSetting) if err != nil { log.V(1).Info("Referred server object could not be fetched") return ctrl.Result{}, err } // patch BMC with BMCSettings reference if BMC.Spec.BMCSettingRef == nil { - if err := r.patchBMCSettingsRefOnBMC(ctx, log, BMC, &corev1.LocalObjectReference{Name: bmcSetting.Name}); err != nil { + if err := r.patchBMCSettingsRefOnBMC(ctx, BMC, &corev1.LocalObjectReference{Name: bmcSetting.Name}); err != nil { return ctrl.Result{}, err } } else if BMC.Spec.BMCSettingRef.Name != bmcSetting.Name { - referredBMCSettings, err := r.getReferredBMCSettings(ctx, log, BMC.Spec.BMCSettingRef) + referredBMCSettings, err := r.getReferredBMCSettings(ctx, BMC.Spec.BMCSettingRef) if err != nil { log.V(1).Info("Referred server contains reference to different BMCSettings object, unable to fetch the referenced BMCSettings") return ctrl.Result{}, err @@ -250,7 +249,7 @@ func (r *BMCSettingsReconciler) reconcile( // todo : handle version checks correctly if referredBMCSettings.Spec.Version < bmcSetting.Spec.Version { log.V(1).Info("Updating BMCSettings reference to the latest BMC version") - if err := r.patchBMCSettingsRefOnBMC(ctx, log, BMC, &corev1.LocalObjectReference{Name: bmcSetting.Name}); err != nil { + if err := r.patchBMCSettingsRefOnBMC(ctx, BMC, &corev1.LocalObjectReference{Name: bmcSetting.Name}); err != nil { return ctrl.Result{}, err } } @@ -260,15 +259,15 @@ func (r *BMCSettingsReconciler) reconcile( return ctrl.Result{}, err } - return r.ensureBMCSettingsMaintenanceStateTransition(ctx, log, bmcSetting, BMC) + return r.ensureBMCSettingsMaintenanceStateTransition(ctx, bmcSetting, BMC) } func (r *BMCSettingsReconciler) ensureBMCSettingsMaintenanceStateTransition( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) bmcClient, err := bmcutils.GetBMCClientFromBMC(ctx, r.Client, BMC, r.Insecure, r.BMCOptions) if err != nil { if errors.As(err, &bmcutils.BMCUnAvailableError{}) { @@ -308,14 +307,14 @@ func (r *BMCSettingsReconciler) ensureBMCSettingsMaintenanceStateTransition( } else { versionCheckCondition = nil } - err = r.updateBMCSettingsStatus(ctx, log, bmcSetting, state, versionCheckCondition) + err = r.updateBMCSettingsStatus(ctx, bmcSetting, state, versionCheckCondition) return ctrl.Result{}, err case metalv1alpha1.BMCSettingsStateInProgress: - return r.handleSettingInProgressState(ctx, log, bmcSetting, BMC, bmcClient) + return r.handleSettingInProgressState(ctx, bmcSetting, BMC, bmcClient) case metalv1alpha1.BMCSettingsStateApplied: - return ctrl.Result{}, r.handleSettingAppliedState(ctx, log, bmcSetting, BMC, bmcClient) + return ctrl.Result{}, r.handleSettingAppliedState(ctx, bmcSetting, BMC, bmcClient) case metalv1alpha1.BMCSettingsStateFailed: - return ctrl.Result{}, r.handleFailedState(ctx, log, bmcSetting, BMC) + return ctrl.Result{}, r.handleFailedState(ctx, bmcSetting, BMC) } log.V(1).Info("Unknown State found", "BMCSettings state", bmcSetting.Status.State) return ctrl.Result{}, nil @@ -323,12 +322,12 @@ func (r *BMCSettingsReconciler) ensureBMCSettingsMaintenanceStateTransition( func (r *BMCSettingsReconciler) handleSettingInProgressState( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, bmcClient bmc.BMC, ) (ctrl.Result, error) { - settingsDiff, err := r.getBMCSettingsDifference(ctx, log, bmcSetting, BMC, bmcClient) + log := ctrl.LoggerFrom(ctx) + settingsDiff, err := r.getBMCSettingsDifference(ctx, bmcSetting, BMC, bmcClient) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to get BMC settings: %w", err) @@ -336,36 +335,36 @@ func (r *BMCSettingsReconciler) handleSettingInProgressState( // if setting is not different, complete the BMCSettings tasks if len(settingsDiff) == 0 { // move status to completed - err := r.updateBMCSettingsStatus(ctx, log, bmcSetting, metalv1alpha1.BMCSettingsStateApplied, nil) + err := r.updateBMCSettingsStatus(ctx, bmcSetting, metalv1alpha1.BMCSettingsStateApplied, nil) return ctrl.Result{}, err } - if req, err := r.requestMaintenanceOnServers(ctx, log, bmcSetting, bmcClient); err != nil || req { + if req, err := r.requestMaintenanceOnServers(ctx, bmcSetting, bmcClient); err != nil || req { return ctrl.Result{}, err } // check if the maintenance is granted - if ok := r.checkIfMaintenanceGranted(ctx, log, bmcSetting, bmcClient); !ok { + if ok := r.checkIfMaintenanceGranted(ctx, bmcSetting, bmcClient); !ok { log.V(1).Info("Waiting for maintenance to be granted before continuing with updating settings") return ctrl.Result{}, err } // once the server is powered on, reset the BMC to make sure its in stable state // this avoids problems with some BMCs that hang up in subsequent operations - if ok, err := r.handleBMCReset(ctx, log, bmcSetting, BMC, BMCConditionReset); !ok || err != nil { + if ok, err := r.handleBMCReset(ctx, bmcSetting, BMC, BMCConditionReset); !ok || err != nil { return ctrl.Result{}, err } - return r.updateSettingsAndVerify(ctx, log, bmcSetting, BMC, settingsDiff, bmcClient) + return r.updateSettingsAndVerify(ctx, bmcSetting, BMC, settingsDiff, bmcClient) } func (r *BMCSettingsReconciler) updateSettingsAndVerify( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, settingsDiff redfish.SettingsAttributes, bmcClient bmc.BMC, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) resetBMC, err := GetCondition(r.Conditions, bmcSetting.Status.Conditions, BMCResetPostSettingApplyCondition) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to get condition for reset of BMC of server %v", err) @@ -390,7 +389,7 @@ func (r *BMCSettingsReconciler) updateSettingsAndVerify( ); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update Pending BMCVersion update condition: %w", err) } - err = r.updateBMCSettingsStatus(ctx, log, bmcSetting, bmcSetting.Status.State, BMCPoweredOffCondition) + err = r.updateBMCSettingsStatus(ctx, bmcSetting, bmcSetting.Status.State, BMCPoweredOffCondition) return ctrl.Result{}, err } default: @@ -407,7 +406,7 @@ func (r *BMCSettingsReconciler) updateSettingsAndVerify( ); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update Pending BMCVersion update condition: %w", err) } - err = r.updateBMCSettingsStatus(ctx, log, bmcSetting, metalv1alpha1.BMCSettingsStateFailed, BMCPoweredOffCondition) + err = r.updateBMCSettingsStatus(ctx, bmcSetting, metalv1alpha1.BMCSettingsStateFailed, BMCPoweredOffCondition) return ctrl.Result{}, err } @@ -430,20 +429,20 @@ func (r *BMCSettingsReconciler) updateSettingsAndVerify( if resetBMCReq { // reset BMC if the setting change requires it - if ok, err := r.handleBMCReset(ctx, log, bmcSetting, BMC, BMCResetPostSettingApplyCondition); !ok || err != nil { + if ok, err := r.handleBMCReset(ctx, bmcSetting, BMC, BMCResetPostSettingApplyCondition); !ok || err != nil { return ctrl.Result{}, err } } } } else { log.V(1).Info("Waiting for BMC reset post applying BMC settings") - if ok, err := r.handleBMCReset(ctx, log, bmcSetting, BMC, BMCResetPostSettingApplyCondition); !ok || err != nil { + if ok, err := r.handleBMCReset(ctx, bmcSetting, BMC, BMCResetPostSettingApplyCondition); !ok || err != nil { return ctrl.Result{}, err } } // verify setting already applied - settingsDiff, err = r.getBMCSettingsDifference(ctx, log, bmcSetting, BMC, bmcClient) + settingsDiff, err = r.getBMCSettingsDifference(ctx, bmcSetting, BMC, bmcClient) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to get BMC settings: %w", err) @@ -451,7 +450,7 @@ func (r *BMCSettingsReconciler) updateSettingsAndVerify( // if setting is not different, complete the BMC settings tasks if len(settingsDiff) == 0 { // move bmcSetting state to completed, and revert the settingUpdate state to initial - err := r.updateBMCSettingsStatus(ctx, log, bmcSetting, metalv1alpha1.BMCSettingsStateApplied, nil) + err := r.updateBMCSettingsStatus(ctx, bmcSetting, metalv1alpha1.BMCSettingsStateApplied, nil) return ctrl.Result{}, err } return ctrl.Result{RequeueAfter: r.ResyncInterval}, nil @@ -459,24 +458,24 @@ func (r *BMCSettingsReconciler) updateSettingsAndVerify( func (r *BMCSettingsReconciler) handleSettingAppliedState( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, bmcClient bmc.BMC, ) error { + log := ctrl.LoggerFrom(ctx) // clean up maintenance crd and references. - if err := r.cleanupServerMaintenanceReferences(ctx, log, bmcSetting); err != nil { + if err := r.cleanupServerMaintenanceReferences(ctx, bmcSetting); err != nil { return err } - settingsDiff, err := r.getBMCSettingsDifference(ctx, log, bmcSetting, BMC, bmcClient) + settingsDiff, err := r.getBMCSettingsDifference(ctx, bmcSetting, BMC, bmcClient) if err != nil { - log.V(1).Error(err, "unable to fetch and check BMCSettings") + log.Error(err, "unable to fetch and check BMCSettings") return err } if len(settingsDiff) > 0 { - err := r.updateBMCSettingsStatus(ctx, log, bmcSetting, "", nil) + err := r.updateBMCSettingsStatus(ctx, bmcSetting, "", nil) return err } @@ -486,11 +485,11 @@ func (r *BMCSettingsReconciler) handleSettingAppliedState( func (r *BMCSettingsReconciler) handleBMCReset( ctx context.Context, - log logr.Logger, bmcSettings *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, conditionType string, ) (bool, error) { + log := ctrl.LoggerFrom(ctx) // reset BMC if not already done resetBMC, err := GetCondition(r.Conditions, bmcSettings.Status.Conditions, conditionType) if err != nil { @@ -513,7 +512,7 @@ func (r *BMCSettingsReconciler) handleBMCReset( return false, fmt.Errorf("failed to update reset BMC condition: %w", err) } // patch condition to reset issued - return false, r.updateBMCSettingsStatus(ctx, log, bmcSettings, bmcSettings.Status.State, resetBMC) + return false, r.updateBMCSettingsStatus(ctx, bmcSettings, bmcSettings.Status.State, resetBMC) } else { return false, fmt.Errorf("unknown annotation on BMC object for operation annotation %v", op) } @@ -540,7 +539,7 @@ func (r *BMCSettingsReconciler) handleBMCReset( return false, fmt.Errorf("failed to update reset BMC condition: %w", err) } // patch condition to reset issued - return false, r.updateBMCSettingsStatus(ctx, log, bmcSettings, bmcSettings.Status.State, resetBMC) + return false, r.updateBMCSettingsStatus(ctx, bmcSettings, bmcSettings.Status.State, resetBMC) } // we need to wait until the BMC resource annotation is removed @@ -561,17 +560,17 @@ func (r *BMCSettingsReconciler) handleBMCReset( ); err != nil { return false, fmt.Errorf("failed to update power on server condition: %w", err) } - return false, r.updateBMCSettingsStatus(ctx, log, bmcSettings, bmcSettings.Status.State, resetBMC) + return false, r.updateBMCSettingsStatus(ctx, bmcSettings, bmcSettings.Status.State, resetBMC) } return true, nil } func (r *BMCSettingsReconciler) handleFailedState( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, ) error { + log := ctrl.LoggerFrom(ctx) if shouldRetryReconciliation(bmcSetting) { log.V(1).Info("Retrying BMCSettings reconciliation") bmcSettingsBase := bmcSetting.DeepCopy() @@ -591,11 +590,11 @@ func (r *BMCSettingsReconciler) handleFailedState( func (r *BMCSettingsReconciler) getBMCSettingsDifference( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, BMC *metalv1alpha1.BMC, bmcClient bmc.BMC, ) (diff redfish.SettingsAttributes, err error) { + log := ctrl.LoggerFrom(ctx) currentSettings, err := bmcClient.GetBMCAttributeValues(ctx, BMC.Spec.BMCUUID, bmcSetting.Spec.SettingsMap) if err != nil { return diff, fmt.Errorf("failed to get BMC settings: %w", err) @@ -612,7 +611,7 @@ func (r *BMCSettingsReconciler) getBMCSettingsDifference( case int: intvalue, err := strconv.Atoi(value) if err != nil { - log.V(1).Error(err, "failed to check type for", "Setting name", key, "setting value", value) + log.Error(err, "failed to check type for", "Setting name", key, "setting value", value) errs = append(errs, fmt.Errorf("failed to check type for name %v; value %v; error: %v", key, value, err)) continue } @@ -626,7 +625,7 @@ func (r *BMCSettingsReconciler) getBMCSettingsDifference( case float64: floatvalue, err := strconv.ParseFloat(value, 64) if err != nil { - log.V(1).Error(err, "failed to check type for", "Setting name", key, "Setting value", value) + log.Error(err, "failed to check type for", "Setting name", key, "Setting value", value) errs = append(errs, fmt.Errorf("failed to check type for name %v; value %v; error: %v", key, value, err)) } if data != floatvalue { @@ -647,17 +646,17 @@ func (r *BMCSettingsReconciler) getBMCSettingsDifference( func (r *BMCSettingsReconciler) checkIfMaintenanceGranted( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, bmcClient bmc.BMC, ) bool { + log := ctrl.LoggerFrom(ctx) if bmcSetting.Spec.ServerMaintenanceRefs == nil { return false } - servers, err := r.getServers(ctx, log, bmcSetting, bmcClient) + servers, err := r.getServers(ctx, bmcSetting, bmcClient) if err != nil { - log.V(1).Error(err, "Failed to get ref. servers to determine maintenance state ") + log.Error(err, "Failed to get ref. servers to determine maintenance state ") return false } @@ -701,14 +700,14 @@ func (r *BMCSettingsReconciler) checkIfMaintenanceGranted( func (r *BMCSettingsReconciler) requestMaintenanceOnServers( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, bmcClient bmc.BMC, ) (bool, error) { + log := ctrl.LoggerFrom(ctx) - servers, err := r.getServers(ctx, log, bmcSetting, bmcClient) + servers, err := r.getServers(ctx, bmcSetting, bmcClient) if err != nil { - log.V(1).Error(err, "Failed to get ref. servers to request maintenance on servers") + log.Error(err, "Failed to get ref. servers to request maintenance on servers") return false, err } @@ -724,7 +723,7 @@ func (r *BMCSettingsReconciler) requestMaintenanceOnServers( serverWithMaintenances := make(map[string]bool, len(servers)) if bmcSetting.Spec.ServerMaintenanceRefs != nil { // we fetch all the references already in the Spec (self created/provided by user) - serverMaintenances, err := r.getReferredServerMaintenances(ctx, log, bmcSetting.Spec.ServerMaintenanceRefs) + serverMaintenances, err := r.getReferredServerMaintenances(ctx, bmcSetting.Spec.ServerMaintenanceRefs) if err != nil { return false, errors.Join(err...) } @@ -766,7 +765,7 @@ func (r *BMCSettingsReconciler) requestMaintenanceOnServers( return controllerutil.SetControllerReference(bmcSetting, serverMaintenance, r.Client.Scheme()) }) if err != nil { - log.V(1).Error(err, "failed to create or patch serverMaintenance", "Server", server.Name) + log.Error(err, "failed to create or patch serverMaintenance", "Server", server.Name) errs = append(errs, err) continue } @@ -788,7 +787,7 @@ func (r *BMCSettingsReconciler) requestMaintenanceOnServers( return false, errors.Join(errs...) } - err = r.patchMaintenanceRequestRefOnBMCSettings(ctx, log, bmcSetting, ServerMaintenanceRefs) + err = r.patchMaintenanceRequestRefOnBMCSettings(ctx, bmcSetting, ServerMaintenanceRefs) if err != nil { return false, fmt.Errorf("failed to patch serverMaintenance ref in bmcSetting status: %w", err) } @@ -800,9 +799,9 @@ func (r *BMCSettingsReconciler) requestMaintenanceOnServers( func (r *BMCSettingsReconciler) getBMC( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, ) (*metalv1alpha1.BMC, error) { + log := ctrl.LoggerFrom(ctx) var refName string if bmcSetting.Spec.BMCRef == nil { @@ -814,7 +813,7 @@ func (r *BMCSettingsReconciler) getBMC( key := client.ObjectKey{Name: refName} BMC := &metalv1alpha1.BMC{} if err := r.Get(ctx, key, BMC); err != nil { - log.V(1).Error(err, "failed to get referred server's Manager") + log.Error(err, "failed to get referred server's Manager") return BMC, err } @@ -823,17 +822,17 @@ func (r *BMCSettingsReconciler) getBMC( func (r *BMCSettingsReconciler) getServers( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, bmcClient bmc.BMC, ) ([]*metalv1alpha1.Server, error) { + log := ctrl.LoggerFrom(ctx) if bmcSetting.Spec.BMCRef == nil { return nil, fmt.Errorf("BMC reference not found") } - BMC, err := r.getBMC(ctx, log, bmcSetting) + BMC, err := r.getBMC(ctx, bmcSetting) if err != nil { - log.V(1).Error(err, "failed to get referred BMC") + log.Error(err, "failed to get referred BMC") return nil, err } bmcServers, err := bmcClient.GetSystems(ctx) @@ -844,7 +843,7 @@ func (r *BMCSettingsReconciler) getServers( for i := range bmcServers { serversRefList[i] = &corev1.LocalObjectReference{Name: bmcutils.GetServerNameFromBMCandIndex(i, BMC)} } - servers, err := r.getReferredServers(ctx, log, serversRefList) + servers, err := r.getReferredServers(ctx, serversRefList) if err != nil { return servers, fmt.Errorf("errors occurred during fetching servers from BMC: %v", err) } @@ -853,16 +852,16 @@ func (r *BMCSettingsReconciler) getServers( func (r *BMCSettingsReconciler) getReferredServers( ctx context.Context, - log logr.Logger, serverRefList []*corev1.LocalObjectReference, ) ([]*metalv1alpha1.Server, error) { + log := ctrl.LoggerFrom(ctx) var errs []error servers := make([]*metalv1alpha1.Server, len(serverRefList)) for idx, serverRef := range serverRefList { key := client.ObjectKey{Name: serverRef.Name} server := &metalv1alpha1.Server{} if err := r.Get(ctx, key, server); err != nil { - log.V(1).Error(err, "failed to get referred server", "reference", serverRef.Name) + log.Error(err, "failed to get referred server", "reference", serverRef.Name) errs = append(errs, err) continue } @@ -874,10 +873,9 @@ func (r *BMCSettingsReconciler) getReferredServers( func (r *BMCSettingsReconciler) getReferredServerMaintenances( ctx context.Context, - log logr.Logger, ServerMaintenanceRefs []metalv1alpha1.ServerMaintenanceRefItem, ) ([]*metalv1alpha1.ServerMaintenance, []error) { - + log := ctrl.LoggerFrom(ctx) serverMaintenances := make([]*metalv1alpha1.ServerMaintenance, 0, len(ServerMaintenanceRefs)) var errs []error cnt := 0 @@ -885,7 +883,7 @@ func (r *BMCSettingsReconciler) getReferredServerMaintenances( key := client.ObjectKey{Name: serverMaintenanceRef.ServerMaintenanceRef.Name, Namespace: r.ManagerNamespace} serverMaintenance := &metalv1alpha1.ServerMaintenance{} if err := r.Get(ctx, key, serverMaintenance); err != nil { - log.V(1).Error(err, "failed to get referred serverMaintenance obj", serverMaintenanceRef.ServerMaintenanceRef.Name) + log.Error(err, "failed to get referred serverMaintenance obj", "ServerMaintenance", serverMaintenanceRef.ServerMaintenanceRef.Name) errs = append(errs, err) continue } @@ -902,13 +900,13 @@ func (r *BMCSettingsReconciler) getReferredServerMaintenances( func (r *BMCSettingsReconciler) getReferredBMCSettings( ctx context.Context, - log logr.Logger, referredBMCSettingsRef *corev1.LocalObjectReference, ) (*metalv1alpha1.BMCSettings, error) { + log := ctrl.LoggerFrom(ctx) key := client.ObjectKey{Name: referredBMCSettingsRef.Name, Namespace: metav1.NamespaceNone} bmcSetting := &metalv1alpha1.BMCSettings{} if err := r.Get(ctx, key, bmcSetting); err != nil { - log.V(1).Error(err, "failed to get referred bmcSetting") + log.Error(err, "failed to get referred bmcSetting") return bmcSetting, err } return bmcSetting, nil @@ -928,10 +926,10 @@ func (r *BMCSettingsReconciler) getServerMaintenanceRefForServer( func (r *BMCSettingsReconciler) patchBMCSettingsRefOnBMC( ctx context.Context, - log logr.Logger, BMC *metalv1alpha1.BMC, BMCSettingsReference *corev1.LocalObjectReference, ) error { + log := ctrl.LoggerFrom(ctx) if BMC.Spec.BMCSettingRef == BMCSettingsReference { return nil } @@ -940,7 +938,7 @@ func (r *BMCSettingsReconciler) patchBMCSettingsRefOnBMC( BMCBase := BMC.DeepCopy() BMC.Spec.BMCSettingRef = BMCSettingsReference if err = r.Patch(ctx, BMC, client.MergeFrom(BMCBase)); err != nil { - log.V(1).Error(err, "failed to patch BMC settings ref") + log.Error(err, "failed to patch BMC settings ref") return err } return err @@ -948,10 +946,10 @@ func (r *BMCSettingsReconciler) patchBMCSettingsRefOnBMC( func (r *BMCSettingsReconciler) patchMaintenanceRequestRefOnBMCSettings( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, ServerMaintenanceRefs []metalv1alpha1.ServerMaintenanceRefItem, ) error { + log := ctrl.LoggerFrom(ctx) BMCSettingsBase := bmcSetting.DeepCopy() if ServerMaintenanceRefs == nil { @@ -961,7 +959,7 @@ func (r *BMCSettingsReconciler) patchMaintenanceRequestRefOnBMCSettings( } if err := r.Patch(ctx, bmcSetting, client.MergeFrom(BMCSettingsBase)); err != nil { - log.V(1).Error(err, "failed to patch BMCSettings ref") + log.Error(err, "failed to patch BMCSettings ref") return err } @@ -970,11 +968,11 @@ func (r *BMCSettingsReconciler) patchMaintenanceRequestRefOnBMCSettings( func (r *BMCSettingsReconciler) updateBMCSettingsStatus( ctx context.Context, - log logr.Logger, bmcSetting *metalv1alpha1.BMCSettings, state metalv1alpha1.BMCSettingsState, condition *metav1.Condition, ) error { + log := ctrl.LoggerFrom(ctx) if bmcSetting.Status.State == state && condition == nil { return nil diff --git a/internal/controller/bmcsettingsset_controller.go b/internal/controller/bmcsettingsset_controller.go index 74b31dc0..4758a16f 100644 --- a/internal/controller/bmcsettingsset_controller.go +++ b/internal/controller/bmcsettingsset_controller.go @@ -8,7 +8,6 @@ import ( "errors" "fmt" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" corev1 "k8s.io/api/core/v1" @@ -40,34 +39,34 @@ const BMCSettingsSetFinalizer = "metal.ironcore.dev/bmcsettingsset" // +kubebuilder:rbac:groups=metal.ironcore.dev,resources=servermaintenances,verbs=get;list;watch func (r *BMCSettingsSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) bmcSettingsSet := &metalv1alpha1.BMCSettingsSet{} if err := r.Get(ctx, req.NamespacedName, bmcSettingsSet); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling bmcSettingsSet") - return r.reconcileExist(ctx, log, bmcSettingsSet) + return r.reconcileExist(ctx, bmcSettingsSet) } func (r *BMCSettingsSetReconciler) reconcileExist( ctx context.Context, - log logr.Logger, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if !bmcSettingsSet.DeletionTimestamp.IsZero() { log.V(1).Info("Object is being deleted") - return r.delete(ctx, log, bmcSettingsSet) + return r.delete(ctx, bmcSettingsSet) } log.V(1).Info("Object exists and is not being deleted") - return r.reconcile(ctx, log, bmcSettingsSet) + return r.reconcile(ctx, bmcSettingsSet) } func (r *BMCSettingsSetReconciler) reconcile( ctx context.Context, - log logr.Logger, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if shouldIgnoreReconciliation(bmcSettingsSet) { log.V(1).Info("Skipped BMCSettingsSet reconciliation") return ctrl.Result{}, nil @@ -81,14 +80,14 @@ func (r *BMCSettingsSetReconciler) reconcile( return ctrl.Result{}, fmt.Errorf("failed to get BMCs through bmclabel selector %w", err) } - return r.handleBMCSettings(ctx, log, bmcList, bmcSettingsSet) + return r.handleBMCSettings(ctx, bmcList, bmcSettingsSet) } func (r *BMCSettingsSetReconciler) delete( ctx context.Context, - log logr.Logger, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if !controllerutil.ContainsFinalizer(bmcSettingsSet, BMCSettingsSetFinalizer) { return ctrl.Result{}, nil } @@ -108,7 +107,7 @@ func (r *BMCSettingsSetReconciler) delete( } if len(ownedBMCSettings.Items) != len(delTableBMCSettings) || int32(len(ownedBMCSettings.Items)) != bmcSettingsSet.Status.AvailableBMCSettings { currentStatus := r.getOwnedBMCSettingsSetStatus(ownedBMCSettings) - err = r.updateStatus(ctx, log, currentStatus, bmcSettingsSet) + err = r.updateStatus(ctx, currentStatus, bmcSettingsSet) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to update current BMCSettingsSet Status %w", err) } @@ -159,10 +158,10 @@ func (r *BMCSettingsSetReconciler) getOwnedBMCSettingsSetStatus( func (r *BMCSettingsSetReconciler) updateStatus( ctx context.Context, - log logr.Logger, currentStatus *metalv1alpha1.BMCSettingsSetStatus, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, ) error { + log := ctrl.LoggerFrom(ctx) bmcSettingsSetBase := bmcSettingsSet.DeepCopy() bmcSettingsSet.Status = *currentStatus if err := r.Status().Patch(ctx, bmcSettingsSet, client.MergeFrom(bmcSettingsSetBase)); err != nil { @@ -191,33 +190,33 @@ func (r *BMCSettingsSetReconciler) getBMCsBySelector( func (r *BMCSettingsSetReconciler) handleBMCSettings( ctx context.Context, - log logr.Logger, bmcList *metalv1alpha1.BMCList, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) ownedBMCSettings, err := r.getOwnedBMCSettings(ctx, bmcSettingsSet) if err != nil { return ctrl.Result{}, err } - if err := r.createMissingBMCSettings(ctx, log, bmcList, ownedBMCSettings, bmcSettingsSet); err != nil { + if err := r.createMissingBMCSettings(ctx, bmcList, ownedBMCSettings, bmcSettingsSet); err != nil { return ctrl.Result{}, fmt.Errorf("failed to create missing BMCSettings resources %w", err) } log.V(1).Info("Summary of BMCs and BMCSettings", "BMC count", len(bmcList.Items), "BMCSettings count", len(ownedBMCSettings.Items)) - if err := r.deleteOrphanedBMCSettings(ctx, log, bmcList, ownedBMCSettings); err != nil { + if err := r.deleteOrphanedBMCSettings(ctx, bmcList, ownedBMCSettings); err != nil { return ctrl.Result{}, fmt.Errorf("failed to delete orphaned BMCSettings resource %w", err) } - if err := r.patchBMCSettingsFromTemplate(ctx, log, bmcSettingsSet, ownedBMCSettings); err != nil { + if err := r.patchBMCSettingsFromTemplate(ctx, bmcSettingsSet, ownedBMCSettings); err != nil { return ctrl.Result{}, fmt.Errorf("failed to patch BMCSettings from template %w", err) } log.V(1).Info("Updating BMCSettingsSet status") currentStatus := r.getOwnedBMCSettingsSetStatus(ownedBMCSettings) currentStatus.FullyLabeledBMCs = int32(len(bmcList.Items)) - if err := r.updateStatus(ctx, log, currentStatus, bmcSettingsSet); err != nil { + if err := r.updateStatus(ctx, currentStatus, bmcSettingsSet); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update current BMCSettingsSet Status %w", err) } @@ -226,11 +225,11 @@ func (r *BMCSettingsSetReconciler) handleBMCSettings( func (r *BMCSettingsSetReconciler) createMissingBMCSettings( ctx context.Context, - log logr.Logger, bmcList *metalv1alpha1.BMCList, bmcSettingsList *metalv1alpha1.BMCSettingsList, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, ) error { + log := ctrl.LoggerFrom(ctx) bmcWithSettings := make(map[string]struct{}) for _, bmcSettings := range bmcSettingsList.Items { bmcWithSettings[bmcSettings.Spec.BMCRef.Name] = struct{}{} @@ -282,10 +281,10 @@ func (r *BMCSettingsSetReconciler) createMissingBMCSettings( func (r *BMCSettingsSetReconciler) deleteOrphanedBMCSettings( ctx context.Context, - log logr.Logger, bmcList *metalv1alpha1.BMCList, bmcSettingsList *metalv1alpha1.BMCSettingsList, ) error { + log := ctrl.LoggerFrom(ctx) bmcMap := make(map[string]struct{}) for _, bmc := range bmcList.Items { bmcMap[bmc.Name] = struct{}{} @@ -310,10 +309,10 @@ func (r *BMCSettingsSetReconciler) deleteOrphanedBMCSettings( func (r *BMCSettingsSetReconciler) patchBMCSettingsFromTemplate( ctx context.Context, - log logr.Logger, bmcSettingsSet *metalv1alpha1.BMCSettingsSet, bmcSettingsList *metalv1alpha1.BMCSettingsList, ) error { + log := ctrl.LoggerFrom(ctx) if len(bmcSettingsList.Items) == 0 { log.V(1).Info("No BMCSettings found, skipping spec template update") return nil diff --git a/internal/controller/bmcuser_controller.go b/internal/controller/bmcuser_controller.go index 19cadaeb..2f9424f5 100644 --- a/internal/controller/bmcuser_controller.go +++ b/internal/controller/bmcuser_controller.go @@ -17,7 +17,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" "github.com/ironcore-dev/metal-operator/bmc" @@ -44,22 +43,22 @@ type BMCUserReconciler struct { // Reconcile reconciles a BMCUser object func (r *BMCUserReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) user := &metalv1alpha1.BMCUser{} if err := r.Get(ctx, req.NamespacedName, user); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, user) + return r.reconcileExists(ctx, user) } -func (r *BMCUserReconciler) reconcileExists(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser) (ctrl.Result, error) { +func (r *BMCUserReconciler) reconcileExists(ctx context.Context, user *metalv1alpha1.BMCUser) (ctrl.Result, error) { if !user.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, user) + return r.delete(ctx, user) } - return r.reconcile(ctx, log, user) + return r.reconcile(ctx, user) } -func (r *BMCUserReconciler) reconcile(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser) (ctrl.Result, error) { +func (r *BMCUserReconciler) reconcile(ctx context.Context, user *metalv1alpha1.BMCUser) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if user.Spec.BMCRef == nil { log.Info("No BMC reference set for User, skipping reconciliation") return ctrl.Result{}, nil @@ -68,7 +67,7 @@ func (r *BMCUserReconciler) reconcile(ctx context.Context, log logr.Logger, user if err := r.Get(ctx, client.ObjectKey{Name: user.Spec.BMCRef.Name}, bmcObj); err != nil { return ctrl.Result{}, err } - if err := r.updateEffectiveSecret(ctx, log, user, bmcObj); err != nil { + if err := r.updateEffectiveSecret(ctx, user, bmcObj); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update effective BMCSecret: %w", err) } if modified, err := clientutils.PatchEnsureFinalizer(ctx, r.Client, user, BMCUserFinalizer); err != nil || modified { @@ -79,13 +78,13 @@ func (r *BMCUserReconciler) reconcile(ctx context.Context, log logr.Logger, user return ctrl.Result{}, fmt.Errorf("failed to get BMC client: %w", err) } defer bmcClient.Logout() - if err = r.patchUserStatus(ctx, log, user, bmcClient); err != nil { + if err = r.patchUserStatus(ctx, user, bmcClient); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update User status: %w", err) } if user.Spec.BMCSecretRef == nil { log.Info("No BMCSecret reference set for User, creating a new one") - if err := r.ensureBMCSecretForUser(ctx, log, bmcClient, user, bmcObj); err != nil { + if err := r.ensureBMCSecretForUser(ctx, bmcClient, user, bmcObj); err != nil { return ctrl.Result{}, fmt.Errorf("failed to handle missing BMCSecret reference: %w", err) } } @@ -103,20 +102,21 @@ func (r *BMCUserReconciler) reconcile(ctx context.Context, log logr.Logger, user if err = bmcClient.CreateOrUpdateAccount(ctx, user.Spec.UserName, user.Spec.RoleID, password, true); err != nil { return ctrl.Result{}, fmt.Errorf("failed to create or update BMC account with new password: %w", err) } - if err = r.patchUserStatus(ctx, log, user, bmcClient); err != nil { + if err = r.patchUserStatus(ctx, user, bmcClient); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update User status after creating BMC account: %w", err) } } if user.Status.EffectiveBMCSecretRef != nil && user.Spec.BMCSecretRef.Name != user.Status.EffectiveBMCSecretRef.Name { log.Info("BMCSecret reference has changed, updating BMC account") - if err := r.handleUpdatedSecretRef(ctx, log, user, bmcSecret, bmcClient); err != nil { + if err := r.handleUpdatedSecretRef(ctx, user, bmcSecret, bmcClient); err != nil { return ctrl.Result{}, fmt.Errorf("failed to handle updated BMCSecret reference: %w", err) } } - return r.handleRotatingPassword(ctx, log, user, bmcObj, bmcClient) + return r.handleRotatingPassword(ctx, user, bmcObj, bmcClient) } -func (r *BMCUserReconciler) patchUserStatus(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, bmcClient bmc.BMC) error { +func (r *BMCUserReconciler) patchUserStatus(ctx context.Context, user *metalv1alpha1.BMCUser, bmcClient bmc.BMC) error { + log := ctrl.LoggerFrom(ctx) accounts, err := bmcClient.GetAccounts() if err != nil { return fmt.Errorf("failed to get BMC accounts: %w", err) @@ -142,7 +142,8 @@ func (r *BMCUserReconciler) patchUserStatus(ctx context.Context, log logr.Logger return nil } -func (r *BMCUserReconciler) handleRotatingPassword(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, bmcObj *metalv1alpha1.BMC, bmcClient bmc.BMC) (ctrl.Result, error) { +func (r *BMCUserReconciler) handleRotatingPassword(ctx context.Context, user *metalv1alpha1.BMCUser, bmcObj *metalv1alpha1.BMC, bmcClient bmc.BMC) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) forceRotation := false if user.GetAnnotations() != nil && user.GetAnnotations()[metalv1alpha1.OperationAnnotation] == metalv1alpha1.OperationAnnotationRotateCredentials { log.Info("User has rotation annotation set, triggering password rotation") @@ -180,11 +181,11 @@ func (r *BMCUserReconciler) handleRotatingPassword(ctx context.Context, log logr if err != nil { return ctrl.Result{}, fmt.Errorf("failed to generate new password for BMC user %s: %w", user.Name, err) } - secret, err := r.createBMCSecretForUser(ctx, log, user, newPassword) + secret, err := r.createBMCSecretForUser(ctx, user, newPassword) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to create BMCSecret: %w", err) } - if err := r.setBMCUserSecretRef(ctx, log, user, secret); err != nil { + if err := r.setBMCUserSecretRef(ctx, user, secret); err != nil { return ctrl.Result{}, fmt.Errorf("failed to set BMCSecret reference for User: %w", err) } if err := bmcClient.CreateOrUpdateAccount(ctx, user.Spec.UserName, user.Spec.RoleID, newPassword, true); err != nil { @@ -200,7 +201,8 @@ func (r *BMCUserReconciler) handleRotatingPassword(ctx context.Context, log logr return ctrl.Result{}, nil } -func (r *BMCUserReconciler) ensureBMCSecretForUser(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, user *metalv1alpha1.BMCUser, bmcObj *metalv1alpha1.BMC) error { +func (r *BMCUserReconciler) ensureBMCSecretForUser(ctx context.Context, bmcClient bmc.BMC, user *metalv1alpha1.BMCUser, bmcObj *metalv1alpha1.BMC) error { + log := ctrl.LoggerFrom(ctx) log.Info("No BMCSecret reference set for User, creating a new one") accountService, err := bmcClient.GetAccountService() if err != nil { @@ -210,11 +212,11 @@ func (r *BMCUserReconciler) ensureBMCSecretForUser(ctx context.Context, log logr if err != nil { return fmt.Errorf("failed to generate new password for BMC account %s: %w", user.Name, err) } - secret, err := r.createBMCSecretForUser(ctx, log, user, newPassword) + secret, err := r.createBMCSecretForUser(ctx, user, newPassword) if err != nil { return fmt.Errorf("failed to create BMCSecret: %w", err) } - if err := r.setBMCUserSecretRef(ctx, log, user, secret); err != nil { + if err := r.setBMCUserSecretRef(ctx, user, secret); err != nil { return fmt.Errorf("failed to set BMCSecret reference for User: %w", err) } log.Info("Creating BMC account with new password", "Account", user.Name) @@ -225,7 +227,8 @@ func (r *BMCUserReconciler) ensureBMCSecretForUser(ctx context.Context, log logr return nil } -func (r *BMCUserReconciler) handleUpdatedSecretRef(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, bmcSecret *metalv1alpha1.BMCSecret, bmcClient bmc.BMC) error { +func (r *BMCUserReconciler) handleUpdatedSecretRef(ctx context.Context, user *metalv1alpha1.BMCUser, bmcSecret *metalv1alpha1.BMCSecret, bmcClient bmc.BMC) error { + log := ctrl.LoggerFrom(ctx) log.Info("BMCSecret credentials have changed, updating BMC user") _, password, err := bmcutils.GetBMCCredentialsFromSecret(bmcSecret) if err != nil { @@ -238,7 +241,8 @@ func (r *BMCUserReconciler) handleUpdatedSecretRef(ctx context.Context, log logr return nil } -func (r *BMCUserReconciler) createBMCSecretForUser(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, password string) (*metalv1alpha1.BMCSecret, error) { +func (r *BMCUserReconciler) createBMCSecretForUser(ctx context.Context, user *metalv1alpha1.BMCUser, password string) (*metalv1alpha1.BMCSecret, error) { + log := ctrl.LoggerFrom(ctx) log.Info("Creating BMCSecret for User") secret := &metalv1alpha1.BMCSecret{ ObjectMeta: metav1.ObjectMeta{ @@ -263,7 +267,8 @@ func (r *BMCUserReconciler) createBMCSecretForUser(ctx context.Context, log logr return secret, nil } -func (r *BMCUserReconciler) setBMCUserSecretRef(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, secret *metalv1alpha1.BMCSecret) error { +func (r *BMCUserReconciler) setBMCUserSecretRef(ctx context.Context, user *metalv1alpha1.BMCUser, secret *metalv1alpha1.BMCSecret) error { + log := ctrl.LoggerFrom(ctx) log.Info("Setting BMCSecret reference for User", "User", user.Name) userBase := user.DeepCopy() user.Spec.BMCSecretRef = &v1.LocalObjectReference{Name: secret.Name} @@ -273,7 +278,8 @@ func (r *BMCUserReconciler) setBMCUserSecretRef(ctx context.Context, log logr.Lo return nil } -func (r *BMCUserReconciler) setEffectiveSecretRef(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, secret *metalv1alpha1.BMCSecret) error { +func (r *BMCUserReconciler) setEffectiveSecretRef(ctx context.Context, user *metalv1alpha1.BMCUser, secret *metalv1alpha1.BMCSecret) error { + log := ctrl.LoggerFrom(ctx) log.Info("Setting effective BMCSecret") userBase := user.DeepCopy() if user.Status.EffectiveBMCSecretRef == nil { @@ -295,7 +301,8 @@ func (r *BMCUserReconciler) getBMCClient(ctx context.Context, bmcObj *metalv1alp return bmcClient, nil } -func (r *BMCUserReconciler) updateEffectiveSecret(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser, bmcObj *metalv1alpha1.BMC) error { +func (r *BMCUserReconciler) updateEffectiveSecret(ctx context.Context, user *metalv1alpha1.BMCUser, bmcObj *metalv1alpha1.BMC) error { + log := ctrl.LoggerFrom(ctx) if user.Spec.BMCSecretRef == nil || user.Status.ID == "" { return nil } @@ -315,7 +322,7 @@ func (r *BMCUserReconciler) updateEffectiveSecret(ctx context.Context, log logr. return nil } if user.Status.EffectiveBMCSecretRef == nil { - if err := r.setEffectiveSecretRef(ctx, log, user, secret); err != nil { + if err := r.setEffectiveSecretRef(ctx, user, secret); err != nil { return fmt.Errorf("failed to update effective BMCSecret: %w", err) } log.Info("Set effective BMCSecret for User") @@ -335,7 +342,7 @@ func (r *BMCUserReconciler) updateEffectiveSecret(ctx context.Context, log logr. } if invalidCredentials { log.Info("Effective BMCSecret is invalid", "EffectiveBMCSecret", effSecret.Name, "NewBMCSecret", secret.Name) - if err := r.setEffectiveSecretRef(ctx, log, user, secret); err != nil { + if err := r.setEffectiveSecretRef(ctx, user, secret); err != nil { return fmt.Errorf("failed to update effective BMCSecret: %w", err) } log.Info("Updated effective BMCSecret for User") @@ -362,7 +369,8 @@ func (r *BMCUserReconciler) bmcConnectionTest(ctx context.Context, secret *metal return false, nil } -func (r *BMCUserReconciler) delete(ctx context.Context, log logr.Logger, user *metalv1alpha1.BMCUser) (ctrl.Result, error) { +func (r *BMCUserReconciler) delete(ctx context.Context, user *metalv1alpha1.BMCUser) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if user.Spec.BMCRef == nil { log.Info("No BMC reference set for User, removing finalizer") if modified, err := clientutils.PatchEnsureNoFinalizer(ctx, r.Client, user, BMCUserFinalizer); err != nil || modified { diff --git a/internal/controller/bmcversion_controller.go b/internal/controller/bmcversion_controller.go index ee011521..5b598e09 100644 --- a/internal/controller/bmcversion_controller.go +++ b/internal/controller/bmcversion_controller.go @@ -9,7 +9,6 @@ import ( "fmt" "time" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/conditionutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" @@ -65,24 +64,25 @@ type BMCVersionReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *BMCVersionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) bmcVersion := &metalv1alpha1.BMCVersion{} if err := r.Get(ctx, req.NamespacedName, bmcVersion); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling BMCVersion") - return r.reconcileExists(ctx, log, bmcVersion) + return r.reconcileExists(ctx, bmcVersion) } -func (r *BMCVersionReconciler) reconcileExists(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { - if r.shouldDelete(log, bmcVersion) { - return r.delete(ctx, log, bmcVersion) +func (r *BMCVersionReconciler) reconcileExists(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { + if r.shouldDelete(ctx, bmcVersion) { + return r.delete(ctx, bmcVersion) } - return r.reconcile(ctx, log, bmcVersion) + return r.reconcile(ctx, bmcVersion) } -func (r *BMCVersionReconciler) shouldDelete(log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) bool { +func (r *BMCVersionReconciler) shouldDelete(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) bool { + log := ctrl.LoggerFrom(ctx) if bmcVersion.DeletionTimestamp.IsZero() { return false } @@ -95,7 +95,8 @@ func (r *BMCVersionReconciler) shouldDelete(log logr.Logger, bmcVersion *metalv1 return true } -func (r *BMCVersionReconciler) delete(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { +func (r *BMCVersionReconciler) delete(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting BMCVersion") if !controllerutil.ContainsFinalizer(bmcVersion, bmcVersionFinalizer) { return ctrl.Result{}, nil @@ -103,7 +104,7 @@ func (r *BMCVersionReconciler) delete(ctx context.Context, log logr.Logger, bmcV if bmcVersion.Status.State == metalv1alpha1.BMCVersionStateInProgress { log.V(1).Info("Skipping delete as version update is in progress") - return r.reconcile(ctx, log, bmcVersion) + return r.reconcile(ctx, bmcVersion) } log.V(1).Info("Ensuring that the finalizer is removed") @@ -115,13 +116,14 @@ func (r *BMCVersionReconciler) delete(ctx context.Context, log logr.Logger, bmcV return ctrl.Result{}, nil } -func (r *BMCVersionReconciler) removeServerMaintenances(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) error { +func (r *BMCVersionReconciler) removeServerMaintenances(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) error { + log := ctrl.LoggerFrom(ctx) if bmcVersion.Spec.ServerMaintenanceRefs == nil { return nil } log.V(1).Info("Removing orphan server Maintenances") - serverMaintenances, errs := r.getServerMaintenances(ctx, log, bmcVersion) + serverMaintenances, errs := r.getServerMaintenances(ctx, bmcVersion) var finalErr []error var missingServerMaintenanceRef []error @@ -163,7 +165,8 @@ func (r *BMCVersionReconciler) removeServerMaintenances(ctx context.Context, log return errors.Join(finalErr...) } -func (r *BMCVersionReconciler) reconcile(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { +func (r *BMCVersionReconciler) reconcile(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if shouldIgnoreReconciliation(bmcVersion) { log.V(1).Info("Skipped BMCVersion reconciliation") return ctrl.Result{}, nil @@ -173,10 +176,11 @@ func (r *BMCVersionReconciler) reconcile(ctx context.Context, log logr.Logger, b return ctrl.Result{}, err } - return r.ensureBMCVersionStateTransition(ctx, log, bmcVersion) + return r.ensureBMCVersionStateTransition(ctx, bmcVersion) } -func (r *BMCVersionReconciler) ensureBMCVersionStateTransition(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { +func (r *BMCVersionReconciler) ensureBMCVersionStateTransition(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) bmcObj, err := r.getBMCFromBMCVersion(ctx, bmcVersion) if err != nil { log.V(1).Info("Referred server object could not be fetched") @@ -189,22 +193,22 @@ func (r *BMCVersionReconciler) ensureBMCVersionStateTransition(ctx context.Conte log.V(1).Info("BMC is not available, skipping", "BMC", bmcObj.Name, "error", err) return ctrl.Result{RequeueAfter: r.ResyncInterval}, nil } - log.V(1).Error(err, "failed to create BMC client", "BMC", bmcObj.Name) + log.Error(err, "failed to create BMC client", "BMC", bmcObj.Name) return ctrl.Result{}, err } defer bmcClient.Logout() switch bmcVersion.Status.State { case "", metalv1alpha1.BMCVersionStatePending: - return ctrl.Result{}, r.removeServerMaintenanceRefAndResetConditions(ctx, log, bmcVersion, bmcClient, bmcObj) + return ctrl.Result{}, r.removeServerMaintenanceRefAndResetConditions(ctx, bmcVersion, bmcClient, bmcObj) case metalv1alpha1.BMCVersionStateInProgress: - servers, err := r.getServersForBMCVersion(ctx, log, bmcClient, bmcVersion) + servers, err := r.getServersForBMCVersion(ctx, bmcClient, bmcVersion) if err != nil { return ctrl.Result{}, err } if len(bmcVersion.Spec.ServerMaintenanceRefs) != len(servers) { - requeue, err := r.requestMaintenanceOnServers(ctx, log, bmcClient, bmcVersion) + requeue, err := r.requestMaintenanceOnServers(ctx, bmcClient, bmcVersion) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to request maintenance on servers: %v", err) } @@ -213,17 +217,17 @@ func (r *BMCVersionReconciler) ensureBMCVersionStateTransition(ctx context.Conte } } - if ok := r.checkIfMaintenanceGranted(ctx, log, bmcClient, bmcVersion); !ok { + if ok := r.checkIfMaintenanceGranted(ctx, bmcClient, bmcVersion); !ok { return ctrl.Result{}, fmt.Errorf("failed to wait for maintenance to be granted") } - if ok, err := r.resetBMC(ctx, log, bmcVersion, bmcObj, BMCConditionReset); !ok || err != nil { + if ok, err := r.resetBMC(ctx, bmcVersion, bmcObj, BMCConditionReset); !ok || err != nil { return ctrl.Result{}, fmt.Errorf("failed to reset bmc %s: %w", client.ObjectKeyFromObject(bmcObj), err) } - return r.handleUpgradeInProgressState(ctx, log, bmcVersion, bmcClient, bmcObj) + return r.handleUpgradeInProgressState(ctx, bmcVersion, bmcClient, bmcObj) case metalv1alpha1.BMCVersionStateCompleted: - return ctrl.Result{}, r.removeServerMaintenanceRefAndResetConditions(ctx, log, bmcVersion, bmcClient, bmcObj) + return ctrl.Result{}, r.removeServerMaintenanceRefAndResetConditions(ctx, bmcVersion, bmcClient, bmcObj) case metalv1alpha1.BMCVersionStateFailed: if shouldRetryReconciliation(bmcVersion) { log.V(1).Info("Retrying BMCVersion reconciliation") @@ -247,11 +251,11 @@ func (r *BMCVersionReconciler) ensureBMCVersionStateTransition(ctx context.Conte func (r *BMCVersionReconciler) handleUpgradeInProgressState( ctx context.Context, - log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion, bmcClient bmc.BMC, BMC *metalv1alpha1.BMC, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) issuedCondition, err := GetCondition(r.Conditions, bmcVersion.Status.Conditions, bmcVersionUpgradeIssued) if err != nil { return ctrl.Result{}, err @@ -268,7 +272,7 @@ func (r *BMCVersionReconciler) handleUpgradeInProgressState( log.V(1).Info("BMC is not powered on. Can not proceed", "BMC", BMC.Name, "PowerState", BMC.Status.PowerState) return ctrl.Result{}, nil } - return ctrl.Result{}, r.issueBMCUpgrade(ctx, log, bmcVersion, bmcClient, BMC, issuedCondition) + return ctrl.Result{}, r.issueBMCUpgrade(ctx, bmcVersion, bmcClient, BMC, issuedCondition) } completedCondition, err := GetCondition(r.Conditions, bmcVersion.Status.Conditions, bmcVersionUpgradeCompleted) @@ -278,10 +282,10 @@ func (r *BMCVersionReconciler) handleUpgradeInProgressState( if completedCondition.Status != metav1.ConditionTrue { log.V(1).Info("Check upgrade task of BMC") - return r.checkBMCUpgradeStatus(ctx, log, bmcVersion, bmcClient, BMC, bmcVersion.Status.UpgradeTask.URI, completedCondition) + return r.checkBMCUpgradeStatus(ctx, bmcVersion, bmcClient, BMC, bmcVersion.Status.UpgradeTask.URI, completedCondition) } - if ok, err := r.resetBMC(ctx, log, bmcVersion, BMC, bmcVersionUpgradeRebootBMC); !ok || err != nil { + if ok, err := r.resetBMC(ctx, bmcVersion, BMC, bmcVersionUpgradeRebootBMC); !ok || err != nil { return ctrl.Result{}, err } @@ -307,7 +311,7 @@ func (r *BMCVersionReconciler) handleUpgradeInProgressState( conditionutils.UpdateReason("VerifyBMCVersionUpdate"), conditionutils.UpdateMessage("waiting for BMC Version update"), ); err != nil { - log.V(1).Error(err, "failed to update the conditions status. retrying...") + log.Error(err, "failed to update the conditions status. retrying...") return ctrl.Result{}, err } } @@ -321,12 +325,11 @@ func (r *BMCVersionReconciler) handleUpgradeInProgressState( conditionutils.UpdateReason(bmcVerifiedVersionUpdateReason), conditionutils.UpdateMessage("BMC Version updated"), ); err != nil { - log.V(1).Error(err, "failed to update the conditions status. retrying...") + log.Error(err, "failed to update the conditions status. retrying...") return ctrl.Result{}, err } err = r.patchBMCVersionStatusAndCondition( ctx, - log, bmcVersion, metalv1alpha1.BMCVersionStateCompleted, bmcVersion.Status.UpgradeTask, @@ -348,15 +351,16 @@ func (r *BMCVersionReconciler) getBMCVersionFromBMC(ctx context.Context, bmcClie return currentBMCVersion, nil } -func (r *BMCVersionReconciler) checkIfMaintenanceGranted(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, bmcVersion *metalv1alpha1.BMCVersion) bool { +func (r *BMCVersionReconciler) checkIfMaintenanceGranted(ctx context.Context, bmcClient bmc.BMC, bmcVersion *metalv1alpha1.BMCVersion) bool { + log := ctrl.LoggerFrom(ctx) // todo length if bmcVersion.Spec.ServerMaintenanceRefs == nil { return true } - servers, err := r.getServersForBMCVersion(ctx, log, bmcClient, bmcVersion) + servers, err := r.getServersForBMCVersion(ctx, bmcClient, bmcVersion) if err != nil { - log.V(1).Error(err, "Failed to get ref. servers to determine maintenance state ") + log.Error(err, "Failed to get ref. servers to determine maintenance state ") return false } @@ -393,28 +397,29 @@ func (r *BMCVersionReconciler) checkIfMaintenanceGranted(ctx context.Context, lo func (r *BMCVersionReconciler) removeServerMaintenanceRefAndResetConditions( ctx context.Context, - log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion, bmcClient bmc.BMC, BMC *metalv1alpha1.BMC, ) error { + log := ctrl.LoggerFrom(ctx) currentBMCVersion, err := r.getBMCVersionFromBMC(ctx, bmcClient, BMC) if err != nil { return err } state := metalv1alpha1.BMCVersionStateInProgress if currentBMCVersion == bmcVersion.Spec.Version { - if err := r.removeServerMaintenances(ctx, log, bmcVersion); err != nil { + if err := r.removeServerMaintenances(ctx, bmcVersion); err != nil { return err } log.V(1).Info("Upgraded BMC version", "BMCVersion", currentBMCVersion, "BMC", BMC.Name) state = metalv1alpha1.BMCVersionStateCompleted } - err = r.patchBMCVersionStatusAndCondition(ctx, log, bmcVersion, state, nil, nil) + err = r.patchBMCVersionStatusAndCondition(ctx, bmcVersion, state, nil, nil) return err } -func (r *BMCVersionReconciler) getServerMaintenances(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion) ([]*metalv1alpha1.ServerMaintenance, []error) { +func (r *BMCVersionReconciler) getServerMaintenances(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion) ([]*metalv1alpha1.ServerMaintenance, []error) { + log := ctrl.LoggerFrom(ctx) refs := bmcVersion.Spec.ServerMaintenanceRefs maintenances := make([]*metalv1alpha1.ServerMaintenance, 0, len(refs)) var errs []error @@ -422,7 +427,7 @@ func (r *BMCVersionReconciler) getServerMaintenances(ctx context.Context, log lo key := client.ObjectKey{Name: ref.Name, Namespace: r.ManagerNamespace} serverMaintenance := &metalv1alpha1.ServerMaintenance{} if err := r.Get(ctx, key, serverMaintenance); err != nil { - log.V(1).Error(err, "failed to get referred serverMaintenance obj", "ServerMaintenance", ref.Name) + log.Error(err, "failed to get referred serverMaintenance obj", "ServerMaintenance", ref.Name) errs = append(errs, err) continue } @@ -436,7 +441,8 @@ func (r *BMCVersionReconciler) getServerMaintenances(ctx context.Context, log lo return maintenances, nil } -func (r *BMCVersionReconciler) resetBMC(ctx context.Context, log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion, bmcObj *metalv1alpha1.BMC, conditionType string) (bool, error) { +func (r *BMCVersionReconciler) resetBMC(ctx context.Context, bmcVersion *metalv1alpha1.BMCVersion, bmcObj *metalv1alpha1.BMC, conditionType string) (bool, error) { + log := ctrl.LoggerFrom(ctx) // reset BMC if not already done condition, err := GetCondition(r.Conditions, bmcVersion.Status.Conditions, conditionType) if err != nil { @@ -461,7 +467,7 @@ func (r *BMCVersionReconciler) resetBMC(ctx context.Context, log logr.Logger, bm return false, fmt.Errorf("failed to update reset BMC condition: %w", err) } // patch condition to reset issued - return false, r.patchBMCVersionStatusAndCondition(ctx, log, bmcVersion, bmcVersion.Status.State, nil, condition) + return false, r.patchBMCVersionStatusAndCondition(ctx, bmcVersion, bmcVersion.Status.State, nil, condition) } else { return false, fmt.Errorf("unknown annotation on BMC object for operation annotation %v", op) } @@ -488,7 +494,7 @@ func (r *BMCVersionReconciler) resetBMC(ctx context.Context, log logr.Logger, bm return false, fmt.Errorf("failed to update reset BMC condition: %w", err) } // patch condition to reset issued - return false, r.patchBMCVersionStatusAndCondition(ctx, log, bmcVersion, bmcVersion.Status.State, nil, condition) + return false, r.patchBMCVersionStatusAndCondition(ctx, bmcVersion, bmcVersion.Status.State, nil, condition) } // we need to wait until the BMC resource annotation is removed @@ -509,23 +515,23 @@ func (r *BMCVersionReconciler) resetBMC(ctx context.Context, log logr.Logger, bm ); err != nil { return false, fmt.Errorf("failed to update power on server condition: %w", err) } - return false, r.patchBMCVersionStatusAndCondition(ctx, log, bmcVersion, bmcVersion.Status.State, nil, condition) + return false, r.patchBMCVersionStatusAndCondition(ctx, bmcVersion, bmcVersion.Status.State, nil, condition) } return true, nil } func (r *BMCVersionReconciler) getServersForBMCVersion( ctx context.Context, - log logr.Logger, bmcClient bmc.BMC, bmcVersion *metalv1alpha1.BMCVersion, ) ([]*metalv1alpha1.Server, error) { + log := ctrl.LoggerFrom(ctx) if bmcVersion.Spec.BMCRef == nil { return nil, fmt.Errorf("BMC reference not found") } bmcObj, err := r.getBMCFromBMCVersion(ctx, bmcVersion) if err != nil { - log.V(1).Error(err, "failed to get referred BMC") + log.Error(err, "failed to get referred BMC") return nil, err } bmcServers, err := bmcClient.GetSystems(ctx) @@ -536,21 +542,22 @@ func (r *BMCVersionReconciler) getServersForBMCVersion( for i := range bmcServers { serversRefList[i] = &corev1.LocalObjectReference{Name: bmcutils.GetServerNameFromBMCandIndex(i, bmcObj)} } - servers, err := r.getServersForRefs(ctx, log, serversRefList) + servers, err := r.getServersForRefs(ctx, serversRefList) if err != nil { return servers, fmt.Errorf("errors occurred during fetching servers from BMC: %v", err) } return servers, nil } -func (r *BMCVersionReconciler) getServersForRefs(ctx context.Context, log logr.Logger, serverRefList []*corev1.LocalObjectReference) ([]*metalv1alpha1.Server, error) { +func (r *BMCVersionReconciler) getServersForRefs(ctx context.Context, serverRefList []*corev1.LocalObjectReference) ([]*metalv1alpha1.Server, error) { + log := ctrl.LoggerFrom(ctx) var errs []error servers := make([]*metalv1alpha1.Server, len(serverRefList)) for idx, serverRef := range serverRefList { key := client.ObjectKey{Name: serverRef.Name} server := &metalv1alpha1.Server{} if err := r.Get(ctx, key, server); err != nil { - log.V(1).Error(err, "failed to get referred server", "reference", serverRef.Name) + log.Error(err, "failed to get referred server", "reference", serverRef.Name) errs = append(errs, err) continue } @@ -583,12 +590,12 @@ func (r *BMCVersionReconciler) getServerMaintenanceRefForServer(serverMaintenanc func (r *BMCVersionReconciler) patchBMCVersionStatusAndCondition( ctx context.Context, - log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion, state metalv1alpha1.BMCVersionState, upgradeTask *metalv1alpha1.Task, condition *metav1.Condition, ) error { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Patching BMCVersion status") if bmcVersion.Status.State == state && condition == nil && upgradeTask == nil { return nil @@ -641,10 +648,11 @@ func (r *BMCVersionReconciler) patchMaintenanceRequestRefOnBMCVersion( return nil } -func (r *BMCVersionReconciler) requestMaintenanceOnServers(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, bmcVersion *metalv1alpha1.BMCVersion) (bool, error) { - servers, err := r.getServersForBMCVersion(ctx, log, bmcClient, bmcVersion) +func (r *BMCVersionReconciler) requestMaintenanceOnServers(ctx context.Context, bmcClient bmc.BMC, bmcVersion *metalv1alpha1.BMCVersion) (bool, error) { + log := ctrl.LoggerFrom(ctx) + servers, err := r.getServersForBMCVersion(ctx, bmcClient, bmcVersion) if err != nil { - log.V(1).Error(err, "Failed to get ref. servers to request maintenance on servers") + log.Error(err, "Failed to get ref. servers to request maintenance on servers") return false, err } @@ -657,7 +665,7 @@ func (r *BMCVersionReconciler) requestMaintenanceOnServers(ctx context.Context, serverWithMaintenances := make(map[string]bool, len(servers)) if bmcVersion.Spec.ServerMaintenanceRefs != nil { // We fetch all the references already in the Spec (self created/provided by user) - serverMaintenances, err := r.getServerMaintenances(ctx, log, bmcVersion) + serverMaintenances, err := r.getServerMaintenances(ctx, bmcVersion) if err != nil { return false, errors.Join(err...) } @@ -700,7 +708,7 @@ func (r *BMCVersionReconciler) requestMaintenanceOnServers(ctx context.Context, return controllerutil.SetControllerReference(bmcVersion, serverMaintenance, r.Client.Scheme()) }) if err != nil { - log.V(1).Error(err, "failed to create or patch ServerMaintenance for Server", "ServerMaintenance", client.ObjectKeyFromObject(serverMaintenance), "Server", server.Name) + log.Error(err, "failed to create or patch ServerMaintenance for Server", "ServerMaintenance", client.ObjectKeyFromObject(serverMaintenance), "Server", server.Name) errs = append(errs, err) continue } @@ -732,13 +740,13 @@ func (r *BMCVersionReconciler) requestMaintenanceOnServers(ctx context.Context, func (r *BMCVersionReconciler) checkBMCUpgradeStatus( ctx context.Context, - log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion, bmcClient bmc.BMC, bmcObj *metalv1alpha1.BMC, bmcUpgradeTaskUri string, completedCondition *metav1.Condition, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) taskCurrentStatus, err := func() (*redfish.Task, error) { if bmcUpgradeTaskUri == "" { return nil, fmt.Errorf("invalid task URI. uri provided: '%v'", bmcUpgradeTaskUri) @@ -746,7 +754,7 @@ func (r *BMCVersionReconciler) checkBMCUpgradeStatus( return bmcClient.GetBMCUpgradeTask(ctx, bmcObj.Status.Manufacturer, bmcUpgradeTaskUri) }() if err != nil { - log.V(1).Error(err, "failed to get the task details of BMC upgrade task", "TaskURI", bmcUpgradeTaskUri) + log.Error(err, "failed to get the task details of BMC upgrade task", "TaskURI", bmcUpgradeTaskUri) return ctrl.Result{}, err } log.V(1).Info("BMC upgrade task current status", "TaskStatus", taskCurrentStatus) @@ -784,12 +792,11 @@ func (r *BMCVersionReconciler) checkBMCUpgradeStatus( conditionutils.UpdateReason(bmcUpgradeTaskFailedReason), conditionutils.UpdateMessage(message), ); err != nil { - log.V(1).Error(err, "failed to update the conditions status. reconcile again ") + log.Error(err, "failed to update the conditions status. reconcile again ") return ctrl.Result{}, err } err = r.patchBMCVersionStatusAndCondition( ctx, - log, bmcVersion, metalv1alpha1.BMCVersionStateFailed, upgradeCurrentTaskStatus, @@ -805,12 +812,11 @@ func (r *BMCVersionReconciler) checkBMCUpgradeStatus( conditionutils.UpdateReason(bmcTaskCompletedReason), conditionutils.UpdateMessage("BMC successfully upgraded to: "+bmcVersion.Spec.Version), ); err != nil { - log.V(1).Error(err, "failed to update the conditions status. reconcile again") + log.Error(err, "failed to update the conditions status. reconcile again") return ctrl.Result{}, err } err = r.patchBMCVersionStatusAndCondition( ctx, - log, bmcVersion, bmcVersion.Status.State, upgradeCurrentTaskStatus, @@ -830,7 +836,7 @@ func (r *BMCVersionReconciler) checkBMCUpgradeStatus( taskCurrentStatus.PercentComplete), ), ); err != nil { - log.V(1).Error(err, "failed to update the conditions status. retrying... ") + log.Error(err, "failed to update the conditions status. retrying... ") return ctrl.Result{}, err } ok, err := checkpoint.Transitioned(r.Conditions, *completedCondition) @@ -842,7 +848,6 @@ func (r *BMCVersionReconciler) checkBMCUpgradeStatus( // todo: Fail the state after certain timeout err = r.patchBMCVersionStatusAndCondition( ctx, - log, bmcVersion, bmcVersion.Status.State, upgradeCurrentTaskStatus, @@ -853,12 +858,12 @@ func (r *BMCVersionReconciler) checkBMCUpgradeStatus( func (r *BMCVersionReconciler) issueBMCUpgrade( ctx context.Context, - log logr.Logger, bmcVersion *metalv1alpha1.BMCVersion, bmcClient bmc.BMC, bmcObj *metalv1alpha1.BMC, issuedCondition *metav1.Condition, ) error { + log := ctrl.LoggerFrom(ctx) var username, password string if bmcVersion.Spec.Image.SecretRef != nil { var err error @@ -888,7 +893,7 @@ func (r *BMCVersionReconciler) issueBMCUpgrade( upgradeCurrentTaskStatus := &metalv1alpha1.Task{URI: taskMonitor} if isFatal { - log.V(1).Error(err, "failed to issue bmc upgrade", "requested bmc version", bmcVersion.Spec.Version, "BMC", bmcObj.Name) + log.Error(err, "failed to issue bmc upgrade", "requested bmc version", bmcVersion.Spec.Version, "BMC", bmcObj.Name) var errCond error if errCond = r.Conditions.Update( issuedCondition, @@ -896,11 +901,10 @@ func (r *BMCVersionReconciler) issueBMCUpgrade( conditionutils.UpdateReason(bmcFailedUpgradeIssueReason), conditionutils.UpdateMessage("Fatal error occurred. Upgrade might still go through on server."), ); errCond != nil { - log.V(1).Error(errCond, "failed to update the conditions status") + log.Error(errCond, "failed to update the conditions status") } err := r.patchBMCVersionStatusAndCondition( ctx, - log, bmcVersion, metalv1alpha1.BMCVersionStateFailed, upgradeCurrentTaskStatus, @@ -909,7 +913,7 @@ func (r *BMCVersionReconciler) issueBMCUpgrade( return errors.Join(errCond, err) } if err != nil { - log.V(1).Error(err, "failed to issue bmc upgrade", "bmc version", bmcVersion.Spec.Version, "BMC", bmcObj.Name) + log.Error(err, "failed to issue bmc upgrade", "bmc version", bmcVersion.Spec.Version, "BMC", bmcObj.Name) return err } var errCond error @@ -920,7 +924,7 @@ func (r *BMCVersionReconciler) issueBMCUpgrade( conditionutils.UpdateReason(bmcUpgradeIssuedReason), conditionutils.UpdateMessage(fmt.Sprintf("Task to upgrade has been created %v", taskMonitor)), ); errCond != nil { - log.V(1).Error(errCond, "failed to update the conditions status... retrying") + log.Error(errCond, "failed to update the conditions status... retrying") if errCond = r.Conditions.Update( issuedCondition, conditionutils.UpdateStatus(corev1.ConditionTrue), @@ -928,12 +932,11 @@ func (r *BMCVersionReconciler) issueBMCUpgrade( conditionutils.UpdateMessage(fmt.Sprintf("Task to upgrade has been created %v", taskMonitor)), ); errCond != nil { state = metalv1alpha1.BMCVersionStateFailed - log.V(1).Error(errCond, "failed to update the conditions status, failing the upgrade process! BMC might still be updated to new version") + log.Error(errCond, "failed to update the conditions status, failing the upgrade process! BMC might still be updated to new version") } } err = r.patchBMCVersionStatusAndCondition( ctx, - log, bmcVersion, state, upgradeCurrentTaskStatus, diff --git a/internal/controller/bmcversionset_controller.go b/internal/controller/bmcversionset_controller.go index d56b812f..0e4dbe86 100644 --- a/internal/controller/bmcversionset_controller.go +++ b/internal/controller/bmcversionset_controller.go @@ -20,7 +20,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/handler" "sigs.k8s.io/controller-runtime/pkg/predicate" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" ) @@ -40,40 +39,40 @@ const BMCVersionSetFinalizer = "metal.ironcore.dev/bmcversionset" // +kubebuilder:rbac:groups=metal.ironcore.dev,resources=bmcversions,verbs=get;list;watch;create;update;patch;delete func (r *BMCVersionSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) bmcVersionSet := &metalv1alpha1.BMCVersionSet{} if err := r.Get(ctx, req.NamespacedName, bmcVersionSet); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling BMCVersionSet") - return r.reconcileExists(ctx, log, bmcVersionSet) + return r.reconcileExists(ctx, bmcVersionSet) } func (r *BMCVersionSetReconciler) reconcileExists( ctx context.Context, - log logr.Logger, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) // if object is being deleted - reconcile deletion if !bmcVersionSet.DeletionTimestamp.IsZero() { log.V(1).Info("object is being deleted") - return r.delete(ctx, log, bmcVersionSet) + return r.delete(ctx, bmcVersionSet) } - return r.reconcile(ctx, log, bmcVersionSet) + return r.reconcile(ctx, bmcVersionSet) } func (r *BMCVersionSetReconciler) delete( ctx context.Context, - log logr.Logger, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if !controllerutil.ContainsFinalizer(bmcVersionSet, BMCVersionSetFinalizer) { return ctrl.Result{}, nil } - if err := r.handleIgnoreAnnotationPropagation(ctx, log, bmcVersionSet); err != nil { + if err := r.handleIgnoreAnnotationPropagation(ctx, bmcVersionSet); err != nil { return ctrl.Result{}, err } @@ -86,11 +85,11 @@ func (r *BMCVersionSetReconciler) delete( if currentStatus.AvailableBMCVersion != (currentStatus.CompletedBMCVersion+currentStatus.FailedBMCVersion) || bmcVersionSet.Status.AvailableBMCVersion != currentStatus.AvailableBMCVersion { - err = r.updateStatus(ctx, log, currentStatus, bmcVersionSet) + err = r.updateStatus(ctx, currentStatus, bmcVersionSet) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to update current BMCVersionSet Status %w", err) } - if err := r.handleRetryAnnotationPropagation(ctx, log, bmcVersionSet); err != nil { + if err := r.handleRetryAnnotationPropagation(ctx, bmcVersionSet); err != nil { return ctrl.Result{}, err } log.Info("Waiting on the created BMCVersion to reach terminal status") @@ -108,9 +107,9 @@ func (r *BMCVersionSetReconciler) delete( func (r *BMCVersionSetReconciler) handleIgnoreAnnotationPropagation( ctx context.Context, - log logr.Logger, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) error { + log := ctrl.LoggerFrom(ctx) ownedBMCVersions, err := r.getOwnedBMCVersions(ctx, bmcVersionSet) if err != nil { return err @@ -119,14 +118,14 @@ func (r *BMCVersionSetReconciler) handleIgnoreAnnotationPropagation( log.V(1).Info("No BMCVersion found, skipping ignore annotation propagation") return nil } - return handleIgnoreAnnotationPropagation(ctx, log, r.Client, bmcVersionSet, ownedBMCVersions) + return handleIgnoreAnnotationPropagation(ctx, r.Client, bmcVersionSet, ownedBMCVersions) } func (r *BMCVersionSetReconciler) handleRetryAnnotationPropagation( ctx context.Context, - log logr.Logger, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) error { + log := ctrl.LoggerFrom(ctx) ownedBMCVersion, err := r.getOwnedBMCVersions(ctx, bmcVersionSet) if err != nil { return err @@ -135,15 +134,15 @@ func (r *BMCVersionSetReconciler) handleRetryAnnotationPropagation( log.V(1).Info("No BMCVersion found, skipping retry annotation propagation") return nil } - return handleRetryAnnotationPropagation(ctx, log, r.Client, bmcVersionSet, ownedBMCVersion) + return handleRetryAnnotationPropagation(ctx, r.Client, bmcVersionSet, ownedBMCVersion) } func (r *BMCVersionSetReconciler) reconcile( ctx context.Context, - log logr.Logger, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) (ctrl.Result, error) { - if err := r.handleIgnoreAnnotationPropagation(ctx, log, bmcVersionSet); err != nil { + log := ctrl.LoggerFrom(ctx) + if err := r.handleIgnoreAnnotationPropagation(ctx, bmcVersionSet); err != nil { return ctrl.Result{}, err } @@ -170,16 +169,16 @@ func (r *BMCVersionSetReconciler) reconcile( "BMCVersion count", len(ownedBMCVersions.Items)) // create BMCVersion for BMCs selected, if it does not exist - if err := r.createMissingBMCVersions(ctx, log, bmcList, ownedBMCVersions, bmcVersionSet); err != nil { + if err := r.createMissingBMCVersions(ctx, bmcList, ownedBMCVersions, bmcVersionSet); err != nil { return ctrl.Result{}, fmt.Errorf("failed to create BMCVersion resources %w", err) } // delete BMCVersion for BMCs which do not exist anymore - if _, err := r.deleteOrphanBMCVersions(ctx, log, bmcList, ownedBMCVersions); err != nil { + if _, err := r.deleteOrphanBMCVersions(ctx, bmcList, ownedBMCVersions); err != nil { return ctrl.Result{}, fmt.Errorf("failed to delete orphaned BMCVersion resources %w", err) } - if err := r.patchBMCVersionfromTemplate(ctx, log, bmcVersionSet, ownedBMCVersions); err != nil { + if err := r.patchBMCVersionfromTemplate(ctx, bmcVersionSet, ownedBMCVersions); err != nil { return ctrl.Result{}, fmt.Errorf("failed to patch BMCVersion spec from template %w", err) } @@ -187,11 +186,11 @@ func (r *BMCVersionSetReconciler) reconcile( currentStatus := r.getOwnedBMCVersionSetStatus(ownedBMCVersions) currentStatus.FullyLabeledBMCs = int32(len(bmcList.Items)) - err = r.updateStatus(ctx, log, currentStatus, bmcVersionSet) + err = r.updateStatus(ctx, currentStatus, bmcVersionSet) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to update current BMCVersionSet Status %w", err) } - if err := r.handleRetryAnnotationPropagation(ctx, log, bmcVersionSet); err != nil { + if err := r.handleRetryAnnotationPropagation(ctx, bmcVersionSet); err != nil { return ctrl.Result{}, err } // wait for any updates from owned resources @@ -200,12 +199,11 @@ func (r *BMCVersionSetReconciler) reconcile( func (r *BMCVersionSetReconciler) createMissingBMCVersions( ctx context.Context, - log logr.Logger, bmcList *metalv1alpha1.BMCList, bmcVersionList *metalv1alpha1.BMCVersionList, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) error { - + log := ctrl.LoggerFrom(ctx) BMCWithBMCVersion := make(map[string]struct{}) for _, bmcVersion := range bmcVersionList.Items { BMCWithBMCVersion[bmcVersion.Spec.BMCRef.Name] = struct{}{} @@ -234,10 +232,10 @@ func (r *BMCVersionSetReconciler) createMissingBMCVersions( func (r *BMCVersionSetReconciler) deleteOrphanBMCVersions( ctx context.Context, - log logr.Logger, bmcList *metalv1alpha1.BMCList, bmcVersionList *metalv1alpha1.BMCVersionList, ) ([]string, error) { + log := ctrl.LoggerFrom(ctx) bmcMap := make(map[string]struct{}) for _, bmc := range bmcList.Items { @@ -264,10 +262,10 @@ func (r *BMCVersionSetReconciler) deleteOrphanBMCVersions( func (r *BMCVersionSetReconciler) patchBMCVersionfromTemplate( ctx context.Context, - log logr.Logger, bmcVersionSet *metalv1alpha1.BMCVersionSet, bmcVersionList *metalv1alpha1.BMCVersionList, ) error { + log := ctrl.LoggerFrom(ctx) if len(bmcVersionList.Items) == 0 { log.V(1).Info("No BMCVersion found, skipping spec template update") return nil @@ -342,10 +340,10 @@ func (r *BMCVersionSetReconciler) getBMCBySelector( func (r *BMCVersionSetReconciler) updateStatus( ctx context.Context, - log logr.Logger, currentStatus *metalv1alpha1.BMCVersionSetStatus, bmcVersionSet *metalv1alpha1.BMCVersionSet, ) error { + log := ctrl.LoggerFrom(ctx) bmcVersionSetBase := bmcVersionSet.DeepCopy() @@ -367,14 +365,14 @@ func (r *BMCVersionSetReconciler) enqueueByBMC(ctx context.Context, obj client.O bmcVersionSetList := &metalv1alpha1.BMCVersionSetList{} if err := r.List(ctx, bmcVersionSetList); err != nil { - log.V(1).Error(err, "failed to list BMCVersionSet") + log.Error(err, "failed to list BMCVersionSet") return nil } reqs := make([]ctrl.Request, 0) for _, bmcVersionSet := range bmcVersionSetList.Items { selector, err := metav1.LabelSelectorAsSelector(&bmcVersionSet.Spec.BMCSelector) if err != nil { - log.V(1).Error(err, "failed to convert label selector") + log.Error(err, "failed to convert label selector") return nil } // if the host label matches the selector, enqueue the request @@ -388,7 +386,7 @@ func (r *BMCVersionSetReconciler) enqueueByBMC(ctx context.Context, obj client.O } else { // if the label has been removed ownedBMCVersions, err := r.getOwnedBMCVersions(ctx, &bmcVersionSet) if err != nil { - log.V(1).Error(err, "failed to get owned BMCVersion resources") + log.Error(err, "failed to get owned BMCVersion resources") return nil } for _, bmcVersion := range ownedBMCVersions.Items { diff --git a/internal/controller/endpoint_controller.go b/internal/controller/endpoint_controller.go index 2262956e..93fd6ef4 100644 --- a/internal/controller/endpoint_controller.go +++ b/internal/controller/endpoint_controller.go @@ -9,7 +9,6 @@ import ( "net" "strings" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" "github.com/ironcore-dev/metal-operator/bmc" @@ -42,23 +41,23 @@ type EndpointReconciler struct { // +kubebuilder:rbac:groups=metal.ironcore.dev,resources=endpoints/finalizers,verbs=update func (r *EndpointReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) endpoint := &metalv1alpha1.Endpoint{} if err := r.Get(ctx, req.NamespacedName, endpoint); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, endpoint) + return r.reconcileExists(ctx, endpoint) } -func (r *EndpointReconciler) reconcileExists(ctx context.Context, log logr.Logger, endpoint *metalv1alpha1.Endpoint) (ctrl.Result, error) { +func (r *EndpointReconciler) reconcileExists(ctx context.Context, endpoint *metalv1alpha1.Endpoint) (ctrl.Result, error) { if !endpoint.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, endpoint) + return r.delete(ctx, endpoint) } - return r.reconcile(ctx, log, endpoint) + return r.reconcile(ctx, endpoint) } -func (r *EndpointReconciler) delete(ctx context.Context, log logr.Logger, endpoint *metalv1alpha1.Endpoint) (ctrl.Result, error) { +func (r *EndpointReconciler) delete(ctx context.Context, endpoint *metalv1alpha1.Endpoint) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting Endpoint") // TODO: cleanup endpoint if modified, err := clientutils.PatchEnsureNoFinalizer(ctx, r.Client, endpoint, EndpointFinalizer); err != nil || modified { @@ -68,7 +67,8 @@ func (r *EndpointReconciler) delete(ctx context.Context, log logr.Logger, endpoi return ctrl.Result{}, nil } -func (r *EndpointReconciler) reconcile(ctx context.Context, log logr.Logger, endpoint *metalv1alpha1.Endpoint) (ctrl.Result, error) { +func (r *EndpointReconciler) reconcile(ctx context.Context, endpoint *metalv1alpha1.Endpoint) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling endpoint") if shouldIgnoreReconciliation(endpoint) { log.V(1).Info("Skipped Endpoint reconciliation") @@ -104,12 +104,12 @@ func (r *EndpointReconciler) reconcile(ctx context.Context, log logr.Logger, end // TODO: ensure that BMC has the correct MACAddress var bmcSecret *metalv1alpha1.BMCSecret - if bmcSecret, err = r.applyBMCSecret(ctx, log, endpoint, m); err != nil { + if bmcSecret, err = r.applyBMCSecret(ctx, endpoint, m); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply BMCSecret: %w", err) } log.V(1).Info("Applied BMC secret for endpoint") - if err := r.applyBMC(ctx, log, endpoint, bmcSecret, m); err != nil { + if err := r.applyBMC(ctx, endpoint, bmcSecret, m); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply BMC object: %w", err) } log.V(1).Info("Applied BMC object for endpoint") @@ -122,12 +122,12 @@ func (r *EndpointReconciler) reconcile(ctx context.Context, log logr.Logger, end defer bmcClient.Logout() var bmcSecret *metalv1alpha1.BMCSecret - if bmcSecret, err = r.applyBMCSecret(ctx, log, endpoint, m); err != nil { + if bmcSecret, err = r.applyBMCSecret(ctx, endpoint, m); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply BMCSecret: %w", err) } log.V(1).Info("Applied local test BMC secret for endpoint") - if err := r.applyBMC(ctx, log, endpoint, bmcSecret, m); err != nil { + if err := r.applyBMC(ctx, endpoint, bmcSecret, m); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply BMC object: %w", err) } log.V(1).Info("Applied BMC object for Endpoint") @@ -140,12 +140,12 @@ func (r *EndpointReconciler) reconcile(ctx context.Context, log logr.Logger, end defer bmcClient.Logout() var bmcSecret *metalv1alpha1.BMCSecret - if bmcSecret, err = r.applyBMCSecret(ctx, log, endpoint, m); err != nil { + if bmcSecret, err = r.applyBMCSecret(ctx, endpoint, m); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply BMCSecret: %w", err) } log.V(1).Info("Applied kube test BMC secret for endpoint") - if err := r.applyBMC(ctx, log, endpoint, bmcSecret, m); err != nil { + if err := r.applyBMC(ctx, endpoint, bmcSecret, m); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply BMC object: %w", err) } log.V(1).Info("Applied BMC object for Endpoint") @@ -160,7 +160,8 @@ func (r *EndpointReconciler) reconcile(ctx context.Context, log logr.Logger, end return ctrl.Result{}, nil } -func (r *EndpointReconciler) applyBMC(ctx context.Context, log logr.Logger, endpoint *metalv1alpha1.Endpoint, secret *metalv1alpha1.BMCSecret, m macdb.MacPrefix) error { +func (r *EndpointReconciler) applyBMC(ctx context.Context, endpoint *metalv1alpha1.Endpoint, secret *metalv1alpha1.BMCSecret, m macdb.MacPrefix) error { + log := ctrl.LoggerFrom(ctx) bmcObj := &metalv1alpha1.BMC{} bmcObj.Name = endpoint.Name opResult, err := controllerutil.CreateOrPatch(ctx, r.Client, bmcObj, func() error { @@ -186,7 +187,8 @@ func (r *EndpointReconciler) applyBMC(ctx context.Context, log logr.Logger, endp return nil } -func (r *EndpointReconciler) applyBMCSecret(ctx context.Context, log logr.Logger, endpoint *metalv1alpha1.Endpoint, m macdb.MacPrefix) (*metalv1alpha1.BMCSecret, error) { +func (r *EndpointReconciler) applyBMCSecret(ctx context.Context, endpoint *metalv1alpha1.Endpoint, m macdb.MacPrefix) (*metalv1alpha1.BMCSecret, error) { + log := ctrl.LoggerFrom(ctx) bmcSecret := &metalv1alpha1.BMCSecret{} bmcSecret.Name = endpoint.Name opResult, err := controllerutil.CreateOrPatch(ctx, r.Client, bmcSecret, func() error { diff --git a/internal/controller/helper.go b/internal/controller/helper.go index 34fd0daa..fd9fcbf1 100644 --- a/internal/controller/helper.go +++ b/internal/controller/helper.go @@ -12,7 +12,6 @@ import ( "reflect" "slices" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/conditionutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" "github.com/ironcore-dev/metal-operator/bmc" @@ -21,6 +20,7 @@ import ( "k8s.io/apimachinery/pkg/api/meta" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" "k8s.io/apimachinery/pkg/runtime" + ctrl "sigs.k8s.io/controller-runtime" "sigs.k8s.io/controller-runtime/pkg/client" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" "sigs.k8s.io/controller-runtime/pkg/event" @@ -183,18 +183,13 @@ func enqueueFromChildObjUpdatesExceptAnnotation(e event.UpdateEvent) bool { return true } -func resetBMCOfServer( - ctx context.Context, - log logr.Logger, - kClient client.Client, - server *metalv1alpha1.Server, - bmcClient bmc.BMC, -) error { +func resetBMCOfServer(ctx context.Context, kClient client.Client, server *metalv1alpha1.Server, bmcClient bmc.BMC) error { + log := ctrl.LoggerFrom(ctx) if server.Spec.BMCRef != nil { key := client.ObjectKey{Name: server.Spec.BMCRef.Name} BMC := &metalv1alpha1.BMC{} if err := kClient.Get(ctx, key, BMC); err != nil { - log.V(1).Error(err, "failed to get referred server's Manager") + log.Error(err, "failed to get referred server's Manager") return err } annotations := BMC.GetAnnotations() @@ -238,7 +233,8 @@ func resetBMCOfServer( return fmt.Errorf("no BMC reference or inline BMC details found in server spec to reset BMC") } -func handleIgnoreAnnotationPropagation(ctx context.Context, log logr.Logger, c client.Client, parentObj client.Object, ownedObjects client.ObjectList) error { +func handleIgnoreAnnotationPropagation(ctx context.Context, c client.Client, parentObj client.Object, ownedObjects client.ObjectList) error { + log := ctrl.LoggerFrom(ctx) var errs []error _ = meta.EachListItem(ownedObjects, func(obj runtime.Object) error { childObj, ok := obj.(client.Object) @@ -280,7 +276,8 @@ func handleIgnoreAnnotationPropagation(ctx context.Context, log logr.Logger, c c return errors.Join(errs...) } -func handleRetryAnnotationPropagation(ctx context.Context, log logr.Logger, c client.Client, parentObj client.Object, ownedObjects client.ObjectList) error { +func handleRetryAnnotationPropagation(ctx context.Context, c client.Client, parentObj client.Object, ownedObjects client.ObjectList) error { + log := ctrl.LoggerFrom(ctx) var errs []error _ = meta.EachListItem(ownedObjects, func(obj runtime.Object) error { childObj, ok := obj.(client.Object) diff --git a/internal/controller/server_controller.go b/internal/controller/server_controller.go index b62ecc77..3a443619 100644 --- a/internal/controller/server_controller.go +++ b/internal/controller/server_controller.go @@ -17,7 +17,6 @@ import ( "strings" "time" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/conditionutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" @@ -110,23 +109,23 @@ type ServerReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *ServerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) server := &metalv1alpha1.Server{} if err := r.Get(ctx, req.NamespacedName, server); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, server) + return r.reconcileExists(ctx, server) } -func (r *ServerReconciler) reconcileExists(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) (ctrl.Result, error) { - if r.shouldDelete(log, server) { - return r.delete(ctx, log, server) +func (r *ServerReconciler) reconcileExists(ctx context.Context, server *metalv1alpha1.Server) (ctrl.Result, error) { + if r.shouldDelete(ctx, server) { + return r.delete(ctx, server) } - return r.reconcile(ctx, log, server) + return r.reconcile(ctx, server) } -func (r *ServerReconciler) shouldDelete(log logr.Logger, server *metalv1alpha1.Server) bool { +func (r *ServerReconciler) shouldDelete(ctx context.Context, server *metalv1alpha1.Server) bool { + log := ctrl.LoggerFrom(ctx) if server.DeletionTimestamp.IsZero() { return false } @@ -139,7 +138,8 @@ func (r *ServerReconciler) shouldDelete(log logr.Logger, server *metalv1alpha1.S return true } -func (r *ServerReconciler) delete(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) (ctrl.Result, error) { +func (r *ServerReconciler) delete(ctx context.Context, server *metalv1alpha1.Server) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) if !controllerutil.ContainsFinalizer(server, ServerFinalizer) { return ctrl.Result{}, nil } @@ -177,7 +177,8 @@ func (r *ServerReconciler) delete(ctx context.Context, log logr.Logger, server * return ctrl.Result{}, nil } -func (r *ServerReconciler) reconcile(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) (ctrl.Result, error) { +func (r *ServerReconciler) reconcile(ctx context.Context, server *metalv1alpha1.Server) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling Server") if shouldIgnoreReconciliation(server) { log.V(1).Info("Skipped Server reconciliation") @@ -201,11 +202,11 @@ func (r *ServerReconciler) reconcile(ctx context.Context, log logr.Logger, serve } defer bmcClient.Logout() - if modified, err := r.patchServerURI(ctx, log, bmcClient, server); err != nil || modified { + if modified, err := r.patchServerURI(ctx, bmcClient, server); err != nil || modified { return ctrl.Result{}, err } - if modified, err := r.handleAnnotionOperations(ctx, log, bmcClient, server); err != nil || modified { + if modified, err := r.handleAnnotionOperations(ctx, bmcClient, server); err != nil || modified { return ctrl.Result{}, err } log.V(1).Info("Handled annotation operations") @@ -221,23 +222,23 @@ func (r *ServerReconciler) reconcile(ctx context.Context, log logr.Logger, serve } } - if err := r.updateServerStatus(ctx, log, bmcClient, server); err != nil { + if err := r.updateServerStatus(ctx, bmcClient, server); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update server status: %w", err) } log.V(1).Info("Updated Server status") - if err := r.applyBootOrder(ctx, log, bmcClient, server); err != nil { + if err := r.applyBootOrder(ctx, bmcClient, server); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update server bios boot order: %w", err) } log.V(1).Info("Updated Server BIOS boot order") - _, err = r.ensureServerStateTransition(ctx, log, bmcClient, server) + _, err = r.ensureServerStateTransition(ctx, bmcClient, server) if err != nil { return ctrl.Result{}, fmt.Errorf("failed to ensure server state transition: %w", err) } log.V(1).Info("Updating Server status after state transition") // we need to update the ServerStatus after state transition to make sure it reflects the changes done - if err := r.updateServerStatus(ctx, log, bmcClient, server); err != nil { + if err := r.updateServerStatus(ctx, bmcClient, server); err != nil { return ctrl.Result{}, fmt.Errorf("failed to update server status: %w", err) } @@ -273,45 +274,46 @@ func (r *ServerReconciler) reconcile(ctx context.Context, log logr.Logger, serve // // Maintenance: // A Maintenance state represents a special case where certain operations like BIOS updates should be performed. -func (r *ServerReconciler) ensureServerStateTransition(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) ensureServerStateTransition(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { switch server.Status.State { case metalv1alpha1.ServerStateInitial: - return r.handleInitialState(ctx, log, bmcClient, server) + return r.handleInitialState(ctx, bmcClient, server) case metalv1alpha1.ServerStateDiscovery: - return r.handleDiscoveryState(ctx, log, bmcClient, server) + return r.handleDiscoveryState(ctx, bmcClient, server) case metalv1alpha1.ServerStateAvailable: - return r.handleAvailableState(ctx, log, bmcClient, server) + return r.handleAvailableState(ctx, bmcClient, server) case metalv1alpha1.ServerStateReserved: - return r.handleReservedState(ctx, log, bmcClient, server) + return r.handleReservedState(ctx, bmcClient, server) case metalv1alpha1.ServerStateMaintenance: - return r.handleMaintenanceState(ctx, log, bmcClient, server) + return r.handleMaintenanceState(ctx, bmcClient, server) default: return false, nil } } -func (r *ServerReconciler) handleInitialState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { - if requeue, err := r.ensureInitialConditions(ctx, log, bmcClient, server); err != nil || requeue { +func (r *ServerReconciler) handleInitialState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) + if requeue, err := r.ensureInitialConditions(ctx, bmcClient, server); err != nil || requeue { return requeue, err } log.V(1).Info("Initial conditions for Server met") - if err := r.ensureServerPowerState(ctx, log, bmcClient, server); err != nil { + if err := r.ensureServerPowerState(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to ensure server power state: %w", err) } log.V(1).Info("Ensured power state for Server") - if err := r.updateServerStatusFromSystemInfo(ctx, log, bmcClient, server); err != nil { + if err := r.updateServerStatusFromSystemInfo(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to update server status system info: %w", err) } log.V(1).Info("Updated Server status system info") - if err := r.applyBootConfigurationAndIgnitionForDiscovery(ctx, log, server); err != nil { + if err := r.applyBootConfigurationAndIgnitionForDiscovery(ctx, server); err != nil { return false, fmt.Errorf("failed to apply server boot configuration: %w", err) } log.V(1).Info("Applied Server boot configuration") - if err := r.pxeBootServer(ctx, log, bmcClient, server); err != nil { + if err := r.pxeBootServer(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to set PXE boot for server: %w", err) } log.V(1).Info("Set PXE Boot for Server") @@ -322,7 +324,8 @@ func (r *ServerReconciler) handleInitialState(ctx context.Context, log logr.Logg return false, nil } -func (r *ServerReconciler) handleDiscoveryState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) handleDiscoveryState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if ready, err := r.serverBootConfigurationIsReady(ctx, server); err != nil || !ready { log.V(1).Info("Server boot configuration is not ready. Retrying ...") return true, err @@ -336,7 +339,7 @@ func (r *ServerReconciler) handleDiscoveryState(ctx context.Context, log logr.Lo } log.V(1).Info("Updated Server power state", "PowerState", metalv1alpha1.PowerOn) - if err := r.ensureServerPowerState(ctx, log, bmcClient, server); err != nil { + if err := r.ensureServerPowerState(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to ensure server power state: %w", err) } log.V(1).Info("Server state set to power on") @@ -352,7 +355,7 @@ func (r *ServerReconciler) handleDiscoveryState(ctx context.Context, log logr.Lo } } - ready, err := r.extractServerDetailsFromRegistry(ctx, log, server) + ready, err := r.extractServerDetailsFromRegistry(ctx, server) if !ready && err == nil { log.V(1).Info("Server agent did not post info to registry") return true, nil @@ -363,7 +366,7 @@ func (r *ServerReconciler) handleDiscoveryState(ctx context.Context, log logr.Lo } log.V(1).Info("Extracted Server details") - if err := r.invalidateRegistryEntryForServer(log, server); err != nil { + if err := r.invalidateRegistryEntryForServer(ctx, server); err != nil { return false, fmt.Errorf("failed to invalidate registry entry for server: %w", err) } log.V(1).Info("Removed Server from Registry") @@ -375,7 +378,8 @@ func (r *ServerReconciler) handleDiscoveryState(ctx context.Context, log logr.Lo return false, nil } -func (r *ServerReconciler) handleAvailableState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) handleAvailableState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) serverBase := server.DeepCopy() if server.Status.PowerState != metalv1alpha1.ServerOffPowerState { server.Spec.Power = metalv1alpha1.PowerOff @@ -384,7 +388,7 @@ func (r *ServerReconciler) handleAvailableState(ctx context.Context, log logr.Lo } log.V(1).Info("Updated Server power state", "PowerState", metalv1alpha1.PowerOff) - if err := r.ensureServerPowerState(ctx, log, bmcClient, server); err != nil { + if err := r.ensureServerPowerState(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to ensure server power state: %w", err) } log.V(1).Info("Server state set to power off") @@ -395,7 +399,7 @@ func (r *ServerReconciler) handleAvailableState(ctx context.Context, log logr.Lo } log.V(1).Info("Ensured initial boot configuration is deleted") - if err := r.ensureIndicatorLED(ctx, log, server); err != nil { + if err := r.ensureIndicatorLED(ctx, server); err != nil { return false, fmt.Errorf("failed to ensure server indicator led: %w", err) } if server.Spec.ServerClaimRef != nil { @@ -407,7 +411,8 @@ func (r *ServerReconciler) handleAvailableState(ctx context.Context, log logr.Lo return true, nil } -func (r *ServerReconciler) handleReservedState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) handleReservedState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) // TODO: This needs be reworked later as the Server cleanup has to happen here. For now we just transition the server // back to available state. if server.Spec.ServerClaimRef == nil { @@ -445,27 +450,28 @@ func (r *ServerReconciler) handleReservedState(ctx context.Context, log logr.Log // TODO: handle working Reserved Server that was suddenly powered off but needs to boot from disk if server.Status.PowerState == metalv1alpha1.ServerOffPowerState { - if err := r.pxeBootServer(ctx, log, bmcClient, server); err != nil { + if err := r.pxeBootServer(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to boot server: %w", err) } log.V(1).Info("Server is powered off, booting Server in PXE") } - if err := r.ensureServerPowerState(ctx, log, bmcClient, server); err != nil { + if err := r.ensureServerPowerState(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to ensure server power state: %w", err) } - if err := r.ensureIndicatorLED(ctx, log, server); err != nil { + if err := r.ensureIndicatorLED(ctx, server); err != nil { return false, fmt.Errorf("failed to ensure server indicator led: %w", err) } log.V(1).Info("Reconciled reserved state") return true, nil } -func (r *ServerReconciler) handleMaintenanceState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) handleMaintenanceState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if server.Spec.ServerMaintenanceRef == nil { log.V(1).Info("Server is in Maintenance state, but no ServerMaintenanceRef is set, transitioning back to previous state") // update system info in case the server was changed during Maintenance state (hardwere changes, biosVersion etc.) - if err := r.updateServerStatusFromSystemInfo(ctx, log, bmcClient, server); err != nil { + if err := r.updateServerStatusFromSystemInfo(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to update server status system info: %w", err) } if server.Spec.ServerClaimRef == nil { @@ -473,7 +479,7 @@ func (r *ServerReconciler) handleMaintenanceState(ctx context.Context, log logr. } return r.patchServerState(ctx, server, metalv1alpha1.ServerStateReserved) } - if err := r.ensureServerPowerState(ctx, log, bmcClient, server); err != nil { + if err := r.ensureServerPowerState(ctx, bmcClient, server); err != nil { return false, fmt.Errorf("failed to ensure server power state: %w", err) } @@ -494,7 +500,8 @@ func (r *ServerReconciler) ensureServerBootConfigRef(ctx context.Context, server } // updates the Server status which can be changed via Spec -func (r *ServerReconciler) updateServerStatus(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) updateServerStatus(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server.Spec.BMCRef == nil && server.Spec.BMC == nil { log.V(1).Info("Server has no BMC connection configured") return nil @@ -513,7 +520,8 @@ func (r *ServerReconciler) updateServerStatus(ctx context.Context, log logr.Logg return nil } -func (r *ServerReconciler) updateServerStatusFromSystemInfo(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) updateServerStatusFromSystemInfo(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) serverBase := server.DeepCopy() systemInfo, err := bmcClient.GetSystemInfo(ctx, server.Spec.SystemURI) if err != nil { @@ -590,7 +598,8 @@ func (r *ServerReconciler) updateServerStatusFromSystemInfo(ctx context.Context, return nil } -func (r *ServerReconciler) applyBootConfigurationAndIgnitionForDiscovery(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) applyBootConfigurationAndIgnitionForDiscovery(ctx context.Context, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) bootConfig := &metalv1alpha1.ServerBootConfiguration{} bootConfig.Name = server.Name bootConfig.Namespace = r.ManagerNamespace @@ -614,10 +623,11 @@ func (r *ServerReconciler) applyBootConfigurationAndIgnitionForDiscovery(ctx con if err := r.ensureServerBootConfigRef(ctx, server, bootConfig); err != nil { return err } - return r.applyDefaultIgnitionForServer(ctx, log, server, bootConfig, r.RegistryURL) + return r.applyDefaultIgnitionForServer(ctx, server, bootConfig, r.RegistryURL) } -func (r *ServerReconciler) applyDefaultIgnitionForServer(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server, bootConfig *metalv1alpha1.ServerBootConfiguration, registryURL string) error { +func (r *ServerReconciler) applyDefaultIgnitionForServer(ctx context.Context, server *metalv1alpha1.Server, bootConfig *metalv1alpha1.ServerBootConfiguration, registryURL string) error { + log := ctrl.LoggerFrom(ctx) sshPrivateKey, sshPublicKey, password, err := generateSSHKeyPairAndPassword() if err != nil { return fmt.Errorf("failed to generate SSH keypair: %w", err) @@ -723,9 +733,10 @@ func (r *ServerReconciler) generateDefaultIgnitionDataForServer(flags string, ss return ignitionData, nil } -func (r *ServerReconciler) ensureInitialConditions(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) ensureInitialConditions(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if server.Spec.Power == "" && server.Status.PowerState == metalv1alpha1.ServerOffPowerState { - requeue, err := r.setAndPatchServerPowerState(ctx, log, bmcClient, server, metalv1alpha1.PowerOff) + requeue, err := r.setAndPatchServerPowerState(ctx, bmcClient, server, metalv1alpha1.PowerOff) if err != nil { return false, fmt.Errorf("failed to set server power state: %w", err) } @@ -738,7 +749,7 @@ func (r *ServerReconciler) ensureInitialConditions(ctx context.Context, log logr server.Status.PowerState == metalv1alpha1.ServerOnPowerState && r.EnforceFirstBoot { log.V(1).Info("Server in initial state is powered on. Ensure that it is powered off.") - requeue, err := r.setAndPatchServerPowerState(ctx, log, bmcClient, server, metalv1alpha1.PowerOff) + requeue, err := r.setAndPatchServerPowerState(ctx, bmcClient, server, metalv1alpha1.PowerOff) if err != nil { return false, fmt.Errorf("failed to set server power state: %w", err) } @@ -749,7 +760,8 @@ func (r *ServerReconciler) ensureInitialConditions(ctx context.Context, log logr return false, nil } -func (r *ServerReconciler) setAndPatchServerPowerState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server, powerState metalv1alpha1.Power) (bool, error) { +func (r *ServerReconciler) setAndPatchServerPowerState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server, powerState metalv1alpha1.Power) (bool, error) { + log := ctrl.LoggerFrom(ctx) op, err := controllerutil.CreateOrPatch(ctx, r.Client, server, func() error { server.Spec.Power = powerState return nil @@ -759,7 +771,7 @@ func (r *ServerReconciler) setAndPatchServerPowerState(ctx context.Context, log } if op == controllerutil.OperationResultUpdated { log.V(1).Info("Server updated to power off state.") - if err := r.ensureServerPowerState(ctx, log, bmcClient, server); err != nil { + if err := r.ensureServerPowerState(ctx, bmcClient, server); err != nil { log.V(1).Info("ensuring power state failed.") } return true, nil @@ -778,7 +790,8 @@ func (r *ServerReconciler) serverBootConfigurationIsReady(ctx context.Context, s return config.Status.State == metalv1alpha1.ServerBootConfigurationStateReady, nil } -func (r *ServerReconciler) pxeBootServer(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) pxeBootServer(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server == nil || server.Spec.BootConfigurationRef == nil { log.V(1).Info("Server not ready for netboot") return nil @@ -794,7 +807,8 @@ func (r *ServerReconciler) pxeBootServer(ctx context.Context, log logr.Logger, b return nil } -func (r *ServerReconciler) extractServerDetailsFromRegistry(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) extractServerDetailsFromRegistry(ctx context.Context, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) resp, err := http.Get(fmt.Sprintf("%s/systems/%s", r.RegistryURL, server.Spec.SystemUUID)) if resp != nil && resp.StatusCode == http.StatusNotFound { log.V(1).Info("Did not find server information in registry") @@ -836,7 +850,7 @@ func (r *ServerReconciler) extractServerDetailsFromRegistry(ctx context.Context, // Parse and validate the IP address ip, err := metalv1alpha1.ParseIP(ipAddr) if err != nil { - log.V(1).Error(err, "Invalid IP address, skipping", "interface", s.Name, "ip", ipAddr) + log.Error(err, "Invalid IP address, skipping", "interface", s.Name, "ip", ipAddr) continue } @@ -891,7 +905,8 @@ func (r *ServerReconciler) patchServerState(ctx context.Context, server *metalv1 return true, nil } -func (r *ServerReconciler) patchServerURI(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) patchServerURI(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if len(server.Spec.SystemURI) != 0 { return false, nil } @@ -919,7 +934,8 @@ func (r *ServerReconciler) patchServerURI(ctx context.Context, log logr.Logger, return true, nil } -func (r *ServerReconciler) ensureServerPowerState(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) ensureServerPowerState(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server.Spec.Power == "" { // no desired power state set return nil @@ -998,7 +1014,7 @@ func (r *ServerReconciler) updatePowerOnCondition(ctx context.Context, server *m return r.Status().Patch(ctx, server, client.MergeFrom(original)) } -func (r *ServerReconciler) ensureIndicatorLED(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) ensureIndicatorLED(ctx context.Context, server *metalv1alpha1.Server) error { // TODO: implement return nil } @@ -1031,7 +1047,8 @@ func (r *ServerReconciler) ensureInitialBootConfigurationIsDeleted(ctx context.C return nil } -func (r *ServerReconciler) invalidateRegistryEntryForServer(log logr.Logger, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) invalidateRegistryEntryForServer(ctx context.Context, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) url := fmt.Sprintf("%s/delete/%s", r.RegistryURL, server.Spec.SystemUUID) c := &http.Client{} @@ -1056,7 +1073,8 @@ func (r *ServerReconciler) invalidateRegistryEntryForServer(log logr.Logger, ser return nil } -func (r *ServerReconciler) applyBootOrder(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { +func (r *ServerReconciler) applyBootOrder(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server.Spec.BMCRef == nil && server.Spec.BMC == nil { log.V(1).Info("Server has no BMC connection configured") return nil @@ -1084,7 +1102,8 @@ func (r *ServerReconciler) applyBootOrder(ctx context.Context, log logr.Logger, return nil } -func (r *ServerReconciler) handleAnnotionOperations(ctx context.Context, log logr.Logger, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerReconciler) handleAnnotionOperations(ctx context.Context, bmcClient bmc.BMC, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) annotations := server.GetAnnotations() operation, ok := annotations[metalv1alpha1.OperationAnnotation] if !ok { diff --git a/internal/controller/serverbootconfiguration_controller.go b/internal/controller/serverbootconfiguration_controller.go index d9273daa..a66559b1 100644 --- a/internal/controller/serverbootconfiguration_controller.go +++ b/internal/controller/serverbootconfiguration_controller.go @@ -6,7 +6,6 @@ package controller import ( "context" - "github.com/go-logr/logr" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" "k8s.io/apimachinery/pkg/runtime" ctrl "sigs.k8s.io/controller-runtime" @@ -26,30 +25,31 @@ type ServerBootConfigurationReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *ServerBootConfigurationReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) bootConfig := &metalv1alpha1.ServerBootConfiguration{} if err := r.Get(ctx, req.NamespacedName, bootConfig); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, bootConfig) + return r.reconcileExists(ctx, bootConfig) } -func (r *ServerBootConfigurationReconciler) reconcileExists(ctx context.Context, log logr.Logger, config *metalv1alpha1.ServerBootConfiguration) (ctrl.Result, error) { +func (r *ServerBootConfigurationReconciler) reconcileExists(ctx context.Context, config *metalv1alpha1.ServerBootConfiguration) (ctrl.Result, error) { if !config.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, config) + return r.delete(ctx, config) } - return r.reconcile(ctx, log, config) + return r.reconcile(ctx, config) } -func (r *ServerBootConfigurationReconciler) delete(ctx context.Context, log logr.Logger, config *metalv1alpha1.ServerBootConfiguration) (ctrl.Result, error) { +func (r *ServerBootConfigurationReconciler) delete(ctx context.Context, _ *metalv1alpha1.ServerBootConfiguration) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting ServerBootConfiguration") log.V(1).Info("Deleted ServerBootConfiguration") return ctrl.Result{}, nil } -func (r *ServerBootConfigurationReconciler) reconcile(ctx context.Context, log logr.Logger, config *metalv1alpha1.ServerBootConfiguration) (ctrl.Result, error) { +func (r *ServerBootConfigurationReconciler) reconcile(ctx context.Context, config *metalv1alpha1.ServerBootConfiguration) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling ServerBootConfiguration") if config.Status.State == "" { if modified, err := r.patchState(ctx, config, metalv1alpha1.ServerBootConfigurationStatePending); err != nil || modified { diff --git a/internal/controller/serverclaim_controller.go b/internal/controller/serverclaim_controller.go index 5b66df78..c35e8fbf 100644 --- a/internal/controller/serverclaim_controller.go +++ b/internal/controller/serverclaim_controller.go @@ -12,7 +12,6 @@ import ( "sigs.k8s.io/controller-runtime/pkg/controller" "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" v1 "k8s.io/api/core/v1" @@ -48,30 +47,30 @@ type ServerClaimReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *ServerClaimReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) claim := &metalv1alpha1.ServerClaim{} if err := r.Get(ctx, req.NamespacedName, claim); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, claim) + return r.reconcileExists(ctx, claim) } -func (r *ServerClaimReconciler) reconcileExists(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim) (ctrl.Result, error) { +func (r *ServerClaimReconciler) reconcileExists(ctx context.Context, claim *metalv1alpha1.ServerClaim) (ctrl.Result, error) { if !claim.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, claim) + return r.delete(ctx, claim) } - return r.reconcile(ctx, log, claim) + return r.reconcile(ctx, claim) } -func (r *ServerClaimReconciler) delete(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim) (ctrl.Result, error) { +func (r *ServerClaimReconciler) delete(ctx context.Context, claim *metalv1alpha1.ServerClaim) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting server claim") if !controllerutil.ContainsFinalizer(claim, ServerClaimFinalizer) { log.V(1).Info("Deleted server claim") return ctrl.Result{}, nil } - if err := r.cleanupAndShutdownServer(ctx, log, claim); err != nil { + if err := r.cleanupAndShutdownServer(ctx, claim); err != nil { return ctrl.Result{}, err } if modified, err := clientutils.PatchEnsureNoFinalizer(ctx, r.Client, claim, ServerClaimFinalizer); !apierrors.IsNotFound(err) || modified { @@ -83,7 +82,8 @@ func (r *ServerClaimReconciler) delete(ctx context.Context, log logr.Logger, cla return ctrl.Result{}, nil } -func (r *ServerClaimReconciler) cleanupAndShutdownServer(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim) error { +func (r *ServerClaimReconciler) cleanupAndShutdownServer(ctx context.Context, claim *metalv1alpha1.ServerClaim) error { + log := ctrl.LoggerFrom(ctx) if claim.Spec.ServerRef == nil { return nil } @@ -129,7 +129,8 @@ func (r *ServerClaimReconciler) cleanupAndShutdownServer(ctx context.Context, lo // - Ensure server spec matches claim & set claim ref on server // - Patch the claim status to bound // - Apply Boot configuration -func (r *ServerClaimReconciler) reconcile(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim) (ctrl.Result, error) { +func (r *ServerClaimReconciler) reconcile(ctx context.Context, claim *metalv1alpha1.ServerClaim) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling server claim") if shouldIgnoreReconciliation(claim) { log.V(1).Info("Skipped Server claim reconciliation") @@ -148,7 +149,7 @@ func (r *ServerClaimReconciler) reconcile(ctx context.Context, log logr.Logger, } log.V(1).Info("Ensured finalizer has been added") - server, err := r.claimServer(ctx, log, claim) + server, err := r.claimServer(ctx, claim) if err != nil { return ctrl.Result{}, err } @@ -167,7 +168,7 @@ func (r *ServerClaimReconciler) reconcile(ctx context.Context, log logr.Logger, return ctrl.Result{}, nil } - if err = r.applyBootConfiguration(ctx, log, server, claim); err != nil { + if err = r.applyBootConfiguration(ctx, server, claim); err != nil { return ctrl.Result{}, fmt.Errorf("failed to apply boot configuration: %w", err) } log.V(1).Info("Applied BootConfiguration for ServerClaim") @@ -177,7 +178,7 @@ func (r *ServerClaimReconciler) reconcile(ctx context.Context, log logr.Logger, } log.V(1).Info("Patched ServerClaim phase", "Phase", claim.Status.Phase) - if modified, err := r.ensurePowerStateForServer(ctx, log, claim, server); err != nil || modified { + if modified, err := r.ensurePowerStateForServer(ctx, claim, server); err != nil || modified { return ctrl.Result{}, err } log.V(1).Info("Ensured PowerState for Server", "Server", server.Name) @@ -186,7 +187,8 @@ func (r *ServerClaimReconciler) reconcile(ctx context.Context, log logr.Logger, return ctrl.Result{}, nil } -func (r *ServerClaimReconciler) ensureObjectRefForServer(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim, server *metalv1alpha1.Server) error { +func (r *ServerClaimReconciler) ensureObjectRefForServer(ctx context.Context, claim *metalv1alpha1.ServerClaim, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server.Spec.ServerClaimRef != nil { log.V(1).Info("Server is already claimed", "Server", server.Name, "Claim", server.Spec.ServerClaimRef.Name) return nil @@ -209,7 +211,8 @@ func (r *ServerClaimReconciler) ensureObjectRefForServer(ctx context.Context, lo return nil } -func (r *ServerClaimReconciler) ensurePowerStateForServer(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerClaimReconciler) ensurePowerStateForServer(ctx context.Context, claim *metalv1alpha1.ServerClaim, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if server.Spec.Power == claim.Spec.Power { return false, nil } @@ -253,7 +256,8 @@ func (r *ServerClaimReconciler) patchServerRef(ctx context.Context, claim *metal return false, fmt.Errorf("failed to patch server ref for claim: server reference is immutable") } -func (r *ServerClaimReconciler) applyBootConfiguration(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server, claim *metalv1alpha1.ServerClaim) error { +func (r *ServerClaimReconciler) applyBootConfiguration(ctx context.Context, server *metalv1alpha1.Server, claim *metalv1alpha1.ServerClaim) error { + log := ctrl.LoggerFrom(ctx) config := &metalv1alpha1.ServerBootConfiguration{} config.Name = claim.Name config.Namespace = claim.Namespace @@ -300,7 +304,8 @@ func (r *ServerClaimReconciler) removeBootConfigRefFromServerAndPowerOff(ctx con return nil } -func (r *ServerClaimReconciler) claimServer(ctx context.Context, log logr.Logger, claim *metalv1alpha1.ServerClaim) (*metalv1alpha1.Server, error) { +func (r *ServerClaimReconciler) claimServer(ctx context.Context, claim *metalv1alpha1.ServerClaim) (*metalv1alpha1.Server, error) { + log := ctrl.LoggerFrom(ctx) serverList := &metalv1alpha1.ServerList{} if err := r.List(ctx, serverList); err != nil { return nil, err @@ -346,7 +351,7 @@ func (r *ServerClaimReconciler) claimServer(ctx context.Context, log logr.Logger // server has to passed all the checks for free server // always select the first matching server // we continue through the loop to find if previously claimed server is also present - if selectedServer == nil && r.isServerClaimable(ctx, log, &server, claim) { + if selectedServer == nil && r.isServerClaimable(ctx, &server, claim) { selectedServer = &server break } @@ -358,7 +363,7 @@ func (r *ServerClaimReconciler) claimServer(ctx context.Context, log logr.Logger // ensureObjectRefForServer() uses a patch with optimistic locking, // so it will not overwrite the claim with a different server, // in case controller-runtimes cached client is not up to date. - err := r.ensureObjectRefForServer(ctx, log, claim, selectedServer) + err := r.ensureObjectRefForServer(ctx, claim, selectedServer) if err != nil { return nil, err } @@ -366,7 +371,8 @@ func (r *ServerClaimReconciler) claimServer(ctx context.Context, log logr.Logger return selectedServer, nil } -func (r *ServerClaimReconciler) isUnderMaintenanceQueue(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) (bool, error) { +func (r *ServerClaimReconciler) isUnderMaintenanceQueue(ctx context.Context, server *metalv1alpha1.Server) (bool, error) { + log := ctrl.LoggerFrom(ctx) if server.Status.State == metalv1alpha1.ServerStateMaintenance || server.Spec.ServerMaintenanceRef != nil { log.V(1).Info("Server in or entering Maintenance, Hence can not be claimed") return true, nil @@ -387,7 +393,8 @@ func (r *ServerClaimReconciler) isUnderMaintenanceQueue(ctx context.Context, log return true, nil } -func (r *ServerClaimReconciler) isServerClaimable(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server, claim *metalv1alpha1.ServerClaim) bool { +func (r *ServerClaimReconciler) isServerClaimable(ctx context.Context, server *metalv1alpha1.Server, claim *metalv1alpha1.ServerClaim) bool { + log := ctrl.LoggerFrom(ctx) if claimRef := server.Spec.ServerClaimRef; claimRef != nil && claimRef.UID != claim.UID { log.V(1).Info("Server claim ref UID does not match claim", "Server", server.Name, "ClaimUID", claimRef.UID) return false @@ -400,7 +407,7 @@ func (r *ServerClaimReconciler) isServerClaimable(ctx context.Context, log logr. log.V(1).Info("Server is not powered off", "Server", server.Name, "PowerState", server.Status.PowerState) return false } - isUnderMaintenance, err := r.isUnderMaintenanceQueue(ctx, log, server) + isUnderMaintenance, err := r.isUnderMaintenanceQueue(ctx, server) // is undergoing maintenance and not in Reserved State, we should not claim this server if err != nil || isUnderMaintenance { log.V(1).Info("Server is undergoing Maintenances", "Server", server.Name, "error", err) diff --git a/internal/controller/servermaintenance_controller.go b/internal/controller/servermaintenance_controller.go index 27df1137..5563bf27 100644 --- a/internal/controller/servermaintenance_controller.go +++ b/internal/controller/servermaintenance_controller.go @@ -7,7 +7,6 @@ import ( "context" "fmt" - "github.com/go-logr/logr" "github.com/ironcore-dev/controller-utils/clientutils" "github.com/ironcore-dev/controller-utils/metautils" metalv1alpha1 "github.com/ironcore-dev/metal-operator/api/v1alpha1" @@ -43,22 +42,22 @@ type ServerMaintenanceReconciler struct { // Reconcile is part of the main kubernetes reconciliation loop which aims to // move the current state of the cluster closer to the desired state. func (r *ServerMaintenanceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) { - log := ctrl.LoggerFrom(ctx) maintenance := &metalv1alpha1.ServerMaintenance{} if err := r.Get(ctx, req.NamespacedName, maintenance); err != nil { return ctrl.Result{}, client.IgnoreNotFound(err) } - return r.reconcileExists(ctx, log, maintenance) + return r.reconcileExists(ctx, maintenance) } -func (r *ServerMaintenanceReconciler) reconcileExists(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { +func (r *ServerMaintenanceReconciler) reconcileExists(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { if !maintenance.DeletionTimestamp.IsZero() { - return r.delete(ctx, log, maintenance) + return r.delete(ctx, maintenance) } - return r.reconcile(ctx, log, maintenance) + return r.reconcile(ctx, maintenance) } -func (r *ServerMaintenanceReconciler) reconcile(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { +func (r *ServerMaintenanceReconciler) reconcile(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciling ServerMaintenance") if maintenance.Spec.ServerRef == nil { @@ -88,24 +87,26 @@ func (r *ServerMaintenanceReconciler) reconcile(ctx context.Context, log logr.Lo return ctrl.Result{}, err } } - return r.ensureServerMaintenanceStateTransition(ctx, log, maintenance) + return r.ensureServerMaintenanceStateTransition(ctx, maintenance) } -func (r *ServerMaintenanceReconciler) ensureServerMaintenanceStateTransition(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { +func (r *ServerMaintenanceReconciler) ensureServerMaintenanceStateTransition(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) switch maintenance.Status.State { case metalv1alpha1.ServerMaintenanceStatePending: - return r.handlePendingState(ctx, log, maintenance) + return r.handlePendingState(ctx, maintenance) case metalv1alpha1.ServerMaintenanceStateInMaintenance: - return r.handleInMaintenanceState(ctx, log, maintenance) + return r.handleInMaintenanceState(ctx, maintenance) case metalv1alpha1.ServerMaintenanceStateFailed: - return r.handleFailedState(log, maintenance) + return r.handleFailedState(ctx, maintenance) default: log.V(1).Info("Unknown ServerMaintenance state, skipping reconciliation", "State", maintenance.Status.State) return ctrl.Result{}, nil } } -func (r *ServerMaintenanceReconciler) handlePendingState(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance) (result ctrl.Result, err error) { +func (r *ServerMaintenanceReconciler) handlePendingState(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance) (result ctrl.Result, err error) { + log := ctrl.LoggerFrom(ctx) server, err := GetServerByName(ctx, r.Client, maintenance.Spec.ServerRef.Name) if err != nil { return ctrl.Result{}, err @@ -120,7 +121,7 @@ func (r *ServerMaintenanceReconciler) handlePendingState(ctx context.Context, lo if server.Spec.ServerClaimRef == nil { log.V(1).Info("Server has no ServerClaim, move to maintenance state right away", "Server", server.Name) - if err = r.updateServerRef(ctx, log, maintenance, server); err != nil { + if err = r.updateServerRef(ctx, maintenance, server); err != nil { return ctrl.Result{}, err } if modified, err := r.patchMaintenanceState(ctx, maintenance, metalv1alpha1.ServerMaintenanceStateInMaintenance); err != nil || modified { @@ -160,7 +161,7 @@ func (r *ServerMaintenanceReconciler) handlePendingState(ctx context.Context, lo if hasAnnotation || hasLabel { log.V(1).Info("Server approved for maintenance", "Server", server.Name) - if err = r.updateServerRef(ctx, log, maintenance, server); err != nil { + if err = r.updateServerRef(ctx, maintenance, server); err != nil { return ctrl.Result{}, err } if modified, err := r.patchMaintenanceState(ctx, maintenance, metalv1alpha1.ServerMaintenanceStateInMaintenance); err != nil || modified { @@ -173,7 +174,7 @@ func (r *ServerMaintenanceReconciler) handlePendingState(ctx context.Context, lo if maintenance.Spec.Policy == metalv1alpha1.ServerMaintenancePolicyEnforced { log.V(1).Info("Enforcing maintenance", "Server", server.Name) - if err := r.updateServerRef(ctx, log, maintenance, server); err != nil { + if err := r.updateServerRef(ctx, maintenance, server); err != nil { return ctrl.Result{}, err } if modified, err := r.patchMaintenanceState(ctx, maintenance, metalv1alpha1.ServerMaintenanceStateInMaintenance); err != nil || modified { @@ -185,13 +186,14 @@ func (r *ServerMaintenanceReconciler) handlePendingState(ctx context.Context, lo return ctrl.Result{}, nil } -func (r *ServerMaintenanceReconciler) handleInMaintenanceState(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { +func (r *ServerMaintenanceReconciler) handleInMaintenanceState(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) server, err := GetServerByName(ctx, r.Client, maintenance.Spec.ServerRef.Name) if err != nil { return ctrl.Result{}, err } - config, err := r.applyServerBootConfiguration(ctx, log, maintenance, server) + config, err := r.applyServerBootConfiguration(ctx, maintenance, server) if err != nil { return ctrl.Result{}, err } @@ -228,7 +230,8 @@ func (r *ServerMaintenanceReconciler) handleInMaintenanceState(ctx context.Conte return ctrl.Result{}, nil } -func (r *ServerMaintenanceReconciler) applyServerBootConfiguration(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance, server *metalv1alpha1.Server) (*metalv1alpha1.ServerBootConfiguration, error) { +func (r *ServerMaintenanceReconciler) applyServerBootConfiguration(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance, server *metalv1alpha1.Server) (*metalv1alpha1.ServerBootConfiguration, error) { + log := ctrl.LoggerFrom(ctx) if maintenance.Spec.ServerBootConfigurationTemplate == nil { log.V(1).Info("No ServerBootConfigurationTemplate specified") return nil, nil @@ -269,7 +272,8 @@ func (r *ServerMaintenanceReconciler) setAndPatchServerPowerState(ctx context.Co return r.Patch(ctx, server, client.MergeFrom(serverBase)) } -func (r *ServerMaintenanceReconciler) updateServerRef(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance, server *metalv1alpha1.Server) error { +func (r *ServerMaintenanceReconciler) updateServerRef(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server.Spec.ServerMaintenanceRef != nil { log.V(1).Info("Server is already in Maintenance", "Server", server.Name, "Maintenance", server.Spec.ServerMaintenanceRef.Name) return nil @@ -290,12 +294,14 @@ func (r *ServerMaintenanceReconciler) updateServerRef(ctx context.Context, log l return nil } -func (r *ServerMaintenanceReconciler) handleFailedState(log logr.Logger, _ *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { +func (r *ServerMaintenanceReconciler) handleFailedState(ctx context.Context, _ *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Reconciled ServerMaintenance in Failed state") return ctrl.Result{}, nil } -func (r *ServerMaintenanceReconciler) delete(ctx context.Context, log logr.Logger, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { +func (r *ServerMaintenanceReconciler) delete(ctx context.Context, maintenance *metalv1alpha1.ServerMaintenance) (ctrl.Result, error) { + log := ctrl.LoggerFrom(ctx) log.V(1).Info("Deleting ServerMaintenance") if maintenance.Spec.ServerRef == nil { return ctrl.Result{}, nil @@ -304,7 +310,7 @@ func (r *ServerMaintenanceReconciler) delete(ctx context.Context, log logr.Logge if err != nil { return ctrl.Result{}, err } - if err := r.cleanup(ctx, log, server); err != nil { + if err := r.cleanup(ctx, server); err != nil { return ctrl.Result{}, err } log.V(1).Info("Removed dependencies") @@ -319,7 +325,8 @@ func (r *ServerMaintenanceReconciler) delete(ctx context.Context, log logr.Logge return ctrl.Result{}, nil } -func (r *ServerMaintenanceReconciler) cleanup(ctx context.Context, log logr.Logger, server *metalv1alpha1.Server) error { +func (r *ServerMaintenanceReconciler) cleanup(ctx context.Context, server *metalv1alpha1.Server) error { + log := ctrl.LoggerFrom(ctx) if server == nil { return nil } diff --git a/test/e2e/e2e_test.go b/test/e2e/e2e_test.go index 99374b15..21dfc43b 100644 --- a/test/e2e/e2e_test.go +++ b/test/e2e/e2e_test.go @@ -216,9 +216,30 @@ var _ = Describe("controller", Ordered, func() { } Eventually(verifyWebhookEndpointsReady, 3*time.Minute, time.Second).Should(Succeed()) + By("verifying the validating webhook server is ready") + verifyValidatingWebhookReady := func(g Gomega) { + cmd := exec.Command("kubectl", "get", "validatingwebhookconfigurations.admissionregistration.k8s.io", + "metal-operator-validating-webhook-configuration", + "-o", "jsonpath={.webhooks[0].clientConfig.caBundle}") + output, err := utils.Run(cmd) + g.Expect(err).NotTo(HaveOccurred(), "ValidatingWebhookConfiguration should exist") + g.Expect(output).ShouldNot(BeEmpty(), "Validating webhook CA bundle not yet injected") + } + Eventually(verifyValidatingWebhookReady, 3*time.Minute, time.Second).Should(Succeed()) + + By("waiting additional time for webhook server to stabilize") + time.Sleep(5 * time.Second) + // +kubebuilder:scaffold:e2e-metrics-webhooks-readiness By("creating the curl-metrics pod to access the metrics endpoint") + curlCmd := fmt.Sprintf( + "for i in $(seq 1 30); do curl -v -k "+ + "-H 'Authorization: Bearer %s' "+ + "https://%s.%s.svc.cluster.local:8443/metrics "+ + "&& exit 0 || sleep 2; done; exit 1", + token, metricsServiceName, namespace, + ) cmd = exec.Command("kubectl", "run", "curl-metrics", "--restart=Never", "--namespace", namespace, "--image=curlimages/curl:latest", @@ -229,7 +250,7 @@ var _ = Describe("controller", Ordered, func() { "name": "curl", "image": "curlimages/curl:latest", "command": ["/bin/sh", "-c"], - "args": ["curl -v -k -H 'Authorization: Bearer %s' https://%s.%s.svc.cluster.local:8443/metrics"], + "args": [%q], "securityContext": { "allowPrivilegeEscalation": false, "capabilities": { @@ -244,7 +265,7 @@ var _ = Describe("controller", Ordered, func() { }], "serviceAccount": "%s" } - }`, token, metricsServiceName, namespace, serviceAccountName)) + }`, curlCmd, serviceAccountName)) _, err = utils.Run(cmd) Expect(err).NotTo(HaveOccurred(), "Failed to create curl-metrics pod") diff --git a/test/utils/utils.go b/test/utils/utils.go index 9759f17a..ddd09c3a 100644 --- a/test/utils/utils.go +++ b/test/utils/utils.go @@ -15,12 +15,11 @@ import ( ) const ( + certmanagerVersion = "v1.19.3" + certmanagerURLTmpl = "https://github.com/cert-manager/cert-manager/releases/download/%s/cert-manager.yaml" prometheusOperatorVersion = "v0.77.1" prometheusOperatorURL = "https://github.com/prometheus-operator/prometheus-operator/" + "releases/download/%s/bundle.yaml" - - certmanagerVersion = "v1.16.3" - certmanagerURLTmpl = "https://github.com/cert-manager/cert-manager/releases/download/%s/cert-manager.yaml" ) func warnError(err error) { @@ -205,7 +204,7 @@ func UncommentCode(filename, target, prefix string) error { idx := strings.Index(strContent, target) if idx < 0 { - return fmt.Errorf("unable to find the code %s to be uncomment", target) + return fmt.Errorf("unable to find the code %q to be uncommented", target) } out := new(bytes.Buffer)