Makefile

# Copyright 2022 IBM Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

KUSTOMIZE_VERSION=v4.5.6

ARCH := $(shell uname -m)
LOCAL_ARCH := "amd64"
ifeq ($(ARCH),x86_64)
    LOCAL_ARCH="amd64"
else ifeq ($(ARCH),ppc64le)
    LOCAL_ARCH="ppc64le"
else ifeq ($(ARCH),s390x)
    LOCAL_ARCH="s390x"
else
    $(error "This system's ARCH $(ARCH) isn't recognized/supported")
endif

# This repo is build locally for dev/test by default;
# Override this variable in CI env.
BUILD_LOCALLY ?= 1

ifeq ($(BUILD_LOCALLY),0)
    export CONFIG_DOCKER_TARGET = config-docker
endif

ifdef DOCKER_REGISTRY
	REGISTRY ?= $(DOCKER_REGISTRY)
else
	REGISTRY ?= "docker-na-public.artifactory.swg-devops.com/hyc-cloud-private-scratch-docker-local/ibmcom"
endif

QEMU_REGISTRY ?= "docker-na-public.artifactory.swg-devops.com/hyc-cloud-private-dockerhub-docker-remote"

VCS_REF ?= $(shell git rev-parse HEAD)

PREV_VERSION ?= 4.2.13

# VERSION defines the project version for the bundle.
# Update this value when you upgrade the version of your project.
# To re-generate a bundle for another specific version without changing the standard setup, you can:
# - use the VERSION as arg of the bundle target (e.g make bundle VERSION=0.0.2)
# - use environment variables to overwrite this value (e.g export VERSION=0.0.2)
ifdef BUILD_VERSION
	VERSION ?= $(BUILD_VERSION)
else
	VERSION ?= 4.2.22
endif

# CHANNELS define the bundle channels used in the bundle.
# Add a new line here if you would like to change its default config. (E.g CHANNELS = "candidate,fast,stable")
# To re-generate a bundle for other specific channels without changing the standard setup, you can:
# - use the CHANNELS as arg of the bundle target (e.g make bundle CHANNELS=candidate,fast,stable)
# - use environment variables to overwrite this value (e.g export CHANNELS="candidate,fast,stable")
ifneq ($(origin CHANNELS), undefined)
BUNDLE_CHANNELS := --channels=$(CHANNELS)
endif

# DEFAULT_CHANNEL defines the default channel used in the bundle.
# Add a new line here if you would like to change its default config. (E.g DEFAULT_CHANNEL = "stable")
# To re-generate a bundle for any other default channel without changing the default setup, you can:
# - use the DEFAULT_CHANNEL as arg of the bundle target (e.g make bundle DEFAULT_CHANNEL=stable)
# - use environment variables to overwrite this value (e.g export DEFAULT_CHANNEL="stable")
ifneq ($(origin DEFAULT_CHANNEL), undefined)
BUNDLE_DEFAULT_CHANNEL := --default-channel=$(DEFAULT_CHANNEL)
endif
BUNDLE_METADATA_OPTS ?= $(BUNDLE_CHANNELS) $(BUNDLE_DEFAULT_CHANNEL)

# IMAGE_TAG_BASE defines the docker.io namespace and part of the image name for remote images.
# This variable is used to construct full image tags for bundle and catalog images.
#
# For example, running 'make bundle-build bundle-push catalog-build catalog-push' will build and push both
# ibm.com/ibm-cert-manager-operator-bundle:$VERSION and ibm.com/ibm-cert-manager-operator-catalog:$VERSION.
IMAGE_TAG_BASE ?= $(REGISTRY)/ibm-cert-manager-operator

# BUNDLE_IMG defines the image:tag used for the bundle.
# You can use it as an arg. (E.g make bundle-build BUNDLE_IMG=<some-registry>/<project-name-bundle>:<tag>)
BUNDLE_IMG ?= $(IMAGE_TAG_BASE)-bundle:v$(VERSION)

