IMG ?= claw-operator:latest

PROXY_IMG ?= claw-proxy:latest

KUBECTL_IMG ?= quay.io/openshift/origin-cli:4.21

BUNDLE_IMG ?= claw-operator-bundle:v$(VERSION)

CATALOG_IMG ?= claw-operator-catalog:latest

PLATFORM ?= linux/amd64

VERSION ?= 0.0.0

CHANNELS ?= staging

DEFAULT_CHANNEL ?= staging

BUNDLE_METADATA_OPTS ?= --channels=$(CHANNELS) --default-channel=$(DEFAULT_CHANNEL)

OS = $(shell go env GOOS)

ARCH = $(shell go env GOARCH)

ifeq (,$(shell go env GOBIN))

GOBIN=$(shell go env GOPATH)/bin

GOBIN=$(shell go env GOBIN)

CONTAINER_TOOL ?= podman

SHELL = /usr/bin/env bash -o pipefail

.SHELLFLAGS = -ec

.PHONY: all

all: build

.PHONY: help

help: ## Display this help.

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

.PHONY: manifests

manifests: controller-gen ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects.

$(CONTROLLER_GEN) rbac:roleName=manager-role crd webhook paths="./api/..." paths="./internal/..." paths="./cmd/..." output:crd:artifacts:config=config/crd/bases

.PHONY: generate

generate: controller-gen ## Generate code containing DeepCopy, DeepCopyInto, and DeepCopyObject method implementations.

$(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./api/..." paths="./internal/..." paths="./cmd/..."

.PHONY: fmt

fmt: ## Run go fmt against code.

go fmt ./...

.PHONY: vet

vet: ## Run go vet against code.

go vet ./...

OUT_DIR := ./build/_output

$(shell mkdir -p $(OUT_DIR))

COV_DIR = $(OUT_DIR)/coverage

.PHONY: test

test: manifests generate fmt vet setup-envtest ## Run tests.

@echo "running the tests with coverage..."

@-mkdir -p $(COV_DIR)

@-rm $(COV_DIR)/coverage.txt

KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) --bin-dir $(LOCALBIN) -p path)" go test -p 1 $$(go list ./... | grep -v /e2e) -coverprofile=$(COV_DIR)/coverage.txt -covermode=atomic -coverpkg=./internal/...

KIND_CLUSTER ?= claw-operator-test-e2e

.PHONY: setup-test-e2e

setup-test-e2e: kind ## Set up a Kind cluster for e2e tests if it does not exist

@case "$$($(KIND) get clusters)" in \

*"$(KIND_CLUSTER)"*) \

echo "Kind cluster '$(KIND_CLUSTER)' already exists. Skipping creation." ;; \

*) \

echo "Creating Kind cluster '$(KIND_CLUSTER)'..."; \

$(KIND) create cluster --name $(KIND_CLUSTER) ;; \

esac

@mkdir -p tmp

@$(KUBECTL) config current-context > tmp/.pre-e2e-context 2>/dev/null || true

@$(KUBECTL) config use-context kind-$(KIND_CLUSTER)

.PHONY: reset-test-e2e

reset-test-e2e: ## Remove leftover operator resources from a previous e2e run

@echo "Resetting e2e test state..."

-$(MAKE) undeploy 2>/dev/null

-$(MAKE) uninstall 2>/dev/null

-$(KUBECTL) delete ns claw-operator --ignore-not-found

.PHONY: test-e2e

test-e2e: ## Run the e2e tests. Expected an isolated environment using Kind.

@trap '$(MAKE) cleanup-test-e2e >/dev/null 2>&1 || true' EXIT; \

$(MAKE) setup-test-e2e manifests generate fmt vet reset-test-e2e; \

KIND_BIN=$(KIND) KIND_CLUSTER=$(KIND_CLUSTER) GATEWAY_IMAGE=$(GATEWAY_IMAGE) go test -v -timeout 15m ./test/e2e/ -run=TestManager

.PHONY: cleanup-test-e2e

