Makefile

###########################
# Configuration Variables #
###########################
# Setting SHELL to bash allows bash commands to be executed by recipes.
# Options are set to exit when a recipe line exits non-zero or a piped command fails.
SHELL := /usr/bin/env bash -o pipefail
.SHELLFLAGS := -ec
export ROOT_DIR := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))

GOLANG_VERSION := $(shell sed -En 's/^go (.*)$$/\1/p' "go.mod")
# Image URL to use all building/pushing image targets
ifeq ($(origin IMAGE_REGISTRY), undefined)
IMAGE_REGISTRY := quay.io/operator-framework
endif
export IMAGE_REGISTRY

ifeq ($(origin OPCON_IMAGE_REPO), undefined)
OPCON_IMAGE_REPO := $(IMAGE_REGISTRY)/operator-controller
endif
export OPCON_IMAGE_REPO

ifeq ($(origin CATD_IMAGE_REPO), undefined)
CATD_IMAGE_REPO := $(IMAGE_REGISTRY)/catalogd
endif
export CATD_IMAGE_REPO

ifeq ($(origin OBJECT_CONTROLLER_IMAGE_REPO), undefined)
OBJECT_CONTROLLER_IMAGE_REPO := $(IMAGE_REGISTRY)/object-controller
endif
export OBJECT_CONTROLLER_IMAGE_REPO

ifeq ($(origin IMAGE_TAG), undefined)
IMAGE_TAG := devel
endif
export IMAGE_TAG

OPCON_IMG := $(OPCON_IMAGE_REPO):$(IMAGE_TAG)
CATD_IMG := $(CATD_IMAGE_REPO):$(IMAGE_TAG)
OBJECT_CONTROLLER_IMG := $(OBJECT_CONTROLLER_IMAGE_REPO):$(IMAGE_TAG)

# Extract Kubernetes client-go version used to set the version to the PSA labels, for ENVTEST and KIND
ifeq ($(origin K8S_VERSION), undefined)
K8S_VERSION := $(shell go list -m k8s.io/client-go | awk '{print $$NF}' | sed -E 's/^v0\.([0-9]+)\.[0-9]+$$/1.\1/')
endif

# Ensure ENVTEST_VERSION follows correct "X.Y.x" format
ENVTEST_VERSION := $(K8S_VERSION).x

# Define dependency versions (use go.mod if we also use Go code from dependency)
export CERT_MGR_VERSION := v1.18.2
export WAIT_TIMEOUT := 60s

# Install default ClusterCatalogs
export INSTALL_DEFAULT_CATALOGS := true

# By default setup-envtest binary will write to $XDG_DATA_HOME, or $HOME/.local/share if that is not defined.
# If $HOME is not set, we need to specify a binary directory to prevent an error in setup-envtest.
# Useful for some CI/CD environments that set neither $XDG_DATA_HOME nor $HOME.
SETUP_ENVTEST_BIN_DIR_OVERRIDE += --bin-dir $(ROOT_DIR)/bin/envtest-binaries
ifeq ($(shell [[ $$HOME == "" || $$HOME == "/" ]] && [[ $$XDG_DATA_HOME == "" ]] && echo true ), true)
	SETUP_ENVTEST_BIN_DIR_OVERRIDE += --bin-dir /tmp/envtest-binaries
endif

# Tool versions are pinned by go.mod.
CONFTEST := go tool conftest
CONTROLLER_GEN := go tool controller-gen
CRD_DIFF := go tool crdify
CRD_REF_DOCS := go tool crd-ref-docs
GOLANGCI_LINT := go tool golangci-lint
GORELEASER := go tool goreleaser
HELM := go tool helm
KIND := go tool kind
KUBE_SCORE := go tool kube-score
MOCKGEN := go tool mockgen
SETUP_ENVTEST := go tool setup-envtest
YAMLFMT := go tool yamlfmt

# These commands need build tags, which go tool does not accept.
OPERATOR_SDK := $(ROOT_DIR)/bin/operator-sdk
OPM := $(ROOT_DIR)/bin/opm
OPERATOR_SDK_VERSION := $(shell go list -m -f '{{.Version}}' github.com/operator-framework/operator-sdk)
$(OPERATOR_SDK): go.mod go.sum
	@mkdir -p $(dir $@)
	go build -tags=containers_image_openpgp -ldflags=-X=github.com/operator-framework/operator-sdk/internal/version.Version=$(OPERATOR_SDK_VERSION) -o $@ github.com/operator-framework/operator-sdk/cmd/operator-sdk
$(OPM): go.mod go.sum
	@mkdir -p $(dir $@)
	go build -tags=containers_image_openpgp -o $@ github.com/operator-framework/operator-registry/cmd/opm

ifeq ($(origin KIND_CLUSTER_NAME), undefined)
KIND_CLUSTER_NAME := operator-controller
endif

ifeq ($(origin KIND_CONFIG), undefined)
KIND_CONFIG := ./kind-config/kind-config.yaml
endif

KUBECONFIG_DIR := $(ROOT_DIR)/.kubeconfig

ifneq (, $(shell command -v docker 2>/dev/null))
CONTAINER_RUNTIME := docker
else ifneq (, $(shell command -v podman 2>/dev/null))
CONTAINER_RUNTIME := podman
else
$(warning Could not find docker or podman in path! This may result in targets requiring a container runtime failing!)
endif

export STANDARD_RELEASE_MANIFEST := operator-controller.yaml
export STANDARD_RELEASE_INSTALL := install.sh
export EXPERIMENTAL_RELEASE_MANIFEST := operator-controller-experimental.yaml
export EXPERIMENTAL_RELEASE_INSTALL := install-experimental.sh
export RELEASE_CATALOGS := default-catalogs.yaml

# List of manifests that are checked in
MANIFEST_HOME := manifests
STANDARD_MANIFEST := $(MANIFEST_HOME)/standard.yaml
STANDARD_E2E_MANIFEST := $(MANIFEST_HOME)/standard-e2e.yaml
EXPERIMENTAL_MANIFEST := $(MANIFEST_HOME)/experimental.yaml
EXPERIMENTAL_E2E_MANIFEST := $(MANIFEST_HOME)/experimental-e2e.yaml
CATALOGS_MANIFEST := $(MANIFEST_HOME)/default-catalogs.yaml

.DEFAULT_GOAL := build

#SECTION General

