# Copyright 2022 Google LLC.

#

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

###

# Global settings

# INSTALLER_IMG in inserted into the installer script as the operator image.

# If $IMG is set, it INSTALLER_IMG defaults to $IMG. If $IMG, then INSTALLER_IMG

# is assigned a placeholder.

ifdef IMG

INSTALLER_IMG=$(IMG)

endif

INSTALLER_IMG ?= cloud-sql-proxy-operator:latest

# IMG is used by build to determine where to push the docker image for the

# operator. You must set the IMG environment variable when you run make build

# or other dependent targets.

IMG ?=

# Import the local build environment file. This holds configuration specific

# to the local environment. build.sample.env describes the required configuration

# environment variables.

include build.env

# if build.env is missing, copy build.sample.env to build.env

build.env:

test -f $@ || cp build.sample.env build.env

#

###

# Set the build parameter PWD if it was not already set in the shell calling make.

PWD ?= $(shell pwd)

# 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

## The version to use for the cert-manager operator

CERT_MANAGER_VERSION=v1.15.0# renovate datasource=github-tags depName=cert-manager/cert-manager

##@ 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

# The `help` target prints out special makefile code comments to make it easier

# for developers to use this file.

# Help section headings have ##@ at the beginning of the line

# Target help message is on the same line as the target declaration and begins with ##

# Only add help messages to permanent makefile targets that we want to maintain forever.

# Intermediate or temporary build targets should only be documented with code

# comments, and should not print a help message.

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

install_tools: remove_tools all_tools ## Installs all development tools

@echo "TIME: $(shell date) end install tools"

.PHONY: generate

generate: ctrl_generate ctrl_manifests generate_crd_docs go_lint tf_lint installer reset_image add_copyright_header go_fmt yaml_fmt license_check license_save ## Runs code generation, format, and validation tools

@echo "TIME: $(shell date) end make generate"

.PHONY: build

build: generate build_push_docker ## Builds and pushes the docker image to tag defined in envvar IMG

@echo "TIME: $(shell date) end make build"

.PHONY: test

test: generate go_test ## Run tests (but not internal/teste2e)

@echo "TIME: $(shell date) end make test"

.PHONY: deploy

deploy: build deploy_with_kubeconfig ## Deploys the operator to the kubernetes cluster using envvar KUBECONFIG. Set $IMG envvar to the image tag.

@echo "TIME: $(shell date) end make deploy"

.PHONY: e2e_test

e2e_test: e2e_setup e2e_build_deploy e2e_test_run e2e_test_clean ## Run end-to-end tests on Google Cloud GKE

@echo "TIME: $(shell date) end make e2e_test"

##

# Development targets

# Load active version from version.txt

VERSION=$(shell cat $(PWD)/version.txt | tr -d '\n')

BUILD_ID:=$(shell $(PWD)/tools/build-identifier.sh | tr -d '\n')

VERSION_LDFLAGS=-X main.version=$(VERSION) -X main.buildID=$(BUILD_ID)

.PHONY: ctrl_generate

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

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

.PHONY: go_fmt

go_fmt: # Automatically formats go files

go vet ./...

go mod tidy

go run golang.org/x/tools/cmd/goimports@latest -w .

yaml_fmt: # Automatically format config/ to make generated and handwritten k8s yaml files consistent

go run github.com/UltiRequiem/yamlfmt@latest -w \

$(shell find ./config -iname '*.yaml' -or -iname '*.yml') $(shell find ./installer -iname '*.yaml' -or -iname '*.yml')

.PHONY: add_copyright_header

add_copyright_header: # Add the copyright header

go run github.com/google/addlicense@latest *

.PHONY: update_version_in_docs

update_version_in_docs: # Fix version numbers that appear in the markdown documentation

# Update links to the install script

find . -name '*.md' | xargs sed -i.bak -E 's|storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy-operator/[^/]+/install.sh|storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy-operator/v$(VERSION)/install.sh|g' && \

find . -name '*.md' | xargs sed -i.bak -E 's|storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy-operator/[^/]+/cloud-sql-proxy-operator.yaml|storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy-operator/v$(VERSION)/cloud-sql-proxy-operator.yaml|g' && \

find . -name '*.md.bak' | xargs rm -f

.PHONY: generate_crd_docs

generate_crd_docs: crd-ref-docs # Generate the