cleanup-test-e2e: ## Tear down the Kind cluster used for e2e tests

@status=0; \

$(KIND) delete cluster --name $(KIND_CLUSTER) || status=$$?; \

if [ -f tmp/.pre-e2e-context ]; then \

ctx=$$(cat tmp/.pre-e2e-context); \

rm -f tmp/.pre-e2e-context; \

if [ -n "$$ctx" ] && $(KUBECTL) config get-contexts "$$ctx" >/dev/null 2>&1; then \

echo "Restoring kubectl context to $$ctx"; \

$(KUBECTL) config use-context "$$ctx"; \

fi; \

fi; \

exit $$status

.PHONY: lint

lint: golangci-lint ## Run golangci-lint linter

$(GOLANGCI_LINT) run --config=./.golangci.yml --verbose

.PHONY: lint-fix

lint-fix: golangci-lint ## Run golangci-lint linter and perform fixes

$(GOLANGCI_LINT) run --fix

.PHONY: lint-config

lint-config: golangci-lint ## Verify golangci-lint linter configuration

$(GOLANGCI_LINT) config verify

.PHONY: build

build: manifests generate fmt vet ## Build manager binary.

go build -o bin/manager cmd/main.go

.PHONY: build-proxy

build-proxy: fmt vet ## Build proxy binary.

go build -o bin/proxy cmd/proxy/main.go

.PHONY: run

run: manifests generate fmt vet ## Run a controller from your host.

go run ./cmd/main.go

.PHONY: container-build

container-build: ## Build container image with the manager.

$(CONTAINER_TOOL) build --platform=${PLATFORM} -t ${IMG} \

--build-arg VERSION=$$(git rev-parse --short HEAD) \

--build-arg BUILD_TIME=$$(date -u +"%Y-%m-%dT%H:%M:%SZ") \

-f Containerfile .

.PHONY: container-save

container-save: ## Save the container image to a tar file.

mkdir -p tmp 2>/dev/null

rm -f ${OUTPUT_FILE} || true

$(CONTAINER_TOOL) save -o ${OUTPUT_FILE} ${IMG}

.PHONY: container-push

container-push: ## Push container image with the manager.

$(CONTAINER_TOOL) push ${IMG}

.PHONY: container-build-proxy

container-build-proxy: ## Build container image for the credential proxy.

$(CONTAINER_TOOL) build --platform=${PLATFORM} -t ${PROXY_IMG} -f Containerfile.proxy .

.PHONY: container-push-proxy

container-push-proxy: ## Push container image for the credential proxy.

$(CONTAINER_TOOL) push ${PROXY_IMG}

define generate-deploy-overlay

@rm -rf config/.deploy && mkdir -p config/.deploy

@img=$(1); printf 'apiVersion: kustomize.config.k8s.io/v1beta1\nkind: Kustomization\nresources:\n- ../default\nimages:\n- name: controller\n newName: %s\n newTag: "%s"\npatches:\n- path: proxy_image_patch.yaml\n target:\n kind: Deployment\n' "$${img%:*}" "$${img##*:}" > config/.deploy/kustomization.yaml

@printf 'apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: controller-manager\nspec:\n template:\n spec:\n containers:\n - name: manager\n imagePullPolicy: $(or $(3),IfNotPresent)\n env:\n - name: PROXY_IMAGE\n value: "$(2)"\n - name: IMAGE_PULL_POLICY\n value: "$(or $(3),)"\n' > config/.deploy/proxy_image_patch.yaml

define generate-bundle-overlay

@rm -rf config/.bundle && mkdir -p config/.bundle

@img=$(1); printf 'apiVersion: kustomize.config.k8s.io/v1beta1\nkind: Kustomization\nresources:\n- ../manifests\nimages:\n- name: controller\n newName: %s\n newTag: "%s"\n' \

"$${img%:*}" "$${img##*:}" > config/.bundle/kustomization.yaml

ifndef ignore-not-found

ignore-not-found = false

.PHONY: install