# The help target prints out all targets with their descriptions organized
# beneath their categories. The categories are represented by '#SECTION' and the
# target descriptions by '#HELP' or '#EXHELP'. The awk commands is responsible for reading the
# entire set of makefiles included in this invocation, looking for lines of the
# file as xyz: #HELP something, and then pretty-format the target and help. Then,
# if there's a line with #SECTION something, that gets pretty-printed as a category.
# More info on the usage of ANSI control characters for terminal formatting:
# https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters
# More info on the awk command:
# http://linuxcommand.org/lc3_adv_awk.php
# The extended-help target uses '#EXHELP' as the delineator.

.PHONY: help
help: #HELP Display essential help.
	@awk 'BEGIN {FS = ":[^#]*#HELP"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n\n"} /^[a-zA-Z_0-9\/%-]+:.*#HELP / { printf "  \033[36m%-21s\033[0m %s\n", $$1, $$2 } ' $(MAKEFILE_LIST)

.PHONY: help-extended
help-extended: #HELP Display extended help.
	@awk 'BEGIN {FS = ":.*#(EX)?HELP"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n"} /^[a-zA-Z_0-9\/%-]+:.*#(EX)?HELP / { printf "  \033[36m%-25s\033[0m %s\n", $$1, $$2 } /^#SECTION / { printf "\n\033[1m%s\033[0m\n", substr($$0, 10) } ' $(MAKEFILE_LIST)

#SECTION Development

.PHONY: lint
lint: lint-custom #HELP Run golangci linter.
	$(GOLANGCI_LINT) run --build-tags $(GO_BUILD_TAGS) $(GOLANGCI_LINT_ARGS)

.PHONY: lint-helm
lint-helm: #HELP Run helm linter
	$(HELM) lint helm/olmv1
	(set -euo pipefail; $(HELM) template olmv1 helm/olmv1) | $(CONFTEST) test --policy hack/conftest/policy/ --combine -n main -

.PHONY: custom-linter-build
custom-linter-build: #EXHELP Build custom linter
	go build -tags $(GO_BUILD_TAGS) -o ./bin/custom-linter ./hack/ci/custom-linters/cmd

.PHONY: lint-custom
lint-custom: custom-linter-build #EXHELP Call custom linter for the project
	go vet -tags=$(GO_BUILD_TAGS) -vettool=./bin/custom-linter ./...

.PHONY: lint-api-diff
lint-api-diff: #HELP Validate API changes using kube-api-linter with diff-aware analysis
	hack/api-lint-diff/run.sh

.PHONY: tidy #HELP Run go mod tidy.
tidy:
	go mod tidy

# Due to https://github.com/kubernetes-sigs/controller-tools/issues/837 we can't specify individual files
# So we have to generate them together and then move them into place
.PHONY: update-crds
update-crds:
	hack/tools/update-crds.sh
	@# Revert CRD files where the only change is the controller-gen version annotation
	@for f in $$(git diff --name-only -- helm/ hack/tools/crd-generator/testdata/); do \
		git diff --quiet -I 'controller-gen.kubebuilder.io/version' -- "$$f" && git restore --worktree -- "$$f" || true; \
	done

# The filename variables can be overridden on the command line if you want to change the set of values files:
# e.g. make "manifests/standard.yaml=helm/cert-manager.yaml my-values-file.yaml" manifests
#
# The set of MANIFESTS to be generated can be changed; you can generate your own custom manifest
# e.g. make MANIFESTS=test.yaml "test.yaml=helm/e2e.yaml" manifests
#
# Override HELM_SETTINGS on the command line to include additional Helm settings
# e.g. make HELM_SETTINGS="options.openshift.enabled=true" manifests
# e.g. make HELM_SETTINGS="options.operatorController.features.enabled={WebhookProviderCertManager}" manifests
#
MANIFESTS ?= $(STANDARD_MANIFEST) $(STANDARD_E2E_MANIFEST) $(EXPERIMENTAL_MANIFEST) $(EXPERIMENTAL_E2E_MANIFEST)
$(STANDARD_MANIFEST) ?= helm/cert-manager.yaml
$(STANDARD_E2E_MANIFEST) ?= helm/cert-manager.yaml helm/e2e.yaml
$(EXPERIMENTAL_MANIFEST) ?= helm/cert-manager.yaml helm/experimental.yaml
$(EXPERIMENTAL_E2E_MANIFEST) ?= helm/cert-manager.yaml helm/experimental.yaml helm/e2e.yaml
HELM_SETTINGS ?=
.PHONY: $(MANIFESTS)
$(MANIFESTS):
	@mkdir -p $(MANIFEST_HOME)
	$(HELM) template olmv1 helm/olmv1 $(addprefix --values ,$($@)) $(addprefix --set ,$(HELM_SETTINGS)) > $@
	$(CONFTEST) test --policy hack/conftest/policy/ -n main --combine $@
	@# Revert manifest if the only change is the controller-gen version annotation
	@git diff --quiet -I 'controller-gen.kubebuilder.io/version' -- "$@" && git restore --worktree -- "$@" || true

# Generate manifests stored in source-control
.PHONY: manifests
manifests: update-crds $(MANIFESTS) #EXHELP Generate OLMv1 manifests
	# These are testing existing manifest options without saving the results
	$(HELM) template olmv1 helm/olmv1 --values helm/tilt.yaml $(addprefix --set ,$(HELM_SETTINGS)) > /dev/null
	$(HELM) template olmv1 helm/olmv1 --set "options.openshift.enabled=true" > /dev/null

.PHONY: generate-mocks
generate-mocks: #EXHELP Generate mock implementations for testing.
	go generate ./...

.PHONY: generate
generate: generate-mocks #EXHELP Generate code containing DeepCopy, DeepCopyInto, DeepCopyObject, and ApplyConfiguration type implementations.
	# Need to delete the files for them to be generated properly
	@find api cmd hack internal -name "zz_generated.deepcopy.go" -not -path "*/vendor/*" -delete && rm -rf applyconfigurations
	$(CONTROLLER_GEN) --load-build-tags=$(GO_BUILD_TAGS) applyconfiguration:headerFile="hack/boilerplate.go.txt" paths="./api/..."
	$(CONTROLLER_GEN) --load-build-tags=$(GO_BUILD_TAGS) object:headerFile="hack/boilerplate.go.txt" paths="./..."
	@# Revert generated files where the only change is the controller-gen version comment
	@for f in $$(git diff --name-only); do \
		git diff --quiet -I 'Code generated by controller-gen' -- "$$f" && git restore --worktree -- "$$f" || true; \
	done