$(CRD_REF_DOCS) --source-path=internal/api/ --config=tools/config-crd-ref-docs.yaml --output-path=bin --renderer=markdown && \

cp bin/out.md docs/api.md

.PHONY: build_push_docker

build_push_docker: # Build docker image with the operator. set IMG env var before running: `IMG=example.com/img:1.0 make build`

@test -n "$(IMG)" || ( echo "IMG environment variable must be set to the public repo where you want to push the image" ; exit 1)

docker buildx build --platform "linux/amd64" \

--build-arg GO_LD_FLAGS="$(VERSION_LDFLAGS)" \

-f "Dockerfile-operator" \

--push -t "$(IMG)" "$(PWD)"

test -d 'bin' || mkdir -p bin

echo "$(IMG)" > bin/last-pushed-image-url.txt

.PHONY: go_lint

go_lint: golangci-lint # Run go lint tools, fail if unchecked errors

# Implements golang CI based on settings described here:

# See https://betterprogramming.pub/how-to-improve-code-quality-with-an-automatic-check-in-go-d18a5eb85f09

$(GOLANGCI_LINT) run --fix --fast ./...

.PHONY: tf_lint

tf_lint: terraform # Run terraform fmt to ensure terraform code is consistent

$(TERRAFORM) -chdir=infra/permissions fmt

$(TERRAFORM) -chdir=infra/resources fmt

.PHONY: go_test

go_test: ctrl_manifests envtest # Run tests (but not internal/teste2e)

KUBEBUILDER_ASSETS="$(shell $(ENVTEST) use $(ENVTEST_K8S_VERSION) -p path)" \

go test ./internal/.../. -coverprofile cover.out -race | tee test_results.txt

##

# 3rd Party License Checks

.PHONY: license_check

license_check: go-licenses # checks that all deps use allowed licenses

$(GO_LICENSES) check .

.PHONY: license_save

license_save: go-licenses # Download all 3rd party license for to include in docker image

( test -d ThirdPartyLicenses && rm -rf ThirdPartyLicenses ) || true

$(GO_LICENSES) save --save_path ThirdPartyLicenses .

##

# Kubernetes configuration targets

SOURCE_CODE_IMAGE=cloud-sql-proxy-operator:latest

.PHONY: ctrl_manifests

ctrl_manifests: controller-gen # Use controller-gen to generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects.

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

.PHONY: reset_image

reset_image: kustomize # Reset the image used in the kubernetes config to a default image.

cd config/manager && $(KUSTOMIZE) edit set image controller=$(SOURCE_CODE_IMAGE)

.PHONY: update_image

update_image: kustomize # Update the image used in the kubernetes config to $(IMG)

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

.PHONY: deploy_with_kubeconfig # Deploy the kubernetes configuration to the current default cluster using kubectl

deploy_with_kubeconfig: install_certmanager install_crd deploy_operator

.PHONY: install_certmanager

install_certmanager: helm # Install the cert-manager operator to manage the certificates for the operator webhooks

helm repo add jetstack https://charts.jetstack.io

helm repo update

helm get all -n cert-manager cert-manager || \

helm install \

cert-manager jetstack/cert-manager \

--namespace cert-manager \

--version "$(CERT_MANAGER_VERSION)" \

--create-namespace \

--set global.leaderElection.namespace=cert-manager \

--set installCRDs=true

.PHONY: install_crd

install_crd: kustomize kubectl # Install CRDs into the K8s cluster using the kubectl default behavior

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

.PHONY: deploy_operator

deploy_operator: kustomize kubectl # Deploy controller to the K8s cluster using the kubectl default behavior

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

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

$(E2E_KUBECTL) rollout status deployment -n cloud-sql-proxy-operator-system cloud-sql-proxy-operator-controller-manager --timeout=3m

$(E2E_PRIVATE_KUBECTL) rollout status deployment -n cloud-sql-proxy-operator-system cloud-sql-proxy-operator-controller-manager --timeout=3m

##

# Update installer

.PHONY: installer

installer: installer/cloud-sql-proxy-operator.yaml installer/install.sh

.PHONY: installer/cloud-sql-proxy-operator.yaml

installer/cloud-sql-proxy-operator.yaml: kustomize # Build the single yaml file for deploying the operator

cd config/manager && $(KUSTOMIZE) edit set image controller=$(INSTALLER_IMG)