# Image URL to use all building/pushing image targets
IMG ?= ibm-cert-manager-operator
# ENVTEST_K8S_VERSION refers to the version of kubebuilder assets to be downloaded by envtest binary.
ENVTEST_K8S_VERSION ?= 1.28

# 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

PROJECT_DIR := $(shell dirname $(abspath $(lastword $(MAKEFILE_LIST))))

GOTOOLCHAIN ?= auto
export GOTOOLCHAIN

# 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
HADOLINT_BIN ?= $(shell command -v hadolint 2>/dev/null)
ifeq ($(HADOLINT_BIN),)
HADOLINT_BIN := $(PROJECT_DIR)/bin/hadolint
endif
HADOLINT_VERSION ?= v2.12.0

.SHELLFLAGS = -ec

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

SHELLCHECK_BIN ?= $(shell command -v shellcheck 2>/dev/null)
ifeq ($(SHELLCHECK_BIN),)
SHELLCHECK_BIN := $(PROJECT_DIR)/bin/shellcheck
endif
SHELLCHECK_VERSION ?= v0.10.0

.PHONY: shellcheck
shellcheck: ## Download shellcheck locally if necessary.
	@if [ ! -x "$(SHELLCHECK_BIN)" ]; then \
		OS=$$(uname -s); \
		ARCH=$$(uname -m); \
		if [ "$$OS" = "Linux" ] && [ "$$ARCH" = "x86_64" ]; then \
			echo "Downloading shellcheck $(SHELLCHECK_VERSION) ..."; \
			mkdir -p $(PROJECT_DIR)/bin; \
			TMP_DIR=$$(mktemp -d); \
			ARCHIVE=$$TMP_DIR/shellcheck.tar.xz; \
			curl -sSL https://github.com/koalaman/shellcheck/releases/download/$(SHELLCHECK_VERSION)/shellcheck-$(SHELLCHECK_VERSION).linux.x86_64.tar.xz -o $$ARCHIVE; \
			if command -v xz >/dev/null 2>&1; then \
				tar -xf $$ARCHIVE -C $$TMP_DIR; \
			elif command -v python3 >/dev/null 2>&1; then \
				ARCHIVE_PATH="$$ARCHIVE" TMP_DIR_PATH="$$TMP_DIR" python3 -c "import io, os, tarfile, lzma, pathlib; archive=pathlib.Path(os.environ['ARCHIVE_PATH']); out=pathlib.Path(os.environ['TMP_DIR_PATH']); data=lzma.open(archive, 'rb').read(); tarfile.open(fileobj=io.BytesIO(data)).extractall(path=out)" || { rm -rf $$TMP_DIR; echo "Failed to extract shellcheck archive"; exit 1; }; \
			else \
				echo "shellcheck install requires 'xz' or Python 3 with lzma support"; \
				rm -rf $$TMP_DIR; \
				exit 1; \
			fi; \
			SC_BIN=$$(find $$TMP_DIR -type f -name shellcheck -perm -u+x | head -n 1); \
			if [ -z "$$SC_BIN" ]; then \
				echo "Unable to locate shellcheck binary in archive"; \
				rm -rf $$TMP_DIR; \
				exit 1; \
			fi; \
			mv "$$SC_BIN" $(PROJECT_DIR)/bin/shellcheck; \
			chmod +x $(PROJECT_DIR)/bin/shellcheck; \
			rm -rf $$TMP_DIR; \
		else \
			echo "shellcheck not found and automatic install unsupported for $$OS/$$ARCH"; \
			echo "Please install shellcheck manually and re-run make."; \
			exit 1; \
		fi; \
	fi

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)

##@ Development

manifests: yq controller-gen ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects.
	$(CONTROLLER_GEN) rbac:roleName=operator crd webhook paths="./..." output:crd:artifacts:config=config/crd/bases
	common/scripts/patch-metadata.sh $(YQ)