install: manifests kustomize ## Install CRDs into the K8s cluster specified in ~/.kube/config.

$(KUSTOMIZE) build config/crd | $(KUBECTL) apply -f -

.PHONY: uninstall

uninstall: manifests kustomize ## Uninstall CRDs from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion.

$(KUSTOMIZE) build config/crd | $(KUBECTL) delete --ignore-not-found=$(ignore-not-found) -f -

.PHONY: deploy

deploy: manifests kustomize ## Deploy controller to the K8s cluster specified in ~/.kube/config.

$(call generate-deploy-overlay,$(IMG),$(PROXY_IMG))

@trap 'rm -rf config/.deploy' EXIT; $(KUSTOMIZE) build config/.deploy | $(KUBECTL) apply -f -

.PHONY: undeploy

undeploy: kustomize ## Undeploy controller from the K8s cluster specified in ~/.kube/config. Call with ignore-not-found=true to ignore resource not found errors during deletion.

$(KUSTOMIZE) build config/default | $(KUBECTL) delete --ignore-not-found=$(ignore-not-found) -f -

ifndef TAG

TAG := dev-$(shell git rev-parse --short HEAD)-$(shell date +%s)

.PHONY: dev-build

dev-build: ## Build operator and proxy images for dev.

ifndef REGISTRY

$(error REGISTRY is required. Usage: make dev-build REGISTRY=quay.io/myuser)

$(MAKE) container-build IMG=$(REGISTRY)/claw-operator:$(TAG)

$(MAKE) container-build-proxy PROXY_IMG=$(REGISTRY)/claw-proxy:$(TAG)

.PHONY: dev-push

dev-push: ## Push operator and proxy images for dev.

ifndef REGISTRY

$(error REGISTRY is required. Usage: make dev-push REGISTRY=quay.io/myuser)

$(MAKE) container-push IMG=$(REGISTRY)/claw-operator:$(TAG)

$(MAKE) container-push-proxy PROXY_IMG=$(REGISTRY)/claw-proxy:$(TAG)

.PHONY: dev-deploy

dev-deploy: manifests kustomize ## Install CRDs and deploy controller for dev (uses Always pull policy).

ifndef REGISTRY

$(error REGISTRY is required. Usage: make dev-deploy REGISTRY=quay.io/myuser)

$(MAKE) install

$(call generate-deploy-overlay,$(REGISTRY)/claw-operator:$(TAG),$(REGISTRY)/claw-proxy:$(TAG),Always)

@trap 'rm -rf config/.deploy' EXIT; $(KUSTOMIZE) build config/.deploy | $(KUBECTL) apply -f -

@$(KUBECTL) rollout restart deployment -n claw-operator claw-operator-controller-manager || { echo "ERROR: rollout restart failed" >&2; false; }

.PHONY: dev-setup

dev-setup: ## Full dev setup: build, push, and deploy.

ifndef REGISTRY

$(error REGISTRY is required. Usage: make dev-setup REGISTRY=quay.io/myuser)

$(MAKE) dev-build REGISTRY=$(REGISTRY) TAG=$(TAG)

$(MAKE) dev-push REGISTRY=$(REGISTRY) TAG=$(TAG)

$(MAKE) dev-deploy REGISTRY=$(REGISTRY) TAG=$(TAG)

NS ?= my-claw

CLAW ?= instance

.PHONY: wait-ready

wait-ready: ## Wait for the Claw instance to become ready and print the URL. Usage: make wait-ready NS=... [CLAW=instance]

@echo "Waiting for Claw $(CLAW) to become ready in namespace $(NS)..."

@$(KUBECTL) wait --for=condition=Ready claw/$(CLAW) -n $(NS) --timeout=300s

@echo

@echo "URL: $$($(KUBECTL) get claw $(CLAW) -n $(NS) -o jsonpath='{.status.url}')"

@token_secret=$$($(KUBECTL) get claw $(CLAW) -n $(NS) -o jsonpath='{.status.gatewayTokenSecretRef}'); \