mkdir -p installer

$(KUSTOMIZE) build config/default > $@

cd config/manager && $(KUSTOMIZE) edit set image controller=$(SOURCE_CODE_IMAGE)

.PHONY: installer/install.sh

installer/install.sh: ## Build install shell script to deploy the operator

cat tools/install.sh | \

sed 's/__VERSION__/v$(VERSION)/g' | \

sed 's/__CERT_MANAGER_VERSION__/$(CERT_MANAGER_VERSION)/g' > $@

##

##@ Google Cloud End to End Test

# This is the file where Terraform will write the kubeconfig.yaml for the

# GKE cluster.

KUBECONFIG_E2E ?= $(PWD)/bin/e2e-kubeconfig.yaml

PRIVATE_KUBECONFIG_E2E ?= $(PWD)/bin/e2e-private-kubeconfig.yaml

# This is the file where Terraform will write the kubeconfig.yaml for the

# GKE cluster.

ENVIRONMENT_NAME ?= $(shell whoami)

# kubectl command with proper environment vars set

E2E_KUBECTL_ENV = USE_GKE_E2E_AUTH_PLUGIN=True KUBECONFIG=$(KUBECONFIG_E2E)

E2E_PRIVATE_KUBECTL_ENV = USE_GKE_E2E_AUTH_PLUGIN=True KUBECONFIG=$(PRIVATE_KUBECONFIG_E2E)

E2E_KUBECTL = $(E2E_KUBECTL_ENV) $(KUBECTL)

E2E_PRIVATE_KUBECTL = $(E2E_PRIVATE_KUBECTL_ENV) $(KUBECTL)

# This is the file where Terraform will write the URL to the e2e container registry

E2E_DOCKER_URL_FILE :=$(PWD)/bin/gcloud-docker-repo.url

E2E_DOCKER_URL=$(shell cat $(E2E_DOCKER_URL_FILE) | tr -d '\n')

# Default value in the Makefile blank. When blank tests will use workload.DefaultProxyImage

E2E_PROXY_URL ?= ""

E2E_WORK_DIR=$(PWD)/bin/e2e

$(E2E_WORK_DIR):

mkdir -p "$(E2E_WORK_DIR)"

## Intermediate targets for developers to use when running e2e tests

.PHONY: e2e_setup

e2e_setup: e2e_project e2e_cluster e2e_cert_manager_deploy ## Provision and reconcile test infrastructure for e2e tests

.PHONY: e2e_build_deploy

e2e_build_deploy: e2e_install_crd e2e_image_push e2e_deploy ## Build and deploy the operator to e2e cluster

.PHONY: e2e_test_run

e2e_test_run: e2e_cleanup_test_namespaces e2e_test_run_gotest ## Run the golang e2e tests

.PHONY: e2e_test_clean

e2e_test_clean: e2e_cleanup_test_namespaces e2e_undeploy ## Remove all operator and testcase configs from the e2e k8s cluster

.PHONY: e2e_teardown

e2e_teardown: e2e_cluster_destroy ## Remove the test infrastructure for e2e tests from the Google Cloud Project

.PHONY: e2e_test_job

e2e_test_job: e2e_setup_job e2e_build_deploy e2e_test_run

.PHONY: e2e_setup_job

e2e_setup_job: e2e_project e2e_cluster_job e2e_cert_manager_deploy

.PHONY: e2e_project

e2e_project: gcloud # Check that the Google Cloud project exists

@gcloud projects describe $(E2E_PROJECT_ID) 2>/dev/null || \

( echo "No Google Cloud Project $(E2E_PROJECT_ID) found"; exit 1 )

.PHONY: e2e_cluster_job

e2e_cluster_job: e2e_project terraform # Build infrastructure for e2e tests in the test job

PROJECT_DIR=$(PWD) \

E2E_PROJECT_ID=$(E2E_PROJECT_ID) \

KUBECONFIG_E2E=$(KUBECONFIG_E2E) \

PRIVATE_KUBECONFIG_E2E=$(PRIVATE_KUBECONFIG_E2E) \

E2E_DOCKER_URL_FILE=$(E2E_DOCKER_URL_FILE) \

ENVIRONMENT_NAME=$(ENVIRONMENT_NAME) \

NODEPOOL_SERVICEACCOUNT_EMAIL=$(NODEPOOL_SERVICEACCOUNT_EMAIL) \

