# Image URL to use all building/pushing image targets

IMG ?= controller:latest

# KUBEBUILDER_ENVTEST_KUBERNETES_VERSION refers to the version of kubebuilder assets to be downloaded by envtest binary.

KUBEBUILDER_ENVTEST_KUBERNETES_VERSION = 1.31.0

# Get the currently used golang install path (in GOPATH/bin, unless GOBIN is set)

ifeq (,$(shell go env GOBIN))

GOBIN=$(shell go env GOPATH)/bin

else

GOBIN=$(shell go env GOBIN)

endif

GO_INSTALL := ./scripts/go_install.sh

# Setting SHELL to bash allows bash commands to be executed by recipes.

# This is a requirement for 'setup-envtest.sh' in the test target.

# 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

# Define Docker related variables.

REGISTRY ?= projectsveltos

IMAGE_NAME ?= ytt-controller

ARCH ?= amd64

OS ?= $(shell uname -s | tr A-Z a-z)

K8S_LATEST_VER ?= $(shell curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)

export CONTROLLER_IMG ?= $(REGISTRY)/$(IMAGE_NAME)

TAG ?= main

.PHONY: all

all: build

##@ General

# The help target prints out all targets with their descriptions organized

# beneath their categories. The categories are represented by '##@' and the

# target descriptions by '##'. The awk commands is responsible for reading the

# entire set of makefiles included in this invocation, looking for lines of the

# file as xyz: ## something, and then pretty-format the target and help. Then,

# if there's a line with ##@ 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

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

# Directories.

ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))

TOOLS_DIR := hack/tools

BIN_DIR := bin

TOOLS_BIN_DIR := $(abspath $(TOOLS_DIR)/$(BIN_DIR))

GOBUILD=go build

GENERATED_FILES:=./manifest/manifest.yaml

## Tool Binaries

CONTROLLER_GEN := $(TOOLS_BIN_DIR)/controller-gen

ENVSUBST := $(TOOLS_BIN_DIR)/envsubst

GOIMPORTS := $(TOOLS_BIN_DIR)/goimports

GOLANGCI_LINT := $(TOOLS_BIN_DIR)/golangci-lint

GINKGO := $(TOOLS_BIN_DIR)/ginkgo

KIND := $(TOOLS_BIN_DIR)/kind

KUBECTL := $(TOOLS_BIN_DIR)/kubectl

GOLANGCI_LINT_VERSION := "v1.61.0"

CLUSTERCTL_VERSION := "v1.8.5"

KUSTOMIZE_VER := v5.3.0

KUSTOMIZE_BIN := kustomize

KUSTOMIZE := $(abspath $(TOOLS_BIN_DIR)/$(KUSTOMIZE_BIN)-$(KUSTOMIZE_VER))

KUSTOMIZE_PKG := sigs.k8s.io/kustomize/kustomize/v5

$(KUSTOMIZE): # Build kustomize from tools folder.

CGO_ENABLED=0 GOBIN=$(TOOLS_BIN_DIR) $(GO_INSTALL) $(KUSTOMIZE_PKG) $(KUSTOMIZE_BIN) $(KUSTOMIZE_VER)

SETUP_ENVTEST_VER := release-0.19

SETUP_ENVTEST_BIN := setup-envtest

SETUP_ENVTEST := $(abspath $(TOOLS_BIN_DIR)/$(SETUP_ENVTEST_BIN)-$(SETUP_ENVTEST_VER))

SETUP_ENVTEST_PKG := sigs.k8s.io/controller-runtime/tools/setup-envtest

setup-envtest: $(SETUP_ENVTEST) ## Set up envtest (download kubebuilder assets)

@echo KUBEBUILDER_ASSETS=$(KUBEBUILDER_ASSETS)

$(SETUP_ENVTEST_BIN): $(SETUP_ENVTEST) ## Build a local copy of setup-envtest.

$(SETUP_ENVTEST): # Build setup-envtest from tools folder.

GOBIN=$(TOOLS_BIN_DIR) $(GO_INSTALL) $(SETUP_ENVTEST_PKG) $(SETUP_ENVTEST_BIN) $(SETUP_ENVTEST_VER)

$(CONTROLLER_GEN): $(TOOLS_DIR)/go.mod # Build controller-gen from tools folder.

cd $(TOOLS_DIR); $(GOBUILD) -tags=tools -o $(subst $(TOOLS_DIR)/hack/tools/,,$@) sigs.k8s.io/controller-tools/cmd/controller-gen