generate: controller-gen ## Generate code containing DeepCopy, DeepCopyInto, and DeepCopyObject method implementations.
	$(CONTROLLER_GEN) object:headerFile="hack/boilerplate.go.txt" paths="./..."

# All available format: format-go format-protos format-python
# Default value will run all formats, override these make target with your requirements:
#    eg: fmt: format-go format-protos
fmt: format-go

vet: ## Run go vet against code.
	go vet ./...

test: manifests generate fmt vet envtest ## Run tests.
	KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) -p path)" go test ./... -coverprofile cover.out

##@ Build

build: generate fmt vet build-amd64 build-ppc64le build-s390x ## Build manager binary.

build-amd64:
	@echo "Building the ${IMG} amd64 binary..."
	@GOARCH=amd64 common/scripts/gobuild.sh build/_output/bin/$(IMG) main.go

build-ppc64le:
	@echo "Building the ${IMG} ppc64le binary..."
	@GOARCH=ppc64le common/scripts/gobuild.sh build/_output/bin/$(IMG)-ppc64le main.go

build-s390x:
	@echo "Building the ${IMG} s390x binary..."
	@GOARCH=s390x common/scripts/gobuild.sh build/_output/bin/$(IMG)-s390x main.go

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

docker-build: test ## Build docker image with the manager.
	docker build -t ${IMG} .

docker-push: ## Push docker image with the manager.
	docker push ${IMG}

images: push-image-amd64 push-image-ppc64le push-image-s390x multiarch-image

build-image-amd64: $(CONFIG_DOCKER_TARGET) build-amd64
	@docker build -t $(REGISTRY)/$(IMG)-amd64:$(VERSION) \
		--build-arg VCS_REF=$(VCS_REF) \
		-f Dockerfile .

build-image-ppc64le: $(CONFIG_DOCKER_TARGET) build-ppc64le
	@docker run --rm --privileged $(QEMU_REGISTRY)/multiarch/qemu-user-static:register --reset
	@docker build -t $(REGISTRY)/$(IMG)-ppc64le:$(VERSION) \
		--build-arg VCS_REF=$(VCS_REF) \
		-f Dockerfile.ppc64le .

build-image-s390x: $(CONFIG_DOCKER_TARGET) build-s390x
	@docker run --rm --privileged $(QEMU_REGISTRY)/multiarch/qemu-user-static:register --reset
	@docker build -t $(REGISTRY)/$(IMG)-s390x:$(VERSION) \
		--build-arg VCS_REF=$(VCS_REF) \
		-f Dockerfile.s390x .

push-image-amd64: $(CONFIG_DOCKER_TARGET) build-image-amd64
	@docker push $(REGISTRY)/$(IMG)-amd64:$(VERSION)

push-image-ppc64le: $(CONFIG_DOCKER_TARGET) build-image-ppc64le
	@docker push $(REGISTRY)/$(IMG)-ppc64le:$(VERSION)

push-image-s390x: $(CONFIG_DOCKER_TARGET) build-image-s390x
	@docker push $(REGISTRY)/$(IMG)-s390x:$(VERSION)

multiarch-image:
	@curl -L -o /tmp/manifest-tool https://github.com/estesp/manifest-tool/releases/download/v1.0.3/manifest-tool-linux-amd64
	@chmod +x /tmp/manifest-tool
	/tmp/manifest-tool push from-args --platforms linux/amd64,linux/ppc64le,linux/s390x --template $(REGISTRY)/$(IMG)-ARCH:$(VERSION) --target $(REGISTRY)/$(IMG)
	/tmp/manifest-tool push from-args --platforms linux/amd64,linux/ppc64le,linux/s390x --template $(REGISTRY)/$(IMG)-ARCH:$(VERSION) --target $(REGISTRY)/$(IMG):$(VERSION)

##@ Deployment

install: manifests kustomize ## Install CRDs into the K8s cluster specified in ~/.kube/config.
	$(KUSTOMIZE) build config/crd | kubectl apply -f -