WORKLOAD_ID_SERVICEACCOUNT_EMAIL=$(WORKLOAD_ID_SERVICEACCOUNT_EMAIL) \

TFSTATE_STORAGE_BUCKET=$(TFSTATE_STORAGE_BUCKET) \

TESTINFRA_JSON_FILE=$(LOCALBIN)/testinfra.json \

infra/run.sh apply_e2e_job

.PHONY: e2e_cluster

e2e_cluster: e2e_project terraform # Build infrastructure for e2e tests

PROJECT_DIR=$(PWD) \

E2E_PROJECT_ID=$(E2E_PROJECT_ID) \

KUBECONFIG_E2E=$(KUBECONFIG_E2E) \

PRIVATE_KUBECONFIG_E2E=$(PRIVATE_KUBECONFIG_E2E) \

E2E_DOCKER_URL_FILE=$(E2E_DOCKER_URL_FILE) \

ENVIRONMENT_NAME=$(ENVIRONMENT_NAME) \

TESTINFRA_JSON_FILE=$(LOCALBIN)/testinfra.json \

infra/run.sh apply

.PHONY: e2e_cluster_destroy

e2e_cluster_destroy: e2e_project terraform # Destroy the infrastructure for e2e tests

PROJECT_DIR=$(PWD) \

E2E_PROJECT_ID=$(E2E_PROJECT_ID) \

KUBECONFIG_E2E=$(KUBECONFIG_E2E) \

PRIVATE_KUBECONFIG_E2E=$(PRIVATE_KUBECONFIG_E2E) \

E2E_DOCKER_URL_FILE=$(E2E_DOCKER_URL_FILE) \

ENVIRONMENT_NAME=$(ENVIRONMENT_NAME) \

TESTINFRA_JSON_FILE=$(LOCALBIN)/testinfra.json \

infra/run.sh destroy

.PHONY: e2e_cert_manager_deploy

e2e_cert_manager_deploy: e2e_project helm # Deploy the certificate manager

KUBECONFIG=$(KUBECONFIG_E2E) CERT_MANAGER_VERSION=$(CERT_MANAGER_VERSION) tools/helm-install-certmanager.sh

KUBECONFIG=$(PRIVATE_KUBECONFIG_E2E) CERT_MANAGER_VERSION=$(CERT_MANAGER_VERSION) tools/helm-install-certmanager.sh

.PHONY: e2e_install_crd

e2e_install_crd: generate e2e_project kustomize kubectl $(E2E_WORK_DIR) # Install CRDs into the GKE cluster

$(KUSTOMIZE) build config/crd > $(E2E_WORK_DIR)/crd.yaml

$(E2E_KUBECTL) apply -f $(E2E_WORK_DIR)/crd.yaml

$(E2E_PRIVATE_KUBECTL) apply -f $(E2E_WORK_DIR)/crd.yaml

.PHONY: e2e_deploy

e2e_deploy: e2e_project kustomize kubectl $(E2E_WORK_DIR) # Deploy the operator to the GKE cluster

cd config/manager && $(KUSTOMIZE) edit set image controller=$(E2E_OPERATOR_URL)

$(KUSTOMIZE) build config/default > $(E2E_WORK_DIR)/operator.yaml

$(E2E_KUBECTL) apply -f $(E2E_WORK_DIR)/operator.yaml

$(E2E_PRIVATE_KUBECTL) apply -f $(E2E_WORK_DIR)/operator.yaml

$(E2E_KUBECTL) rollout status deployment -n cloud-sql-proxy-operator-system cloud-sql-proxy-operator-controller-manager --timeout=90s

$(E2E_PRIVATE_KUBECTL) rollout status deployment -n cloud-sql-proxy-operator-system cloud-sql-proxy-operator-controller-manager --timeout=90s

# Note: `go test --count=1` is used to make sure go actually runs the tests every

# time. By default go will skip the tests when go source files are unchanged.

.PHONY: e2e_test_run_gotest

e2e_test_run_gotest: # Run the golang e2e tests

USE_GKE_E2E_AUTH_PLUGIN=True \

TEST_INFRA_JSON=$(LOCALBIN)/testinfra.json \

PROXY_IMAGE_URL=$(E2E_PROXY_URL) \

OPERATOR_IMAGE_URL=$(E2E_OPERATOR_URL) \