echo "Token: $$($(KUBECTL) get secret $$token_secret -n $(NS) -o jsonpath='{.data.token}' | base64 -d)"

APPROVE_SCRIPT = var fs=require("fs"),crypto=require("crypto"),p=require("path"),dir=p.join(process.env.HOME||"/home/node",".openclaw","devices"),rid=process.env.APPROVE_RID,pf=p.join(dir,"pending.json"),af=p.join(dir,"paired.json"),pending=JSON.parse(fs.readFileSync(pf,"utf8")),e=pending[rid];if(!e){console.error("unknown requestId: "+rid);process.exit(1)}var paired;try{paired=JSON.parse(fs.readFileSync(af,"utf8"))}catch(err){if(err.code==="ENOENT"){paired={}}else{throw err}}var roles=e.roles&&e.roles.length?e.roles:e.role?[e.role]:["operator"],scopes=e.scopes||[],tokens=(paired[e.deviceId]||{}).tokens||{},now=Date.now();roles.forEach(function(r){tokens[r]={token:crypto.randomBytes(32).toString("base64url"),role:r,scopes:scopes,createdAtMs:now}});paired[e.deviceId]={deviceId:e.deviceId,publicKey:e.publicKey,displayName:e.displayName,platform:e.platform,deviceFamily:e.deviceFamily,clientId:e.clientId,clientMode:e.clientMode,role:e.role,roles:roles,scopes:scopes,approvedScopes:scopes,remoteIp:e.remoteIp,tokens:tokens,createdAtMs:(paired[e.deviceId]||{}).createdAtMs||now,approvedAtMs:now};delete pending[rid];fs.writeFileSync(af,JSON.stringify(paired,null,2));fs.writeFileSync(pf,JSON.stringify(pending,null,2));console.log("Approved device "+e.deviceId.substring(0,12)+"... for roles: "+roles.join(", "))

LIST_SCRIPT = var fs=require("fs"),p=require("path"),dir=p.join(process.env.HOME||"/home/node",".openclaw","devices");try{var d=JSON.parse(fs.readFileSync(p.join(dir,"pending.json"),"utf8"));Object.values(d).sort(function(a,b){return(b.ts||0)-(a.ts||0)}).forEach(function(r){console.log(r.requestId+" "+(r.platform||"unknown")+" "+(r.clientMode||""))})}catch(_){}

.PHONY: approve-pairing

approve-pairing: ## Approve a device pairing request. Usage: make approve-pairing NS=... [CLAW=instance] [REQUEST_ID=...]

@if [ -n "$(REQUEST_ID)" ]; then \

$(KUBECTL) exec -n $(NS) deployment/$(CLAW) -c gateway -- \

env APPROVE_RID="$(REQUEST_ID)" node -e '$(APPROVE_SCRIPT)'; \

else \

output=$$($(KUBECTL) exec -n $(NS) deployment/$(CLAW) -c gateway -- \

node -e '$(LIST_SCRIPT)' 2>/dev/null); \

rid=$$(echo "$$output" | head -1 | cut -d' ' -f1); \

if [ -z "$$rid" ]; then \

echo "No pending pairing requests found."; \

exit 1; \

fi; \

echo "Found pairing request: $$rid"; \

desc=$$(echo "$$output" | head -1 | cut -d' ' -f2-); \

if [ -n "$$desc" ]; then echo " Device: $$desc"; fi; \

read -r -p "Approve? [y/N] " ans; \

case "$$ans" in [yY]*) ;; *) echo "Aborted."; exit 0;; esac; \

$(KUBECTL) exec -n $(NS) deployment/$(CLAW) -c gateway -- \

env APPROVE_RID="$$rid" node -e '$(APPROVE_SCRIPT)'; \

fi

.PHONY: dev-cleanup

dev-cleanup: ## Remove deployed controller and CRDs.

$(MAKE) undeploy ignore-not-found=true

$(MAKE) uninstall ignore-not-found=true