.PHONY: verify
verify: tidy kind-verify-versions fmt generate manifests update-tls-profiles crd-ref-docs update-registryv1-bundle-schema #HELP Verify all generated code is up-to-date.
	git diff --exit-code

.PHONY: fix-lint
fix-lint: #EXHELP Fix lint issues
	$(GOLANGCI_LINT) run --fix --build-tags $(GO_BUILD_TAGS) $(GOLANGCI_LINT_ARGS)

.PHONY: fmt
fmt: #EXHELP Formats code
	go fmt ./...
	$(YAMLFMT) -gitignore_excludes testdata

.PHONY: update-tls-profiles
update-tls-profiles: #EXHELP Update TLS profiles from the Mozilla wiki
	hack/tools/update-tls-profiles.sh

.PHONY: update-registryv1-bundle-schema
update-registryv1-bundle-schema: #EXHELP Update registry+v1 bundle configuration JSON schema
	hack/tools/update-registryv1-bundle-schema.sh

.PHONY: verify-crd-compatibility
CRD_DIFF_ORIGINAL_REF := git://main?path=
CRD_DIFF_UPDATED_REF := file://
CRD_DIFF_OPCON_SOURCE := helm/olmv1/base/operator-controller/crd/standard/olm.operatorframework.io_clusterextensions.yaml
CRD_DIFF_CATD_SOURCE := helm/olmv1/base/catalogd/crd/standard/olm.operatorframework.io_clustercatalogs.yaml
CRD_DIFF_CONFIG := crd-diff-config.yaml
verify-crd-compatibility: manifests
	$(CRD_DIFF) --config="${CRD_DIFF_CONFIG}" "${CRD_DIFF_ORIGINAL_REF}${CRD_DIFF_OPCON_SOURCE}" ${CRD_DIFF_UPDATED_REF}${CRD_DIFF_OPCON_SOURCE}
	$(CRD_DIFF) --config="${CRD_DIFF_CONFIG}" "${CRD_DIFF_ORIGINAL_REF}${CRD_DIFF_CATD_SOURCE}" ${CRD_DIFF_UPDATED_REF}${CRD_DIFF_CATD_SOURCE}

#SECTION Test

define install-sh
.PHONY: $(1)/install.sh
$(1)/install.sh: manifests
	@echo -e "\n\U1F4D8 Using $(1).yaml as source manifest\n"
	sed "s/cert-git-version/cert-$$(VERSION)/g" manifests/$(1).yaml > $(2)
	MANIFEST=$(2) INSTALL_DEFAULT_CATALOGS=false DEFAULT_CATALOG=$$(RELEASE_CATALOGS) envsubst '$$$$DEFAULT_CATALOG,$$$$CERT_MGR_VERSION,$$$$INSTALL_DEFAULT_CATALOGS,$$$$MANIFEST' < scripts/install.tpl.sh > $(1)-install.sh
endef

$(eval $(call install-sh,experimental,operator-controller-experimental.yaml))
$(eval $(call install-sh,standard,operator-controller-standard.yaml))

.PHONY: test
test: manifests generate fmt lint test-unit test-e2e test-regression #HELP Run all tests.

export CLUSTER_REGISTRY_HOST := docker-registry.operator-controller-e2e.svc:5000
.PHONY: extension-developer-e2e
extension-developer-e2e: export OPERATOR_SDK := $(OPERATOR_SDK)
extension-developer-e2e: export CONTAINER_RUNTIME := $(CONTAINER_RUNTIME)
extension-developer-e2e: $(OPERATOR_SDK) #EXHELP Run extension create, upgrade and delete tests.
	go test -count=1 -v ./test/extension-developer-e2e/...

UNIT_TEST_DIRS := $(shell go list ./... | grep -vE "/test/|/testutils|/testutil/mock") $(shell go list ./test/internal/...)
COVERAGE_PKGS := $(shell go list ./... | grep -vE "/test/|/testutils|/testutil/mock" | paste -sd, -)
COVERAGE_UNIT_DIR := $(ROOT_DIR)/coverage/unit

.PHONY: envtest-k8s-bins #HELP Uses setup-envtest to download and install the binaries required to run ENVTEST-test based locally at the project/bin directory.
envtest-k8s-bins:
	mkdir -p $(ROOT_DIR)/bin
	$(SETUP_ENVTEST) use -p env $(ENVTEST_VERSION) $(SETUP_ENVTEST_BIN_DIR_OVERRIDE)

.PHONY: test-unit
test-unit: envtest-k8s-bins #HELP Run the unit tests
	rm -rf $(COVERAGE_UNIT_DIR) && mkdir -p $(COVERAGE_UNIT_DIR)
	KUBEBUILDER_ASSETS="$(shell $(SETUP_ENVTEST) use -p path $(ENVTEST_VERSION) $(SETUP_ENVTEST_BIN_DIR_OVERRIDE))" \
            CGO_ENABLED=1 go test \
                -tags '$(GO_BUILD_TAGS)' \
                -cover -coverpkg=$(COVERAGE_PKGS) -coverprofile ${ROOT_DIR}/coverage/unit.out \
                -count=1 -race -short \
                $(UNIT_TEST_DIRS) \
                -test.gocoverdir=$(COVERAGE_UNIT_DIR) \
                | sed -E 's/ of statements in .*/ of statements/'

COVERAGE_REGRESSION_DIR := $(ROOT_DIR)/coverage/regression
.PHONY: test-regression
test-regression: #HELP Run regression test
	rm -rf $(COVERAGE_REGRESSION_DIR) && mkdir -p $(COVERAGE_REGRESSION_DIR)
	go test -count=1 -v ./test/regression/... -cover -coverprofile ${ROOT_DIR}/coverage/regression.out -test.gocoverdir=$(COVERAGE_REGRESSION_DIR)