uninstall: manifests kustomize ## Uninstall CRDs from the K8s cluster specified in ~/.kube/config.
	$(KUSTOMIZE) build config/crd | kubectl delete -f -

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 | kubectl apply -f -

undeploy: ## Undeploy controller from the K8s cluster specified in ~/.kube/config.
	$(KUSTOMIZE) build config/default | kubectl delete -f -


CONTROLLER_GEN = $(shell pwd)/bin/controller-gen
controller-gen: ## Download controller-gen locally if necessary.
	$(call go-get-tool,$(CONTROLLER_GEN),sigs.k8s.io/controller-tools/cmd/controller-gen@v0.19.0)

kustomize: ## Install kustomize
ifeq (, $(shell which kustomize 2>/dev/null))
	@{ \
	set -e ;\
	mkdir -p bin ;\
	echo "Downloading kustomize ...";\
	curl -sSLo - https://github.com/kubernetes-sigs/kustomize/releases/download/kustomize%2Fv4.5.6/kustomize_v4.5.6_linux_amd64.tar.gz | tar xzf - -C bin/ ;\
	}
KUSTOMIZE=$(realpath ./bin/kustomize)
else
KUSTOMIZE=$(shell which kustomize)
endif

YQ = $(shell pwd)/bin/yq
yq: ## Download kustomize locally if necessary.
	$(call go-get-tool,$(YQ),github.com/mikefarah/yq/v4@v4.17.2)

ENVTEST = $(shell pwd)/bin/setup-envtest
ENVTEST_VERSION ?= latest
envtest: ## Download envtest-setup locally if necessary.
	$(call go-get-tool,$(ENVTEST),sigs.k8s.io/controller-runtime/tools/setup-envtest@$(ENVTEST_VERSION))

# go-get-tool will 'go get' any package $2 and install it to $1.
define go-get-tool
@[ -f $(1) ] || { \
set -e ;\
TMP_DIR=$$(mktemp -d) ;\
cd $$TMP_DIR ;\
go mod init tmp ;\
echo "Downloading $(2)" ;\
export GOSUMDB=sum.golang.org ;\
GOBIN=$(PROJECT_DIR)/bin go install $(2) ;\
rm -rf $$TMP_DIR ;\
}
endef

GOIMPORTS_VERSION ?= v0.36.0
GOIMPORTS_BIN ?= $(PROJECT_DIR)/bin/goimports

.PHONY: goimports
goimports: ## Download goimports locally if necessary.
	$(call go-get-tool,$(GOIMPORTS_BIN),golang.org/x/tools/cmd/goimports@$(GOIMPORTS_VERSION))

HADOLINT_BIN ?= $(shell command -v hadolint 2>/dev/null)
ifeq ($(HADOLINT_BIN),)
HADOLINT_BIN := $(PROJECT_DIR)/bin/hadolint
endif
HADOLINT_VERSION ?= v2.12.0

.PHONY: hadolint
hadolint: ## Download hadolint locally if necessary.
	@if [ ! -x "$(HADOLINT_BIN)" ]; then \
		OS=$$(uname -s); \
		ARCH=$$(uname -m); \
		if [ "$$OS" = "Linux" ] && [ "$$ARCH" = "x86_64" ]; then \
			echo "Downloading hadolint $(HADOLINT_VERSION) ..."; \
			mkdir -p $(PROJECT_DIR)/bin; \
			curl -sSL https://github.com/hadolint/hadolint/releases/download/$(HADOLINT_VERSION)/hadolint-$$OS-$$ARCH -o "$(PROJECT_DIR)/bin/hadolint"; \
			chmod +x "$(PROJECT_DIR)/bin/hadolint"; \
		else \
			echo "hadolint not found and automatic install unsupported for $$OS/$$ARCH"; \
			echo "Please install hadolint manually and re-run make."; \
			exit 1; \
		fi; \
	fi