go test --count=1 -v -race ./tests/... | tee test_results.txt

.PHONY: e2e_cleanup_test_namespaces

e2e_cleanup_test_namespaces: e2e_project kustomize kubectl # remove e2e test namespaces named "test*"

( $(E2E_KUBECTL) get ns -o=name | \

grep namespace/test | \

$(E2E_KUBECTL_ENV) xargs $(KUBECTL) delete ) || true

( $(E2E_PRIVATE_KUBECTL) get ns -o=name | \

grep namespace/test | \

$(E2E_PRIVATE_KUBECTL_ENV) xargs $(KUBECTL) delete ) || true

.PHONY: e2e_undeploy

e2e_undeploy: e2e_project kustomize kubectl $(E2E_WORK_DIR) # Remove the operator from the GKE cluster

$(E2E_KUBECTL) delete -f $(E2E_WORK_DIR)/operator.yaml

$(E2E_PRIVATE_KUBECTL) delete -f $(E2E_WORK_DIR)/operator.yaml

###

# Build the operator docker image and push it to the

# google cloud project repo.

E2E_OPERATOR_URL_FILE=$(PWD)/bin/last-gcloud-operator-url.txt

E2E_OPERATOR_URL=$(shell cat $(E2E_OPERATOR_URL_FILE) | tr -d "\n")

.PHONY: e2e_image_push

e2e_image_push: generate # Build and push a operator image to the e2e artifact repo

PROJECT_DIR=$(PWD) \

IMAGE_NAME=cloud-sql-auth-proxy-operator \

REPO_URL=$(E2E_DOCKER_URL) \

IMAGE_URL_OUT=$(E2E_OPERATOR_URL_FILE) \

PLATFORMS=linux/amd64 \

DOCKER_FILE_NAME=Dockerfile-operator \

$(PWD)/tools/docker-build.sh

###

# Build a version of the cloud-sql-proxy from local sources

E2E_LOCAL_PROXY_PROJECT_DIR?=/not-set

E2E_LOCAL_PROXY_BUILD_URL_FILE=$(PWD)/bin/last-local-proxy-url.txt

E2E_LOCAL_PROXY_BUILD_URL=$(shell cat $(E2E_LOCAL_PROXY_BUILD_URL_FILE) | tr -d "\n")

.PHONY: e2e_image_push

e2e_local_proxy_image_push: # Build and push the proxy image from a local working directory to the e2e artifact repo

test -d $(E2E_LOCAL_PROXY_PROJECT_DIR) && \

PROJECT_DIR=$(E2E_LOCAL_PROXY_PROJECT_DIR) \

IMAGE_NAME=cloud-sql-proxy-dev \

REPO_URL=$(E2E_DOCKER_URL) \

IMAGE_URL_OUT=$(E2E_LOCAL_PROXY_BUILD_URL_FILE) \

PLATFORMS=linux/amd64 \

DOCKER_FILE_NAME=Dockerfile \

$(PWD)/tools/docker-build.sh

##

# Build tool dependencies

## Location to install dependencies to

LOCALBIN ?= $(shell pwd)/bin

$(LOCALBIN):

test -d $@ || mkdir -p $@

## Tool Binaries

KUSTOMIZE ?= $(LOCALBIN)/kustomize

CONTROLLER_GEN ?= $(LOCALBIN)/controller-gen

KUBECTL ?= $(LOCALBIN)/kubectl

ENVTEST ?= $(LOCALBIN)/setup-envtest

TERRAFORM ?= $(LOCALBIN)/terraform

GOLANGCI_LINT ?= $(LOCALBIN)/golangci-lint

GO_LICENSES ?= $(LOCALBIN)/go-licenses

CRD_REF_DOCS ?= $(LOCALBIN)/crd-ref-docs

## Tool Versions

# Important note: avoid adding spaces in the macro declarations as any

# additional whitespace will break the renovate regex rules.

KUBECTL_VERSION=v1.29.3# renovate datasource=github-tags depName=kubernetes/kubernetes

TERRAFORM_VERSION=v1.8.5# renovate datasource=github-tags depName=hashicorp/terraform

CONTROLLER_TOOLS_VERSION=v0.14.0# renovate datasource=go depName=sigs.k8s.io/controller-tools

CRD_REF_DOCS_VERSION=v0.0.12# renovate datasource=go depName=github.com/elastic/crd-ref-docs