# When running the e2e suite, you can set the ARTIFACT_PATH variable to the absolute path
# of the directory for the operator-controller e2e tests to store the artifacts, which
# may be helpful for debugging purposes after a test run.
#
# for example: ARTIFACT_PATH=/tmp/artifacts make test-e2e
#
# E2E targets use pattern rules (kind-cluster-%, kind-load-%, etc.) with the stem
# identifying the variant (e2e, experimental-e2e). Each variant runs on its own KIND
# cluster, enabling parallel execution via make -j2 test-e2e test-experimental-e2e.
#
# Parallel runs require sufficient inotify instances for multiple KIND clusters:
#   sudo sysctl fs.inotify.max_user_instances=512
# To persist: echo "fs.inotify.max_user_instances=512" | sudo tee /etc/sysctl.d/99-kind.conf
#
ifneq (,$(and $(findstring -j,$(MAKEFLAGS)),$(findstring test-e2e,$(MAKECMDGOALS)),$(findstring test-experimental-e2e,$(MAKECMDGOALS)),$(findstring Linux,$(shell uname))))
$(info NOTE: Running both standard and experimental e2e tests in parallel requires fs.inotify.max_user_instances>=512 (current: $(shell sysctl -n fs.inotify.max_user_instances)))
endif

# Variant-specific overrides on top-level targets propagate down through the entire chain.
# The stem ($*) in pattern rules IS the cluster name (e.g., operator-controller-e2e).
.PHONY: test-e2e test-experimental-e2e
test-e2e: GO_BUILD_EXTRA_FLAGS := -cover
test-e2e: SOURCE_MANIFEST := $(STANDARD_E2E_MANIFEST)
test-e2e: export MANIFEST := $(STANDARD_RELEASE_MANIFEST)
test-e2e: export DEFAULT_CATALOG := $(CATALOGS_MANIFEST)
test-e2e: export INSTALL_DEFAULT_CATALOGS := false
test-experimental-e2e: GO_BUILD_EXTRA_FLAGS := -cover
test-experimental-e2e: KIND_CONFIG := ./kind-config/kind-config-2node.yaml
test-experimental-e2e: SOURCE_MANIFEST := $(EXPERIMENTAL_E2E_MANIFEST)
test-experimental-e2e: export MANIFEST := $(EXPERIMENTAL_RELEASE_MANIFEST)
test-experimental-e2e: export DEFAULT_CATALOG := $(CATALOGS_MANIFEST)
test-experimental-e2e: export INSTALL_DEFAULT_CATALOGS := false
test-experimental-e2e: E2E_PROMETHEUS_VALUES := testdata/prometheus/values-experimental.yaml
test-experimental-e2e: E2E_TIMEOUT ?= 25m
e2e-setup: SOURCE_MANIFEST := $(STANDARD_E2E_MANIFEST)
e2e-setup: export MANIFEST := $(STANDARD_RELEASE_MANIFEST)
e2e-setup: export DEFAULT_CATALOG := $(CATALOGS_MANIFEST)
e2e-setup: export INSTALL_DEFAULT_CATALOGS := false
experimental-e2e-setup: KIND_CONFIG := ./kind-config/kind-config-2node.yaml
experimental-e2e-setup: SOURCE_MANIFEST := $(EXPERIMENTAL_E2E_MANIFEST)
experimental-e2e-setup: export MANIFEST := $(EXPERIMENTAL_RELEASE_MANIFEST)
experimental-e2e-setup: export DEFAULT_CATALOG := $(CATALOGS_MANIFEST)
experimental-e2e-setup: export INSTALL_DEFAULT_CATALOGS := false

E2E_KUBECONFIG = $(KUBECONFIG_DIR)/$*.kubeconfig

CATALOGD_CERT_SECRET = catalogd-service-cert-$(VERSION)

.PHONY: kind-cluster-%
kind-cluster-%: #EXHELP Create a kind cluster named after the stem (%).
	@KIND_NODE_IMAGE=$$(K8S_VERSION=$(K8S_VERSION) $(VALIDATE_KINDEST_NODE_SCRIPT)) || exit 1; \
	$(KIND) delete cluster --name $* 2>/dev/null || true; \
	$(KIND) create cluster --name $* --config $(KIND_CONFIG) --image "$$KIND_NODE_IMAGE"; \
	mkdir -p $(KUBECONFIG_DIR); \
	KUBECONFIG=$(E2E_KUBECONFIG) $(KIND) export kubeconfig --name $*; \
	KUBECONFIG=$(E2E_KUBECONFIG) kubectl wait --for=condition=Ready nodes --all --timeout=2m

.PHONY: kind-load-%
kind-load-%: kind-cluster-% docker-build
	$(KIND) load docker-image $(OPCON_IMG) --name $*
	$(KIND) load docker-image $(CATD_IMG) --name $*
	$(KIND) load docker-image $(OBJECT_CONTROLLER_IMG) --name $*

.PHONY: kind-deploy-%
kind-deploy-%: kind-load-% manifests
	@echo "Using $(SOURCE_MANIFEST) as source manifest"
	sed "s/cert-git-version/cert-$(VERSION)/g" $(SOURCE_MANIFEST) > $(MANIFEST)
	cp $(CATALOGS_MANIFEST) $(RELEASE_CATALOGS)
	export KUBECONFIG=$(E2E_KUBECONFIG) \
		DEFAULT_CATALOG=$(DEFAULT_CATALOG) \
		CERT_MGR_VERSION=$(CERT_MGR_VERSION) \
		INSTALL_DEFAULT_CATALOGS=$(INSTALL_DEFAULT_CATALOGS) \
		MANIFEST=$(MANIFEST); \
	envsubst '$$DEFAULT_CATALOG,$$CERT_MGR_VERSION,$$INSTALL_DEFAULT_CATALOGS,$$MANIFEST' < scripts/install.tpl.sh | bash -s

.PHONY: lint-deployed-%
lint-deployed-%: kind-deploy-%
	(export KUBECONFIG=$(E2E_KUBECONFIG); \
	for ns in $$(printf "olmv1-system\n%s\n" "$(CATD_NAMESPACE)" | uniq); do \
		for resource in $$(kubectl api-resources --verbs=list --namespaced -o name); do \
			kubectl get $$resource -n $$ns -o yaml ; \
			echo "---" ; \
		done \
	done) | $(KUBE_SCORE) score - \
		--ignore-test container-resources \
		--ignore-test container-image-pull-policy \
		--ignore-test container-ephemeral-storage-request-and-limit \
		--ignore-test container-security-context-user-group-id