BUNDLE_CSV = bundle/manifests/claw-operator.clusterserviceversion.yaml

.PHONY: bundle

bundle: manifests kustomize operator-sdk ## Generate OLM bundle manifests and validate.

$(OPERATOR_SDK) generate kustomize manifests -q

$(call generate-bundle-overlay,$(IMG))

trap 'rm -rf config/.bundle' EXIT; \

$(KUSTOMIZE) build config/.bundle | $(OPERATOR_SDK) generate bundle -q --overwrite \

--version $(VERSION) $(BUNDLE_METADATA_OPTS)

sed -i 's|image: $(IMG)|image: REPLACE_IMAGE|' $(BUNDLE_CSV)

sed -i 's|value: $(PROXY_IMG)|value: REPLACE_PROXY_IMAGE|' $(BUNDLE_CSV)

sed -i 's|value: $(KUBECTL_IMG)|value: REPLACE_KUBECTL_IMAGE|' $(BUNDLE_CSV)

sed -i 's|^ createdAt: .*| createdAt: "REPLACE_CREATED_AT"|' $(BUNDLE_CSV)

sed -i 's|^ version: \(.*\)| relatedImages:\n - image: REPLACE_IMAGE\n name: manager\n - image: REPLACE_PROXY_IMAGE\n name: proxy\n - image: REPLACE_KUBECTL_IMAGE\n name: kubectl\n version: \1|' $(BUNDLE_CSV)

$(OPERATOR_SDK) bundle validate ./bundle

.PHONY: bundle-build

bundle-build: ## Build the OLM bundle image.

$(CONTAINER_TOOL) build -f bundle.Dockerfile -t $(BUNDLE_IMG) .

.PHONY: bundle-push

bundle-push: ## Push the OLM bundle image.

$(CONTAINER_TOOL) push $(BUNDLE_IMG)

.PHONY: clean-bundle

clean-bundle: ## Remove the generated bundle directory.

rm -rf bundle/

QUAY_NAMESPACE ?= codeready-toolchain

OPERATOR_REPO = quay.io/$(QUAY_NAMESPACE)/claw-operator

PROXY_REPO = quay.io/$(QUAY_NAMESPACE)/claw-proxy

BUNDLE_REPO = quay.io/$(QUAY_NAMESPACE)/claw-operator-bundle

CATALOG_REPO = quay.io/$(QUAY_NAMESPACE)/claw-operator-catalog

OPM_CATALOG_BASE_IMG ?= quay.io/operator-framework/opm:$(OPM_VERSION)

GIT_COMMIT_COUNT = $(shell git rev-list --count HEAD)

GIT_SHORT_SHA = $(shell git rev-parse --short HEAD)

CD_VERSION = 0.0.$(GIT_COMMIT_COUNT)-commit-$(GIT_SHORT_SHA)

.PHONY: push-to-quay-staging

push-to-quay-staging: generate-cd-release-manifests ## Build and push bundle + catalog images for staging channel.

$(MAKE) bundle-build BUNDLE_IMG=$(BUNDLE_REPO):v$(CD_VERSION)

$(MAKE) bundle-push BUNDLE_IMG=$(BUNDLE_REPO):v$(CD_VERSION)

rm -rf catalog/ && mkdir -p catalog/claw-operator

$(OPM) render $(BUNDLE_REPO):v$(CD_VERSION) -o yaml > catalog/claw-operator/bundle.yaml

@printf -- '---\nschema: olm.package\nname: claw-operator\ndefaultChannel: staging\n---\nschema: olm.channel\npackage: claw-operator\nname: staging\nentries:\n- name: claw-operator.v$(CD_VERSION)\n skipRange: ">=0.0.0 <$(CD_VERSION)"\n' \

> catalog/claw-operator/index.yaml

$(MAKE) build-and-push-catalog CATALOG_IMG=$(CATALOG_REPO):latest

.PHONY: generate-cd-release-manifests

generate-cd-release-manifests: opm ## Generate bundle with CD version, images, and upgrade metadata.

