Makefile

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

GO_PKG=github.com/openshift/cluster-monitoring-operator
REPO?=quay.io/openshift/cluster-monitoring-operator
TAG?=$(shell git rev-parse --short HEAD)
VERSION=$(shell cat VERSION | tr -d " \t\n\r")

GOOS?=$(shell go env GOOS)
GOARCH?=$(shell go env GOARCH)
GO111MODULE?=on
GOPROXY?=http://proxy.golang.org
export GO111MODULE
export GOPROXY

# go pakages for unit tests, excluding e2e tests
PKGS=$(shell go list ./... | grep -v /test/e2e)
GOLANG_FILES:=$(shell find . -name \*.go -print)
# NOTE: grep -v %.yaml is needed  because "%s-policy.yaml" is used
# in manifest.go and that isn't a valid asset.
# NOTE: Certain paths included in the manifest.go file are not valid
# asset paths and should be excluded from the list of assets. These
# paths are:
# - /etc/
ASSETS=$(shell grep -oh '[^"]*/.*\.yaml' pkg/manifests/manifests.go \
          | grep -v '^/etc' \
          | grep -v '%.*yaml' | sed 's/^/assets\//')

BIN_DIR ?= $(shell pwd)/tmp/bin

# Docgen related variables
TYPES_TARGET=pkg/manifests/types.go
K8S_VERSION=$(shell echo -n v1. &&  cat go.mod | grep -w "k8s.io/api" | awk '{ print $$2 }' | cut -d "." -f 2)
PO_VERSION=$(shell cat go.mod | grep "github.com/prometheus-operator/prometheus-operator[^=>]\+$$" | awk '{ print $$2 }' | sort -u)

EMBEDMD_BIN=$(BIN_DIR)/embedmd
JB_BIN=$(BIN_DIR)/jb
GOJSONTOYAML_BIN=$(BIN_DIR)/gojsontoyaml
JSONNET_BIN=$(BIN_DIR)/jsonnet
JSONNETFMT_BIN=$(BIN_DIR)/jsonnetfmt
GOLANGCI_LINT_BIN=$(BIN_DIR)/golangci-lint
GOLANGCI_LINT_VERSION=v1.55.2
PROMTOOL_BIN=$(BIN_DIR)/promtool
DOCGEN_BIN=$(BIN_DIR)/docgen
MISSPELL_BIN=$(BIN_DIR)/misspell
TOOLING=$(EMBEDMD_BIN) $(JB_BIN) $(GOJSONTOYAML_BIN) $(JSONNET_BIN) $(JSONNETFMT_BIN) $(PROMTOOL_BIN) $(DOCGEN_BIN) $(GOLANGCI_LINT_BIN)