.PHONY: wait-%
wait-%: lint-deployed-%
	KUBECONFIG=$(E2E_KUBECONFIG) kubectl wait --for=condition=Available --namespace=$(CATD_NAMESPACE) deployment/catalogd-controller-manager --timeout=60s
	KUBECONFIG=$(E2E_KUBECONFIG) kubectl wait --for=condition=Ready --namespace=$(CATD_NAMESPACE) certificate/catalogd-service-cert

.PHONY: fluentbit-%
fluentbit-%: wait-%
ifeq ($(strip $(ARTIFACT_PATH)),)
	@echo "ARTIFACT_PATH unset; skipping fluent-bit deployment"
else
	KUBECONFIG=$(E2E_KUBECONFIG) $(HELM) upgrade --install fluent-bit oci://ghcr.io/fluent/helm-charts/fluent-bit \
	  --namespace $(FLUENTBIT_NAMESPACE) --create-namespace \
	  --version $(FLUENTBIT_CHART_VERSION) \
	  -f testdata/fluentbit/values.yaml \
	  --wait --timeout 2m
endif

.PHONY: prometheus-%
prometheus-%: wait-%
ifeq ($(strip $(E2E_SUMMARY_OUTPUT)),)
	@echo "E2E_SUMMARY_OUTPUT unset; skipping prometheus deployment"
else
	KUBECONFIG=$(E2E_KUBECONFIG) $(HELM) upgrade --install prometheus oci://ghcr.io/prometheus-community/charts/kube-prometheus-stack \
	  --namespace $(PROMETHEUS_NAMESPACE) --create-namespace \
	  --version $(PROMETHEUS_CHART_VERSION) \
	  -f testdata/prometheus/values.yaml \
	  $(if $(E2E_PROMETHEUS_VALUES),-f $(E2E_PROMETHEUS_VALUES)) \
	  --set-string 'prometheus.additionalServiceMonitors[1].endpoints[0].tlsConfig.ca.secret.name=$(CATALOGD_CERT_SECRET)' \
	  --set-string 'prometheus.additionalServiceMonitors[1].endpoints[0].tlsConfig.cert.secret.name=$(CATALOGD_CERT_SECRET)' \
	  --set-string 'prometheus.additionalServiceMonitors[1].endpoints[0].tlsConfig.keySecret.name=$(CATALOGD_CERT_SECRET)' \
	  --wait --timeout 5m
endif

.PHONY: e2e-run-%
e2e-run-%: GODOG_ARGS ?=
e2e-run-%: prometheus-% fluentbit-%
ifeq ($(strip $(GODOG_ARGS)),)
	E2E_PROMETHEUS_PORT=$$(grep -A1 'containerPort: 30900' $(KIND_CONFIG) | grep hostPort | awk '{print $$2}'); \
	if [[ -z "$$E2E_PROMETHEUS_PORT" ]]; then echo "error: failed to extract prometheus hostPort from $(KIND_CONFIG)" >&2; exit 1; fi; \
	trap 'exit 130' INT; \
	set +e; \
	KUBECONFIG=$(E2E_KUBECONFIG) \
	PROMETHEUS_URL=http://localhost:$$E2E_PROMETHEUS_PORT \
	go test -count=1 -v ./test/e2e/features_test.go -timeout $(or $(E2E_TIMEOUT),20m) -args --godog.tags="~@Serial && ~@demo" --godog.concurrency=100; \
	parallelExit=$$?; \
	KUBECONFIG=$(E2E_KUBECONFIG) \
	PROMETHEUS_URL=http://localhost:$$E2E_PROMETHEUS_PORT \
	go test -count=1 -v ./test/e2e/features_test.go -timeout $(or $(E2E_TIMEOUT),20m) -args --godog.tags="@Serial && ~@demo" --godog.concurrency=1; \
	serialExit=$$?; \
	if [[ $$parallelExit -ne 0 ]] || [[ $$serialExit -ne 0 ]]; then \
		echo "e2e tests failed: parallel=$$parallelExit serial=$$serialExit"; \
		exit 1; \
	fi
else
	E2E_PROMETHEUS_PORT=$$(grep -A1 'containerPort: 30900' $(KIND_CONFIG) | grep hostPort | awk '{print $$2}'); \
	if [[ -z "$$E2E_PROMETHEUS_PORT" ]]; then echo "error: failed to extract prometheus hostPort from $(KIND_CONFIG)" >&2; exit 1; fi; \
	KUBECONFIG=$(E2E_KUBECONFIG) \
	PROMETHEUS_URL=http://localhost:$$E2E_PROMETHEUS_PORT \
	go test -count=1 -v ./test/e2e/features_test.go -timeout=$(or $(E2E_TIMEOUT),20m) -args $(GODOG_ARGS)
endif

.PHONY: e2e-coverage-%
e2e-coverage-%: e2e-run-%
	KUBECONFIG=$(E2E_KUBECONFIG) COVERAGE_NAME=$* ./hack/test/e2e-coverage.sh

.PHONY: kind-clean-%
kind-clean-%: #EXHELP Delete the kind cluster named after the stem (%).
	$(KIND) delete cluster --name $*

test-e2e: e2e-coverage-operator-controller-e2e #HELP Run e2e test suite on local kind cluster
	-$(KIND) delete cluster --name operator-controller-e2e
test-experimental-e2e: e2e-coverage-operator-controller-experimental-e2e #HELP Run experimental e2e test suite on local kind cluster
	-$(KIND) delete cluster --name operator-controller-experimental-e2e

.PHONY: e2e-setup
e2e-setup: wait-operator-controller-e2e #EXHELP Create a KIND cluster with standard OLM deployed for iterative e2e testing.

.PHONY: experimental-e2e-setup
experimental-e2e-setup: wait-operator-controller-experimental-e2e #EXHELP Create a KIND cluster with experimental OLM deployed for iterative e2e testing.

.PHONY: e2e-teardown experimental-e2e-teardown
e2e-teardown: kind-clean-operator-controller-e2e #EXHELP Delete the standard e2e KIND cluster.
experimental-e2e-teardown: kind-clean-operator-controller-experimental-e2e #EXHELP Delete the experimental e2e KIND cluster.