$(ENVSUBST): $(TOOLS_DIR)/go.mod # Build envsubst from tools folder.

cd $(TOOLS_DIR); $(GOBUILD) -tags=tools -o $(subst $(TOOLS_DIR)/hack/tools/,,$@) github.com/a8m/envsubst/cmd/envsubst

$(GOLANGCI_LINT): # Build golangci-lint from tools folder.

cd $(TOOLS_DIR); ./get-golangci-lint.sh $(GOLANGCI_LINT_VERSION)

$(GOIMPORTS):

cd $(TOOLS_DIR); $(GOBUILD) -tags=tools -o $(subst $(TOOLS_DIR)/hack/tools/,,$@) golang.org/x/tools/cmd/goimports

$(GINKGO): $(TOOLS_DIR)/go.mod

cd $(TOOLS_DIR) && $(GOBUILD) -tags tools -o $(subst $(TOOLS_DIR)/hack/tools/,,$@) github.com/onsi/ginkgo/v2/ginkgo

$(KIND): $(TOOLS_DIR)/go.mod

cd $(TOOLS_DIR) && $(GOBUILD) -tags tools -o $(subst $(TOOLS_DIR)/hack/tools/,,$@) sigs.k8s.io/kind

$(CLUSTERCTL): $(TOOLS_DIR)/go.mod ## Build clusterctl binary

curl -L https://github.com/kubernetes-sigs/cluster-api/releases/download/$(CLUSTERCTL_VERSION)/clusterctl-$(OS)-$(ARCH) -o $@

chmod x $@

mkdir -p $(HOME)/.cluster-api # create cluster api init directory, if not present

$(KUBECTL):

curl -L https://storage.googleapis.com/kubernetes-release/release/$(K8S_LATEST_VER)/bin/$(OS)/$(ARCH)/kubectl -o $@

chmod x $@

.PHONY: tools

tools: $(CONTROLLER_GEN) $(ENVSUBST) $(KUSTOMIZE) $(GOLANGCI_LINT) $(SETUP_ENVTEST) $(GOIMPORTS) $(GINKGO) $(KIND) $(KUBECTL) ## build all tools

.PHONY: clean

clean: ## Remove all built tools