GOLANGCI_LINT_VERSION=v1.59.1# renovate datasource=go depName=github.com/golangci/golangci-lint/cmd/golangci-lint

GO_LICENSES_VERSION=v1.6.0# renovate datasource=go depName=github.com/google/go-licenses

KUSTOMIZE_VERSION=v4.5.2# don't manage with renovate, this repo has non-standard tags

GOOS?=$(shell go env GOOS | tr -d '\n')

GOARCH?=$(shell go env GOARCH | tr -d '\n')

remove_tools:

rm -rf $(KUSTOMIZE) $(CONTROLLER_GEN) $(KUBECTL) $(ENVTEST) $(TERRAFORM) $(GOLANGCI_LINT) $(CRD_REF_DOCS)

all_tools: kustomize controller-gen envtest kubectl terraform golangci-lint crd-ref-docs

.PHONY: controller-gen

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

$(CONTROLLER_GEN): $(LOCALBIN)

test -s $(LOCALBIN)/controller-gen || GOBIN=$(LOCALBIN) go install sigs.k8s.io/controller-tools/cmd/controller-gen@$(CONTROLLER_TOOLS_VERSION)

KUSTOMIZE_INSTALL_SCRIPT ?= "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh"

.PHONY: kustomize

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

$(KUSTOMIZE): $(LOCALBIN)

test -s $(LOCALBIN)/kustomize || { curl -s $(KUSTOMIZE_INSTALL_SCRIPT) | bash -s -- $(subst v,,$(KUSTOMIZE_VERSION)) $(LOCALBIN); }

.PHONY: envtest

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

$(ENVTEST): $(LOCALBIN)

test -s $(LOCALBIN)/setup-envtest || GOBIN=$(LOCALBIN) go install sigs.k8s.io/controller-runtime/tools/setup-envtest@latest

.PHONY: crd-ref-docs

crd-ref-docs: $(CRD_REF_DOCS) # Download crd-ref-docs locally if necessary.

$(CRD_REF_DOCS): $(LOCALBIN)

test -s $(LOCALBIN)/crd-ref-docs || GOBIN=$(LOCALBIN) go install github.com/elastic/crd-ref-docs@$(CRD_REF_DOCS_VERSION)

.PHONY: kubectl

kubectl: $(KUBECTL) # Download kubectl

$(KUBECTL): $(LOCALBIN)

test -s $@ || \

( curl -L -o $@ https://dl.k8s.io/release/$(KUBECTL_VERSION)/bin/$(GOOS)/$(GOARCH)/kubectl && \

chmod a+x $@ && \

touch $@ )

.PHONY: terraform

terraform: $(TERRAFORM) # Download terraform

$(TERRAFORM): $(LOCALBIN)

test -s $@ || \

( curl -L -o $@.zip https://releases.hashicorp.com/terraform/$(subst v,,$(TERRAFORM_VERSION))/terraform_$(subst v,,$(TERRAFORM_VERSION))_$(GOOS)_$(GOARCH).zip && \

cd $(LOCALBIN) && unzip -o $@.zip && \

rm -f $@.zip && \

chmod a+x $@ && \

touch $@ )

.PHONY: golangci-lint

golangci-lint: $(GOLANGCI_LINT) ## Download controller-gen locally if necessary.

$(GOLANGCI_LINT): $(LOCALBIN)

test -s $@ || GOBIN=$(LOCALBIN) go install github.com/golangci/golangci-lint/cmd/golangci-lint@$(GOLANGCI_LINT_VERSION)

.PHONY: go-licenses

go-licenses: $(GO_LICENSES) ## Download controller-gen locally if necessary.

$(GO_LICENSES): $(LOCALBIN)

test -s $@ || GOBIN=$(LOCALBIN) go install github.com/google/go-licenses@$(GO_LICENSES_VERSION)

##

# Tools that need to be installed on the development machine

.PHONY: gcloud

gcloud:

@which gcloud > /dev/null || \

(echo "Google Cloud API command line tools are not available in your path" ;\

echo "Instructions on how to install https://cloud.google.com/sdk/docs/install " ; \

exit 1)

.PHONY: helm

helm:

@which helm > /dev/null || \

(echo "Helm command line tools are not available in your path" ; \

echo "Instructions on how to install https://helm.sh/docs/helm/helm_install/ " ; \

exit 1)