.PHONY: e2e/%
e2e/%: E2E_TIMEOUT ?= 20m
e2e/%: KUBECONFIG ?= $(KUBECONFIG_DIR)/operator-controller-e2e.kubeconfig
e2e/%: #EXHELP Run e2e scenario against a cluster created by e2e-setup or experimental-e2e-setup (tear down with e2e-teardown).
	@feature=$$(echo "$*" | cut -d/ -f1); \
	scenario=$$(echo "$*" | cut -d/ -f2-); \
	if [ "$$scenario" = "$$feature" ]; then scenario=""; fi; \
	KUBECONFIG=$(KUBECONFIG) go test -count=1 -v ./test/e2e/features_test.go \
	  -timeout $(E2E_TIMEOUT) \
	  -args --godog.concurrency=1 --e2e.scenario="$$scenario" "features/$$feature.feature"

.PHONY: test-extension-developer-e2e
test-extension-developer-e2e: SOURCE_MANIFEST := $(STANDARD_E2E_MANIFEST)
test-extension-developer-e2e: export MANIFEST := $(STANDARD_RELEASE_MANIFEST)
test-extension-developer-e2e: export DEFAULT_CATALOG := $(RELEASE_CATALOGS)
test-extension-developer-e2e: export INSTALL_DEFAULT_CATALOGS := false
test-extension-developer-e2e: wait-operator-controller-ext-dev-e2e extension-developer-e2e #HELP Run extension-developer e2e on local kind cluster
	-$(KIND) delete cluster --name operator-controller-ext-dev-e2e

.PHONY: run-latest-release
run-latest-release:
	@echo -e "\n\U23EC Using $(RELEASE_INSTALL) as release installer\n"
	curl -L -s https://github.com/operator-framework/operator-controller/releases/latest/download/$(notdir $(RELEASE_INSTALL)) | bash -s

.PHONY: test-upgrade-e2e
test-upgrade-e2e:
	RELEASE_INSTALL=$(RELEASE_INSTALL) \
	RELEASE_UPGRADE=$(RELEASE_UPGRADE) \
	KIND_CLUSTER_NAME=$(KIND_CLUSTER_NAME) \
	KUBECONFIG=$(KUBECONFIG_DIR)/$(KIND_CLUSTER_NAME).kubeconfig \
	ROOT_DIR=$(ROOT_DIR) \
	go test -count=1 -v ./test/upgrade-e2e/upgrade_test.go


.PHONY: test-upgrade-st2st-e2e
test-upgrade-st2st-e2e: RELEASE_INSTALL := https://github.com/operator-framework/operator-controller/releases/latest/download/install.sh
test-upgrade-st2st-e2e: RELEASE_UPGRADE := $(ROOT_DIR)/standard-install.sh
test-upgrade-st2st-e2e: KIND_CLUSTER_NAME := operator-controller-upgrade-st2st-e2e
test-upgrade-st2st-e2e: standard/install.sh kind-load-operator-controller-upgrade-st2st-e2e test-upgrade-e2e #HELP Run upgrade (standard -> standard) e2e tests on a local kind cluster
	-$(KIND) delete cluster --name operator-controller-upgrade-st2st-e2e

.PHONY: test-upgrade-ex2ex-e2e
test-upgrade-ex2ex-e2e: RELEASE_INSTALL := https://github.com/operator-framework/operator-controller/releases/latest/download/install-experimental.sh
test-upgrade-ex2ex-e2e: KIND_CLUSTER_NAME := operator-controller-upgrade-ex2ex-e2e
test-upgrade-ex2ex-e2e: RELEASE_UPGRADE := $(ROOT_DIR)/experimental-install.sh
test-upgrade-ex2ex-e2e: experimental/install.sh kind-load-operator-controller-upgrade-ex2ex-e2e test-upgrade-e2e #HELP Run upgrade (experimental -> experimental) e2e tests on a local kind cluster
	-$(KIND) delete cluster --name operator-controller-upgrade-ex2ex-e2e

.PHONY: test-upgrade-st2ex-e2e
test-upgrade-st2ex-e2e: RELEASE_INSTALL := https://github.com/operator-framework/operator-controller/releases/latest/download/install.sh
test-upgrade-st2ex-e2e: RELEASE_UPGRADE := $(ROOT_DIR)/experimental-install.sh
test-upgrade-st2ex-e2e: KIND_CLUSTER_NAME := operator-controller-upgrade-st2ex-e2e
test-upgrade-st2ex-e2e: experimental/install.sh kind-load-operator-controller-upgrade-st2ex-e2e test-upgrade-e2e #HELP Run upgrade (standard -> experimental) e2e tests on a local kind cluster
	-$(KIND) delete cluster --name operator-controller-upgrade-st2ex-e2e

.PHONY: test-st2ex-e2e
test-st2ex-e2e: RELEASE_INSTALL := $(ROOT_DIR)/standard-install.sh
test-st2ex-e2e: RELEASE_UPGRADE := $(ROOT_DIR)/experimental-install.sh
test-st2ex-e2e: KIND_CLUSTER_NAME := operator-controller-st2ex-e2e
test-st2ex-e2e: export MANIFEST := $(STANDARD_RELEASE_MANIFEST)
test-st2ex-e2e: export TEST_CLUSTER_CATALOG_NAME := test-catalog
test-st2ex-e2e: export TEST_CLUSTER_EXTENSION_NAME := test-package
test-st2ex-e2e: experimental/install.sh standard/install.sh kind-load-operator-controller-st2ex-e2e test-upgrade-e2e #HELP Run swichover (standard -> experimental) e2e tests on a local kind cluster
	-$(KIND) delete cluster --name operator-controller-st2ex-e2e

TEST_PROFILE_BIN := bin/test-profile
.PHONY: build-test-profiler
build-test-profiler: #EXHELP Build the test profiling tool
	cd hack/tools/test-profiling && go build -o ../../../$(TEST_PROFILE_BIN) ./cmd/test-profile

.PHONY: test-test-profiler
test-test-profiler: #EXHELP Run unit tests for the test profiling tool
	cd hack/tools/test-profiling && go test -v ./...

.PHONY: start-profiling
start-profiling: build-test-profiler #EXHELP Start profiling in background with auto-generated name (timestamp). Use start-profiling/<name> for custom name.
	$(TEST_PROFILE_BIN) start

.PHONY: start-profiling/%
start-profiling/%: build-test-profiler #EXHELP Start profiling in background with specified name. Usage: make start-profiling/<name>
	$(TEST_PROFILE_BIN) start $*

.PHONY: stop-profiling
stop-profiling: build-test-profiler #EXHELP Stop profiling and generate analysis report
	$(TEST_PROFILE_BIN) stop

