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")

ifeq ($(origin IMAGE_REGISTRY), undefined)

IMAGE_REGISTRY := quay.io/operator-framework

export IMAGE_REGISTRY

ifeq ($(origin OPCON_IMAGE_REPO), undefined)

OPCON_IMAGE_REPO := $(IMAGE_REGISTRY)/operator-controller

export OPCON_IMAGE_REPO

ifeq ($(origin CATD_IMAGE_REPO), undefined)

CATD_IMAGE_REPO := $(IMAGE_REGISTRY)/catalogd

export CATD_IMAGE_REPO

ifeq ($(origin OBJECT_CONTROLLER_IMAGE_REPO), undefined)

OBJECT_CONTROLLER_IMAGE_REPO := $(IMAGE_REGISTRY)/object-controller

export OBJECT_CONTROLLER_IMAGE_REPO

ifeq ($(origin IMAGE_TAG), undefined)

IMAGE_TAG := devel

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)

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/')

ENVTEST_VERSION := $(K8S_VERSION).x

export CERT_MGR_VERSION := v1.18.2

export WAIT_TIMEOUT := 60s

export INSTALL_DEFAULT_CATALOGS := true

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

include .bingo/Variables.mk

_MOCKGEN_BINGO := $(MOCKGEN)

MOCKGEN := $(ROOT_DIR)/bin/mockgen

$(MOCKGEN): $(_MOCKGEN_BINGO)

@mkdir -p $(dir $@)

@ln -sf $< $@

ifeq ($(origin KIND_CLUSTER_NAME), undefined)

KIND_CLUSTER_NAME := operator-controller

ifeq ($(origin KIND_CONFIG), undefined)

KIND_CONFIG := ./kind-config/kind-config.yaml

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

$(warning Could not find docker or podman in path! This may result in targets requiring a container runtime failing!)

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

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

.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)

.PHONY: lint

lint: lint-custom $(GOLANGCI_LINT) #HELP Run golangci linter.

$(GOLANGCI_LINT) run --build-tags $(GO_BUILD_TAGS) $(GOLANGCI_LINT_ARGS)

.PHONY: lint-helm

lint-helm: $(HELM) $(CONFTEST) #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: $(GOLANGCI_LINT) #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

.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

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): $(HELM) $(CONFTEST)

@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

.PHONY: manifests

manifests: update-crds $(MANIFESTS) $(HELM) #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: $(MOCKGEN) #EXHELP Generate mock implementations for testing.

PATH="$(ROOT_DIR)/bin:$$PATH" go generate ./...

.PHONY: generate

generate: $(CONTROLLER_GEN) 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 verify-bingo #HELP Verify all generated code is up-to-date.

git diff --exit-code

.PHONY: verify-bingo

verify-bingo: $(BINGO)

$(BINGO) get -v -t 15

.PHONY: fix-lint

fix-lint: $(GOLANGCI_LINT) #EXHELP Fix lint issues

$(GOLANGCI_LINT) run --fix --build-tags $(GO_BUILD_TAGS) $(GOLANGCI_LINT_ARGS)

.PHONY: fmt

fmt: $(YAMLFMT) #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: $(CRD_DIFF) 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}

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

$(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: $(SETUP_ENVTEST)

mkdir -p $(ROOT_DIR)/bin

$(SETUP_ENVTEST) use -p env $(ENVTEST_VERSION) $(SETUP_ENVTEST_BIN_DIR_OVERRIDE)

.PHONY: test-unit

test-unit: $(SETUP_ENVTEST) 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)

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)

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)))

.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-%: $(KIND) #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-% $(KUBE_SCORE)

(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-% $(HELM)

ifeq ($(strip $(ARTIFACT_PATH)),)

@echo "ARTIFACT_PATH unset; skipping fluent-bit deployment"

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

.PHONY: prometheus-%

prometheus-%: wait-% $(HELM)

ifeq ($(strip $(E2E_SUMMARY_OUTPUT)),)

@echo "E2E_SUMMARY_OUTPUT unset; skipping prometheus deployment"

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

.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

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)

.PHONY: e2e-coverage-%

e2e-coverage-%: e2e-run-%

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

.PHONY: kind-clean-%

kind-clean-%: $(KIND) #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

.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: $(KIND) #EXHELP Regenerate the kindest/node image map in validate_kindest_node.sh.

hack/tools/update-kind-images.sh $(KIND)

ifeq ($(strip $(VERSION)),)

VERSION := $(shell git describe --tags --always --dirty)

export VERSION

ifeq ($(strip $(VERSION)),)

$(error undefined VERSION; resulting certs will be invalid)

ifeq ($(origin CGO_ENABLED), undefined)

CGO_ENABLED := 0

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):

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

ifeq ($(origin ENABLE_RELEASE_PIPELINE), undefined)

ENABLE_RELEASE_PIPELINE := false

ifeq ($(origin GORELEASER_ARGS), undefined)

GORELEASER_ARGS := --snapshot --clean

export ENABLE_RELEASE_PIPELINE

export GORELEASER_ARGS

.PHONY: release

release: $(GORELEASER) #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)

.PHONY: crd-ref-docs

API_REFERENCE_FILENAME := olmv1-api-reference.md

API_REFERENCE_DIR := $(ROOT_DIR)/docs/api-reference

crd-ref-docs: $(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