.PHONY: bundle
bundle: manifests kustomize ## Generate bundle manifests and metadata, then validate generated files.
	common/scripts/patch-csv.sh v$(PREV_VERSION) $(VERSION)
	operator-sdk generate kustomize manifests -q
	cd config/manager && $(KUSTOMIZE) edit set image controller=$(IMG)
	$(KUSTOMIZE) build config/manifests | operator-sdk generate bundle -q --overwrite --version $(VERSION) $(BUNDLE_METADATA_OPTS)
	hack/reduce-bundle-crds.sh
	operator-sdk bundle validate ./bundle
	$(YQ) eval-all -i '.spec.relatedImages = load("config/manifests/bases/ibm-cert-manager-operator.clusterserviceversion.yaml").spec.relatedImages' bundle/manifests/ibm-cert-manager-operator.clusterserviceversion.yaml

.PHONY: bundle-build
bundle-build: ## Build the bundle image.
	docker build -f bundle.Dockerfile -t $(BUNDLE_IMG) .

.PHONY: bundle-push
bundle-push: ## Push the bundle image.
	$(MAKE) docker-push IMG=$(BUNDLE_IMG)

bundle-run: bundle bundle-build bundle-push
	operator-sdk run bundle $(REGISTRY)/ibm-cert-manager-operator-bundle:v$(VERSION) --install-mode AllNamespaces

olm-cleanup:
	operator-sdk cleanup ibm-cert-manager-operator

.PHONY: opm
OPM = ./bin/opm
opm: ## Download opm locally if necessary.
ifeq (,$(wildcard $(OPM)))
ifeq (,$(shell which opm 2>/dev/null))
	@{ \
	set -e ;\
	mkdir -p $(dir $(OPM)) ;\
	OS=$(shell go env GOOS) && ARCH=$(shell go env GOARCH) && \
	curl -sSLo $(OPM) https://github.com/operator-framework/operator-registry/releases/download/v1.15.1/$${OS}-$${ARCH}-opm ;\
	chmod +x $(OPM) ;\
	}
else
OPM = $(shell which opm)
endif
endif

# A comma-separated list of bundle images (e.g. make catalog-build BUNDLE_IMGS=example.com/operator-bundle:v0.1.0,example.com/operator-bundle:v0.2.0).
# These images MUST exist in a registry and be pull-able.
BUNDLE_IMGS ?= $(BUNDLE_IMG)

# The image tag given to the resulting catalog image (e.g. make catalog-build CATALOG_IMG=example.com/operator-catalog:v0.2.0).
CATALOG_IMG ?= $(IMAGE_TAG_BASE)-catalog:v$(VERSION)

# Set CATALOG_BASE_IMG to an existing catalog image tag to add $BUNDLE_IMGS to that image.
ifneq ($(origin CATALOG_BASE_IMG), undefined)
FROM_INDEX_OPT := --from-index $(CATALOG_BASE_IMG)
endif

# Build a catalog image by adding bundle images to an empty catalog using the operator package manager tool, 'opm'.
# This recipe invokes 'opm' in 'semver' bundle add mode. For more information on add modes, see:
# https://github.com/operator-framework/community-operators/blob/7f1438c/docs/packaging-operator.md#updating-your-existing-operator
.PHONY: catalog-build
catalog-build: opm ## Build a catalog image.
	$(OPM) index add --container-tool docker --mode semver --tag $(CATALOG_IMG) --bundles $(BUNDLE_IMGS) $(FROM_INDEX_OPT)

# Push the catalog image.
.PHONY: catalog-push
catalog-push: ## Push a catalog image.
	$(MAKE) docker-push IMG=$(CATALOG_IMG)

check: fmt lint

# All available linters: lint-dockerfiles lint-scripts lint-yaml lint-copyright-banner lint-go lint-python lint-helm lint-markdown lint-sass lint-typescript lint-protos
# Default value will run all linters, override these make target with your requirements:
#    eg: lint: lint-go lint-yaml
lint: lint-all

# TODO: remove this target after removing from test-infra
coverage:
	echo "COVERAGE REMOVED"

include common/Makefile.common.mk