VALIDATE_KINDEST_NODE_SCRIPT := hack/tools/validate_kindest_node.sh

#SECTION KIND Cluster Operations
# Shortcut targets delegate to pattern rules using $(KIND_CLUSTER_NAME) as the stem.

.PHONY: kind-cluster
kind-cluster: kind-cluster-$(KIND_CLUSTER_NAME) #EXHELP Standup a kind cluster.

.PHONY: kind-load
kind-load: kind-load-$(KIND_CLUSTER_NAME) #EXHELP Loads the currently constructed images into the KIND cluster.

.PHONY: kind-deploy
kind-deploy: export DEFAULT_CATALOG := $(RELEASE_CATALOGS)
kind-deploy: kind-deploy-$(KIND_CLUSTER_NAME) #EXHELP Deploy OLM into the kind cluster.

.PHONY: kind-clean
kind-clean: kind-clean-$(KIND_CLUSTER_NAME) #EXHELP Delete the kind cluster.

.PHONY: wait
wait: wait-$(KIND_CLUSTER_NAME) #EXHELP Wait for OLM deployments to be ready.

.PHONY: kind-verify-versions
kind-verify-versions:
	@K8S_VERSION=$(K8S_VERSION) $(VALIDATE_KINDEST_NODE_SCRIPT) > /dev/null

.PHONY: kind-update-images
kind-update-images: #EXHELP Regenerate the kindest/node image map in validate_kindest_node.sh.
	hack/tools/update-kind-images.sh "$$(go tool -n kind)"


#SECTION Build

# attempt to generate the VERSION attribute for certificates
# fail if it is unset afterwards, since the side effects are indirect
ifeq ($(strip $(VERSION)),)
VERSION := $(shell git describe --tags --always --dirty)
endif
export VERSION
ifeq ($(strip $(VERSION)),)
	$(error undefined VERSION; resulting certs will be invalid)
endif

ifeq ($(origin CGO_ENABLED), undefined)
CGO_ENABLED := 0
endif
export CGO_ENABLED

export GIT_REPO := $(shell go list -m)
export VERSION_PATH := ${GIT_REPO}/internal/shared/version
export GO_BUILD_TAGS := containers_image_openpgp
export GO_BUILD_ASMFLAGS := all=-trimpath=$(PWD)
export GO_BUILD_GCFLAGS := all=-trimpath=$(PWD)
export GO_BUILD_EXTRA_FLAGS :=
export GO_BUILD_LDFLAGS := -s -w \
    -X '$(VERSION_PATH).version=$(VERSION)' \
    -X '$(VERSION_PATH).gitCommit=$(GIT_COMMIT)'

BINARIES=operator-controller catalogd object-controller

.PHONY: $(BINARIES)
$(BINARIES):
	# use double quotes around $(GO_BUILD_LDFLAGS) to avoid conflicts with the
	# single quotes that are embedded inside the variable itself. this prevents
	# malformed arguments such as "malformed import path \" \"" when the git commit is empty.
	go build $(GO_BUILD_FLAGS) $(GO_BUILD_EXTRA_FLAGS) -tags '$(GO_BUILD_TAGS)' -ldflags "$(GO_BUILD_LDFLAGS)" -gcflags '$(GO_BUILD_GCFLAGS)' -asmflags '$(GO_BUILD_ASMFLAGS)' -o $(BUILDBIN)/$@ ./cmd/$@

.PHONY: build-deps
build-deps: manifests generate fmt

.PHONY: build go-build-local
build: build-deps go-build-local #HELP Build manager binary for current GOOS and GOARCH. Default target.
go-build-local: BUILDBIN := bin
go-build-local: $(BINARIES)

.PHONY: build-linux go-build-linux
build-linux: build-deps go-build-linux #EXHELP Build manager binary for GOOS=linux and local GOARCH.
go-build-linux: BUILDBIN := bin/linux
go-build-linux: export GOOS=linux
go-build-linux: $(BINARIES)

.PHONY: run
run: SOURCE_MANIFEST := $(STANDARD_MANIFEST)
run: export MANIFEST := $(STANDARD_RELEASE_MANIFEST)
run: export DEFAULT_CATALOG := $(RELEASE_CATALOGS)
run: wait-$(KIND_CLUSTER_NAME) #HELP Build operator-controller then deploy it with the standard manifest into a new kind cluster.

.PHONY: run-experimental
run-experimental: SOURCE_MANIFEST := $(EXPERIMENTAL_MANIFEST)
run-experimental: export MANIFEST := $(EXPERIMENTAL_RELEASE_MANIFEST)
run-experimental: export DEFAULT_CATALOG := $(RELEASE_CATALOGS)
run-experimental: wait-$(KIND_CLUSTER_NAME) #HELP Build the operator-controller then deploy it with the experimental manifest into a new kind cluster.

CATD_NAMESPACE := olmv1-system
PROMETHEUS_NAMESPACE := olmv1-system
PROMETHEUS_CHART_VERSION := 86.2.2
FLUENTBIT_NAMESPACE := fluent-bit
FLUENTBIT_CHART_VERSION := 0.57.9

.PHONY: docker-build
docker-build: build-linux #EXHELP Build controller images with GOOS=linux and local GOARCH.
	$(CONTAINER_RUNTIME) build -t $(OPCON_IMG) -f Dockerfile.operator-controller ./bin/linux
	$(CONTAINER_RUNTIME) build -t $(CATD_IMG) -f Dockerfile.catalogd ./bin/linux
	$(CONTAINER_RUNTIME) build -t $(OBJECT_CONTROLLER_IMG) -f Dockerfile.object-controller ./bin/linux

#SECTION Release
ifeq ($(origin ENABLE_RELEASE_PIPELINE), undefined)
ENABLE_RELEASE_PIPELINE := false
endif
ifeq ($(origin GORELEASER_ARGS), undefined)
GORELEASER_ARGS := --snapshot --clean
endif

export ENABLE_RELEASE_PIPELINE
export GORELEASER_ARGS

.PHONY: release
release: #EXHELP Runs goreleaser for the operator-controller. By default, this will run only as a snapshot and will not publish any artifacts unless it is run with different arguments. To override the arguments, run with "GORELEASER_ARGS=...". When run as a github action from a tag, this target will publish a full release.
	OPCON_IMAGE_REPO=$(OPCON_IMAGE_REPO) CATD_IMAGE_REPO=$(CATD_IMAGE_REPO) OBJECT_CONTROLLER_IMAGE_REPO=$(OBJECT_CONTROLLER_IMAGE_REPO) $(GORELEASER) $(GORELEASER_ARGS)