$(MAKE) bundle IMG=$(OPERATOR_REPO):$(GIT_SHORT_SHA) VERSION=$(CD_VERSION)

@echo "Patching CSV for staging release $(CD_VERSION)..."

sed -i 's|REPLACE_IMAGE|$(OPERATOR_REPO):$(GIT_SHORT_SHA)|g' $(BUNDLE_CSV)

sed -i 's|REPLACE_PROXY_IMAGE|$(PROXY_REPO):$(GIT_SHORT_SHA)|g' $(BUNDLE_CSV)

sed -i 's|REPLACE_KUBECTL_IMAGE|$(KUBECTL_IMG)|g' $(BUNDLE_CSV)

sed -i 's|REPLACE_CREATED_AT|$(shell date -u +"%Y-%m-%dT%H:%M:%SZ")|' $(BUNDLE_CSV)

sed -i '/^ createdAt:/a\ olm.skipRange: ">=0.0.0 <$(CD_VERSION)"' $(BUNDLE_CSV)

.PHONY: build-and-push-catalog

build-and-push-catalog: opm ## Validate, build, and push FBC catalog image from catalog/ directory.

$(OPM) validate catalog/

# Build a catalog image from the FBC configs using opm as the base.

# --cache-enforce-integrity=false works around an opm bug where the pogreb

# cache backend fails its integrity check on first startup because the

# digest file hasn't been written yet, causing the container to crash-loop.

printf 'FROM $(OPM_CATALOG_BASE_IMG)\nCOPY catalog /configs\nLABEL operators.operatorframework.io.index.configs.v1=/configs\nENTRYPOINT ["/bin/opm"]\nCMD ["serve", "/configs", "--cache-dir=/tmp/cache", "--cache-enforce-integrity=false"]\n' | \

$(CONTAINER_TOOL) build -f - -t $(CATALOG_IMG) .

$(CONTAINER_TOOL) push $(CATALOG_IMG)

rm -rf catalog/

.PHONY: publish-current-bundle

publish-current-bundle: opm ## One-shot publish for testing OLM install (alpha channel, no replaces). Requires IMG and PROXY_IMG.

$(MAKE) bundle VERSION=$(CD_VERSION) CHANNELS=alpha DEFAULT_CHANNEL=alpha

@echo "Patching CSV for alpha release $(CD_VERSION)..."

sed -i 's|REPLACE_IMAGE|$(IMG)|g' $(BUNDLE_CSV)

sed -i 's|REPLACE_PROXY_IMAGE|$(PROXY_IMG)|g' $(BUNDLE_CSV)

sed -i 's|REPLACE_KUBECTL_IMAGE|$(KUBECTL_IMG)|g' $(BUNDLE_CSV)

sed -i 's|REPLACE_CREATED_AT|$(shell date -u +"%Y-%m-%dT%H:%M:%SZ")|' $(BUNDLE_CSV)

$(MAKE) bundle-build BUNDLE_IMG=$(BUNDLE_REPO):v$(CD_VERSION)

$(MAKE) bundle-push BUNDLE_IMG=$(BUNDLE_REPO):v$(CD_VERSION)

rm -rf catalog/ && mkdir -p catalog/claw-operator

$(OPM) render $(BUNDLE_REPO):v$(CD_VERSION) -o yaml > catalog/claw-operator/bundle.yaml

@printf -- '---\nschema: olm.package\nname: claw-operator\ndefaultChannel: alpha\n---\nschema: olm.channel\npackage: claw-operator\nname: alpha\nentries:\n- name: claw-operator.v$(CD_VERSION)\n' \

> catalog/claw-operator/index.yaml

$(MAKE) build-and-push-catalog

LOCALBIN ?= $(shell pwd)/bin

$(LOCALBIN):

mkdir -p $(LOCALBIN)

KUBECTL ?= kubectl

KIND ?= $(LOCALBIN)/kind

KUSTOMIZE ?= $(LOCALBIN)/kustomize

CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen

ENVTEST ?= $(LOCALBIN)/setup-envtest

GOLANGCI_LINT = $(LOCALBIN)/golangci-lint

OPERATOR_SDK ?= $(LOCALBIN)/operator-sdk

OPM ?= $(LOCALBIN)/opm

KUSTOMIZE_VERSION ?= v5.6.0

CONTROLLER_TOOLS_VERSION ?= v0.19.0

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 ?= $(shell go list -m -f "{{ .Version }}" k8s.io/api | awk -F'[v.]' '{printf "1.%d", $$3}')

GOLANGCI_LINT_VERSION ?= v2.15.0

OPERATOR_SDK_VERSION ?= v1.42.0

OPM_VERSION ?= v1.59.0

KIND_VERSION ?= v0.31.0

.PHONY: kustomize

kustomize: $(KUSTOMIZE) ## Download kustomize locally if necessary.

$(KUSTOMIZE): $(LOCALBIN)

$(call go-install-tool,$(KUSTOMIZE),sigs.k8s.io/kustomize/kustomize/v5,$(KUSTOMIZE_VERSION))

.PHONY: controller-gen

controller-gen: $(CONTROLLER_GEN) ## Download controller-gen locally if necessary.

$(CONTROLLER_GEN): $(LOCALBIN)

$(call go-install-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen,$(CONTROLLER_TOOLS_VERSION))

.PHONY: setup-envtest

setup-envtest: envtest ## Download the binaries required for ENVTEST in the local bin directory.

@echo "Setting up envtest binaries for Kubernetes version $(ENVTEST_K8S_VERSION)..."

@$(ENVTEST) use $(ENVTEST_K8S_VERSION) --bin-dir $(LOCALBIN) -p path || { \

echo "Error: Failed to set up envtest binaries for version $(ENVTEST_K8S_VERSION)."; \

exit 1; \

}

.PHONY: envtest

envtest: $(ENVTEST) ## Download setup-envtest locally if necessary.

$(ENVTEST): $(LOCALBIN)

$(call go-install-tool,$(ENVTEST),sigs.k8s.io/controller-runtime/tools/setup-envtest,$(ENVTEST_VERSION))

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

.PHONY: operator-sdk

operator-sdk: $(OPERATOR_SDK) ## Download operator-sdk locally if necessary.

$(OPERATOR_SDK): $(LOCALBIN)

$(call download-tool,$(OPERATOR_SDK),$(OPERATOR_SDK_VERSION),\

https://github.com/operator-framework/operator-sdk/releases/download/$(OPERATOR_SDK_VERSION)/operator-sdk_$(OS)_$(ARCH))

.PHONY: opm

opm: $(OPM) ## Download opm locally if necessary.

$(OPM): $(LOCALBIN)

$(call download-tool,$(OPM),$(OPM_VERSION),\

https://github.com/operator-framework/operator-registry/releases/download/$(OPM_VERSION)/$(OS)-$(ARCH)-opm)

.PHONY: kind

kind: $(KIND) ## Download kind locally if necessary.

$(KIND): $(LOCALBIN)

$(call download-tool,$(KIND),$(KIND_VERSION),\

https://github.com/kubernetes-sigs/kind/releases/download/$(KIND_VERSION)/kind-$(OS)-$(ARCH))

define download-tool

@[ -f "$(1)-$(2)" ] || { \

set -e; \

echo "Downloading $(1) $(2)"; \

curl --silent --show-error --location --fail --retry 3 --output $(1)-$(2) $(3); \

chmod +x $(1)-$(2); \

}; \

ln -sf $(1)-$(2) $(1)

define go-install-tool

@[ -f "$(1)-$(3)" ] || { \

set -e; \

package=$(2)@$(3) ;\

echo "Downloading $${package}" ;\

rm -f $(1) || true ;\

GOBIN=$(LOCALBIN) go install $${package} ;\

mv $(1) $(1)-$(3) ;\

} ;\

ln -sf $(1)-$(3) $(1)