rm -rf $(TOOLS_BIN_DIR)/*

rm -rf $(GENERATED_FILES)

rm -rf version.txt

##@ Development

.PHONY: manifests

manifests: $(CONTROLLER_GEN) $(KUSTOMIZE) $(ENVSUBST) fmt generate ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects.

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

MANIFEST_IMG=$(CONTROLLER_IMG) MANIFEST_TAG=$(TAG) $(MAKE) set-manifest-image

$(KUSTOMIZE) build config/default | $(ENVSUBST) > manifest/manifest.yaml

.PHONY: generate

generate: $(CONTROLLER_GEN) ## Generate code containing DeepCopy, DeepCopyInto, and DeepCopyObject method implementations.

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

.PHONY: fmt

fmt: $(GOIMPORTS) ## Run go fmt against code.

$(GOIMPORTS) -local github.com/projectsveltos -w .

go fmt ./...

.PHONY: vet

vet: ## Run go vet against code.

go vet ./...

.PHONY: lint

lint: $(GOLANGCI_LINT) generate ## Lint codebase

$(GOLANGCI_LINT) run -v --fast=false --max-issues-per-linter 0 --max-same-issues 0 --timeout 5m

.PHONY: check-manifests

check-manifests: manifests ## Verify manifests file is up to date

test `git status --porcelain $(GENERATED_FILES) | grep -cE '(^\?)|(^ M)'` -eq 0 || (echo "The manifest file changed, please 'make manifests' and commit the results"; exit 1)

ifeq ($(shell go env GOOS),darwin) # Use the darwin/amd64 binary until an arm64 version is available

KUBEBUILDER_ASSETS ?= $(shell $(SETUP_ENVTEST) use --use-env -p path --arch amd64 $(KUBEBUILDER_ENVTEST_KUBERNETES_VERSION))

else

KUBEBUILDER_ASSETS ?= $(shell $(SETUP_ENVTEST) use --use-env -p path $(KUBEBUILDER_ENVTEST_KUBERNETES_VERSION))

endif

##@ TESTING

# K8S_VERSION for the Kind cluster can be set as environment variable. If not defined,

# this default value is used

ifndef K8S_VERSION

K8S_VERSION := v1.31.0

endif

KIND_CONFIG ?= kind-cluster.yaml

CONTROL_CLUSTER_NAME ?= sveltos-management

NUM_NODES ?= 5

TIMEOUT ?= 10m

.PHONY: fv

fv: $(GINKGO) ## Run Sveltos Controller tests using existing cluster

cd test/fv; $(GINKGO) -nodes $(NUM_NODES) --label-filter='FV' --v --trace --randomize-all

.PHONY: create-cluster

create-cluster: $(KIND) $(KUBECTL) $(ENVSUBST) ## Create a new kind cluster designed for development

sed -e "s/K8S_VERSION/$(K8S_VERSION)/g" test/$(KIND_CONFIG) > test/$(KIND_CONFIG).tmp

$(KIND) create cluster --name=$(CONTROL_CLUSTER_NAME) --config test/$(KIND_CONFIG).tmp

@echo "Start ytt-controller"

$(MAKE) deploy-ytt-controller

@echo "prepare configMap with ytt files"

$(KUBECTL) create configmap ytt --from-file=ytt.tar.gz=test/ytt.tar.gz

@echo "prepare configMap with ytt overlays files"

$(KUBECTL) create configmap ytt-overlays --from-file=ytt.tar.gz=test/ytt_overlays.tar.gz

.PHONY: delete-cluster

delete-cluster: $(KIND) ## Deletes the kind cluster $(CONTROL_CLUSTER_NAME)

$(KIND) delete cluster --name $(CONTROL_CLUSTER_NAME)

$(KIND) delete cluster --name $(WORKLOAD_CLUSTER_NAME)

deploy-ytt-controller: $(KUSTOMIZE)

# Load ytt controller image into cluster

@echo 'Load ytt-controller image into cluster'

$(MAKE) load-image

# Install ytt-controller

@echo 'Install ytt-controller'

cd config/manager && $(KUSTOMIZE) edit set image controller=${IMG}

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

@echo "Waiting for ytt-controller to be available..."

$(KUBECTL) wait --for=condition=Available deployment/ytt-controller -n ytt-system --timeout=$(TIMEOUT)

.PHONY: kind-test

kind-test: test create-cluster fv ## Build docker image; start kind cluster; load docker image; install all cluster api components and run fv

.PHONY: test

test: | check-manifests generate fmt vet $(SETUP_ENVTEST) ## Run uts.

KUBEBUILDER_ASSETS="$(KUBEBUILDER_ASSETS)" go test $(shell go list ./... |grep -v test/fv) $(TEST_ARGS) -coverprofile cover.out

set-manifest-image:

$(info Updating kustomize image patch file for manager resource)

sed -i'' -e 's@image: .*@image: '"${MANIFEST_IMG}:$(MANIFEST_TAG)"'@' ./config/default/manager_image_patch.yaml

set-manifest-pull-policy:

$(info Updating kustomize pull policy file for manager resource)

sed -i'' -e 's@imagePullPolicy: .*@imagePullPolicy: '"$(PULL_POLICY)"'@' ./config/default/manager_pull_policy.yaml

##@ Build

.PHONY: build

build: generate fmt vet ## Build manager binary.

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

.PHONY: run

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

go run ./cmd/main.go

.PHONY: docker-build

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

docker build --load --build-arg BUILDOS=linux --build-arg TARGETARCH=amd64 -t $(CONTROLLER_IMG):$(TAG) .

MANIFEST_IMG=$(CONTROLLER_IMG) MANIFEST_TAG=$(TAG) $(MAKE) set-manifest-image

$(MAKE) set-manifest-pull-policy

.PHONY: docker-push

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

docker push $(CONTROLLER_IMG):$(TAG)

.PHONY: docker-buildx

docker-buildx: ## docker build for multiple arch and push to docker hub

docker buildx build --push --platform linux/amd64,linux/arm64 -t $(CONTROLLER_IMG):$(TAG) .

.PHONY: load-image

load-image: docker-build $(KIND)

$(KIND) load docker-image $(CONTROLLER_IMG):$(TAG) --name $(CONTROL_CLUSTER_NAME)

##@ Deployment

ifndef ignore-not-found

ignore-not-found = false

endif

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

cd config/manager && ../../$(KUSTOMIZE) edit set image controller=${IMG}

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

.PHONY: undeploy

undeploy: s $(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 -