.PHONY: quickstart
quickstart: export STANDARD_MANIFEST_URL := "https://github.com/operator-framework/operator-controller/releases/download/$(VERSION)/$(notdir $(STANDARD_RELEASE_MANIFEST))"
quickstart: export EXPERIMENTAL_MANIFEST_URL := "https://github.com/operator-framework/operator-controller/releases/download/$(VERSION)/$(notdir $(EXPERIMENTAL_RELEASE_MANIFEST))"
quickstart: export DEFAULT_CATALOG := "https://github.com/operator-framework/operator-controller/releases/download/$(VERSION)/$(notdir $(RELEASE_CATALOGS))"
quickstart: manifests #EXHELP Generate the unified installation release manifests and scripts.
	# Update the stored standard manifests for distribution
	sed "s/:devel/:$(VERSION)/g" $(STANDARD_MANIFEST) | sed "s/cert-git-version/cert-$(VERSION)/g" > $(STANDARD_RELEASE_MANIFEST)
	sed "s/:devel/:$(VERSION)/g" $(EXPERIMENTAL_MANIFEST) | sed "s/cert-git-version/cert-$(VERSION)/g" > $(EXPERIMENTAL_RELEASE_MANIFEST)
	cp $(CATALOGS_MANIFEST) $(RELEASE_CATALOGS)
	MANIFEST=$(STANDARD_MANIFEST_URL) envsubst '$$DEFAULT_CATALOG,$$CERT_MGR_VERSION,$$INSTALL_DEFAULT_CATALOGS,$$MANIFEST' < scripts/install.tpl.sh > $(STANDARD_RELEASE_INSTALL)
	MANIFEST=$(EXPERIMENTAL_MANIFEST_URL) envsubst '$$DEFAULT_CATALOG,$$CERT_MGR_VERSION,$$INSTALL_DEFAULT_CATALOGS,$$MANIFEST' < scripts/install.tpl.sh > $(EXPERIMENTAL_RELEASE_INSTALL)

##@ Docs

.PHONY: crd-ref-docs
API_REFERENCE_FILENAME := olmv1-api-reference.md
API_REFERENCE_DIR := $(ROOT_DIR)/docs/api-reference
crd-ref-docs: #EXHELP Generate the API Reference Documents.
	rm -f $(API_REFERENCE_DIR)/$(API_REFERENCE_FILENAME)
	$(CRD_REF_DOCS) --source-path=$(ROOT_DIR)/api/ \
	--config=$(API_REFERENCE_DIR)/crd-ref-docs-gen-config.yaml \
	--renderer=markdown --output-path=$(API_REFERENCE_DIR)/$(API_REFERENCE_FILENAME);
	# crd-ref-docs renders doc-comment text verbatim, including internal <opcon:...> generator
	# directives. The reference covers both channels at once, so label the channel-specific
	# description blocks rather than dropping the tags silently -- otherwise a field documented
	# per channel reads as self-contradictory. Remaining directives are stripped.
	sed -E -e 's#<opcon:standard:description>#**Standard channel:** #g' \
		-e 's#<opcon:experimental:description>#**Experimental channel:** #g' \
		-e 's#<opcon:experimental>#**Experimental channel:** #g' \
		-e 's#</?opcon:[^>]*>##g' \
		$(API_REFERENCE_DIR)/$(API_REFERENCE_FILENAME) > $(API_REFERENCE_DIR)/$(API_REFERENCE_FILENAME).tmp
	mv $(API_REFERENCE_DIR)/$(API_REFERENCE_FILENAME).tmp $(API_REFERENCE_DIR)/$(API_REFERENCE_FILENAME)

VENVDIR := $(abspath docs/.venv)

.PHONY: build-docs
build-docs: venv
	. $(VENV)/activate; \
	mkdocs build --strict

.PHONY: serve-docs
serve-docs: venv
	. $(VENV)/activate; \
	mkdocs serve

.PHONY: deploy-docs
deploy-docs: venv
	. $(VENV)/activate; \
	mkdocs gh-deploy --force --strict

DEMO_OUTPUT_DIR ?= $(ROOT_DIR)/docs/demos

.PHONY: update-demos
update-demos: SOURCE_MANIFEST := $(EXPERIMENTAL_E2E_MANIFEST)
update-demos: export MANIFEST := $(EXPERIMENTAL_RELEASE_MANIFEST)
update-demos: export DEFAULT_CATALOG := $(CATALOGS_MANIFEST)
update-demos: export INSTALL_DEFAULT_CATALOGS := true
update-demos: export CATALOG_WAIT_TIMEOUT := 5m
update-demos: wait-operator-controller-experimental-e2e demo-e2e demo-svg experimental-e2e-teardown #EXHELP Record demo scenarios as asciicast and SVG files.

.PHONY: demo-e2e
demo-e2e:
	@command -v curl >/dev/null 2>&1 || { echo "Error: curl not found in PATH."; exit 1; }
	@command -v jq >/dev/null 2>&1 || { echo "Error: jq not found in PATH."; exit 1; }
	@mkdir -p $(DEMO_OUTPUT_DIR)
	KUBECONFIG=$(KUBECONFIG_DIR)/operator-controller-experimental-e2e.kubeconfig \
	DEMO_OUTPUT_DIR=$(DEMO_OUTPUT_DIR) go test -count=1 -v ./test/e2e/features_test.go -timeout 30m \
	  -args --godog.tags="@demo" --godog.concurrency=1

.PHONY: demo-svg
demo-svg: #EXHELP Convert asciicast recordings to SVG.
	@command -v docker >/dev/null 2>&1 || { echo "Error: docker not found in PATH."; exit 1; }
	@for cast in $(DEMO_OUTPUT_DIR)/*.cast; do \
	  svg=$${cast%.cast}.svg; \
	  echo "Converting $$(basename $$cast) -> $$(basename $$svg)"; \
	  docker run --rm -v $(DEMO_OUTPUT_DIR):/data node:alpine \
	    npx --yes svg-term-cli --in /data/$$(basename $$cast) --out /data/$$(basename $$svg) --window; \
	done

include Makefile.venv