MANIFESTS_DIR ?= $(shell pwd)/manifests
JSON_MANIFESTS_DIR ?= $(shell pwd)/tmp/json-manifests/manifests
MANIFESTS ?= $(wildcard $(MANIFESTS_DIR)/*.yaml)
JSON_MANIFESTS ?= $(patsubst $(MANIFESTS_DIR)%,$(JSON_MANIFESTS_DIR)%,$(patsubst %.yaml,%.json,$(MANIFESTS)))

JSONNET_SRC=$(shell find ./jsonnet -type f -not -path "./jsonnet/vendor*")
JSONNET_VENDOR=jsonnet/vendor

GO_BUILD_RECIPE=GOOS=$(GOOS) GOARCH=$(GOARCH) CGO_ENABLED=0 go build --ldflags="-s -X $(GO_PKG)/pkg/operator.Version=$(VERSION)"
MARKDOWN_DOCS=$(shell find . -type f -name '*.md' ! -path '*/vendor/*' ! -path './git/*'  \
				! -name 'data-collection.md' ! -name 'sample-metrics.md' | sort)

.PHONY: all
all: clean format generate build test

.PHONY: clean
clean:
	rm -rf $(JSONNET_VENDOR) operator .hack-operator-image tmp/

############
# Building #
############

# run-local builds and runs operator out of cluster.
# use make run-local SWITCH_TO_CMO=false to not switch the login to CMO
# service-account. E.g. when logged in kube:admin and what to run operator
# as kube:admin
.PHONY: run-local
run-local: build
	@if $${SWITCH_TO_CMO:-true} ; then \
		PATH="$(PATH):$(BIN_DIR)" \
		KUBECONFIG=$(KUBECONFIG)  ./hack/local-cmo.sh ;\
	else \
		PATH="$(PATH):$(BIN_DIR)" \
		KUBECONFIG=$(KUBECONFIG) ./hack/local-cmo.sh --no-cmo-login ;\
	fi

.PHONY: build
build: operator

.PHONY: operator
operator: $(GOLANG_FILES)
	$(GO_BUILD_RECIPE) -o operator $(GO_PKG)/cmd/operator

# We need this Make target so that we can build the operator depending
# only on what is checked into the repo, without calling to the internet.
.PHONY: operator-no-deps
operator-no-deps:
	$(GO_BUILD_RECIPE) -o operator $(GO_PKG)/cmd/operator

.PHONY: image
image: .hack-operator-image

.hack-operator-image: Dockerfile operator
# Create empty target file, for the sole purpose of recording when this target
# was last executed via the last-modification timestamp on the file. See
# https://www.gnu.org/software/make/manual/make.html#Empty-Targets
	docker build -t $(REPO):$(TAG) .
	touch $@

##############
# Generating #
##############

.PHONY: vendor
vendor:
	go mod tidy
	go mod vendor
	go mod verify

.PHONY: update-go-deps
update-go-deps:
	for m in $$(go list -mod=readonly -m -f '{{ if and (not .Indirect) (not .Main)}}{{.Path}}{{end}}' all); do \
		go get $$m; \
	done
	@echo "Don't forget to run 'make vendor'"

.PHONY: update
update: $(JB_BIN)
	cd jsonnet && $(JB_BIN) update $(COMPONENTS)

.PHONY: generate
generate: build-jsonnet docs

.PHONY: verify
verify: check-assets check-rules check-runbooks

# TODO(paulfantom): generate-in-docker can be completely removed after OpenShift 4.7 is EOL
.PHONY: generate-in-docker
generate-in-docker:
	echo -e "FROM golang:1.14 \n RUN apt update && apt install python-yaml jq -y \n RUN mkdir /.cache && chown $(shell id -u):$(shell id -g) /.cache" | docker build -t cmo-tooling -
	docker run -it --user $(shell id -u):$(shell id -g) \
		-w /go/src/github.com/openshift/cluster-monitoring-operator \
		-v ${PWD}:/go/src/github.com/openshift/cluster-monitoring-operator \
		cmo-tooling make generate


$(JSONNET_VENDOR): $(JB_BIN) jsonnet/jsonnetfile.json jsonnet/jsonnetfile.lock.json
	cd jsonnet && $(JB_BIN) install

$(ASSETS): build-jsonnet
	# Check if files were properly generated
	[ -f "$@" ] || exit 1

.PHONY: build-jsonnet
build-jsonnet: $(JSONNET_BIN) $(GOJSONTOYAML_BIN) $(JSONNET_SRC) $(JSONNET_VENDOR) json-manifests json-crds
	./hack/build-jsonnet.sh

$(JSON_MANIFESTS): $(MANIFESTS)
	cat $(MANIFESTS_DIR)/$(patsubst %.json,%.yaml,$(@F)) | $(GOJSONTOYAML_BIN) -yamltojson > $@

.PHONY: json-manifests
json-manifests: $(JSON_MANIFESTS_DIR) $(JSON_MANIFESTS)

.PHONY: json-crds
json-crds: jsonnet/crds/alertingrules-custom-resource-definition.json jsonnet/crds/alertrelabelconfigs-custom-resource-definition.json

jsonnet/crds/alertingrules-custom-resource-definition.json: vendor/github.com/openshift/api/monitoring/v1/zz_generated.crd-manifests/0000_50_monitoring_01_alertingrules.crd.yaml
	$(GOJSONTOYAML_BIN) -yamltojson < $< > $@

jsonnet/crds/alertrelabelconfigs-custom-resource-definition.json: vendor/github.com/openshift/api/monitoring/v1/zz_generated.crd-manifests/0000_50_monitoring_02_alertrelabelconfigs.crd.yaml
	$(GOJSONTOYAML_BIN) -yamltojson < $< > $@

.PHONY: versions
versions:
	@cd ./hack/go && go mod tidy && go mod download && go run -mod=mod generate_versions.go

.PHONY: check-versions
check-versions: VERSION_FILE=jsonnet/versions.yaml
check-versions:
	export VERSION_FILE=$(VERSION_FILE) && $(MAKE) versions && git diff --exit-code -- ${VERSION_FILE}

.PHONY: docs
docs: $(EMBEDMD_BIN) $(DOCGEN_BIN) Documentation/telemetry/telemeter_query
	$(EMBEDMD_BIN) -w `find Documentation -name "*.md"`
	$(DOCGEN_BIN) api markdown $(K8S_VERSION) $(PO_VERSION) $(TYPES_TARGET) > Documentation/api.md
	$(DOCGEN_BIN) api asciidocs $(K8S_VERSION) $(PO_VERSION) $(TYPES_TARGET)
	$(DOCGEN_BIN) resources markdown > Documentation/resources.md
	$(DOCGEN_BIN) resources asciidocs > Documentation/resources.adoc

Documentation/telemetry/telemeter_query: manifests/0000_50_cluster-monitoring-operator_04-config.yaml hack/telemeter_query.go
	go generate ./hack/telemeter_query.go > Documentation/telemetry/telemeter_query

##############
# Formatting #
##############

.PHONY: format
format: go-fmt golangci-lint shellcheck jsonnet-fmt misspell

.PHONY: go-fmt
go-fmt:
	go fmt ./...

.PHONY: golangci-lint
golangci-lint: $(GOLANGCI_LINT_BIN)
	$(GOLANGCI_LINT_BIN) run --verbose --print-resources-usage

.PHONY: golangci-lint-fix
golangci-lint-fix: $(GOLANGCI_LINT_BIN)
	$(GOLANGCI_LINT_BIN) run --verbose --print-resources-usage --fix

.PHONY:
misspell:
	$(MISSPELL_BIN) -error $(MARKDOWN_DOCS)

.PHONY:
misspell-fix:
	$(MISSPELL_BIN) -w $(MARKDOWN_DOCS)

.PHONY: jsonnet-fmt
jsonnet-fmt: $(JSONNETFMT_BIN)
	find jsonnet/ -name 'vendor' -prune -o -name '*.libsonnet' -print -o -name '*.jsonnet' -print | xargs -n 1 -- $(JSONNETFMT_BIN) -i

.PHONY: shellcheck
shellcheck:
	hack/shellcheck.sh

tmp/rules.yaml: $(GOJSONTOYAML_BIN) $(ASSETS)
	mkdir -p tmp/rules
	hack/find-rules.sh | $(GOJSONTOYAML_BIN) > tmp/rules.yaml

.PHONY: check-rules
check-rules: $(PROMTOOL_BIN) tmp/rules.yaml
	rm -f tmp/"$@".out
	@$(PROMTOOL_BIN) check rules tmp/rules.yaml | tee "tmp/$@.out"

.PHONY: test-rules
test-rules: check-rules
	hack/test-rules.sh | tee "tmp/$@.out"

.PHONY: check-assets
check-assets:
	hack/check-assets.sh

.PHONY: check-runbooks
check-runbooks:
	# Get runbook urls from the alerts annotations and test if a link is broken
	# with wget. It also make sure that the command succeed when there are no urls.
	@grep -rho 'runbook_url.*' assets || true | cut -f2- -d: | wget --spider -nv -i -

###########
# Testing #
###########

.PHONY: test
test: test-unit test-rules test-e2e

.PHONY: test-unit
test-unit:
	go test -race -short $(PKGS) -count=1

.PHONY: test-e2e
test-e2e: KUBECONFIG?=$(HOME)/.kube/config
test-e2e:
	go test -v -timeout=150m ./test/e2e/ --kubeconfig $(KUBECONFIG)

$(BIN_DIR):
	mkdir -p $(BIN_DIR)

$(JSON_MANIFESTS_DIR):
	mkdir -p $(JSON_MANIFESTS_DIR)

$(TOOLING): $(BIN_DIR)
	@echo Installing tools from hack/tools/tools.go
	@cd hack/tools && go list -mod=mod -tags tools -e -f '{{ range .Imports }}{{ printf "%s\n" .}}{{end}}' ./ | xargs -tI % go build -mod=mod -o $(BIN_DIR) %
	@GOBIN=$(BIN_DIR) go install $(GO_PKG)/hack/docgen
	curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh| sh -s -- -b $(BIN_DIR) $(GOLANGCI_LINT_VERSION)