monok8s/makefile

include build.env
export

TAG ?= dev

PACKAGES_DIR := packages
OUT_DIR      := out

E2FSPROGS_TAR := $(PACKAGES_DIR)/e2fsprogs-$(E2FSPROGS_VERSION).tar.gz
BUSYBOX_TAR   := $(PACKAGES_DIR)/busybox-$(BUSYBOX_VERSION).tar.gz
ALPINE_TAR    := $(PACKAGES_DIR)/alpine-minirootfs-$(ALPINE_VER)-$(ALPINE_ARCH).tar.gz
NXP_TAR       := $(PACKAGES_DIR)/$(NXP_VERSION).tar.gz
CRIO_TAR      := $(PACKAGES_DIR)/$(CRIO_VERSION).tar.gz

# Kubernetes components
KUBELET_BIN := $(PACKAGES_DIR)/kubernetes/kubelet-$(KUBE_VERSION)
KUBEADM_BIN := $(PACKAGES_DIR)/kubernetes/kubeadm-$(KUBE_VERSION)
KUBECTL_BIN := $(PACKAGES_DIR)/kubernetes/kubectl-$(KUBE_VERSION)

CONFIGS_DIR          := configs
SCRIPTS_DIR          := scripts
CLUSTER_ENV_DEFAULT  := $(CONFIGS_DIR)/cluster.env.default
CLUSTER_ENV          := $(OUT_DIR)/cluster.env
NODE_ENV_DEFAULT     := configs/node.env.default
NODE_ENV             := $(OUT_DIR)/node.env

BOARD_ITB     := $(OUT_DIR)/board.itb
INITRAMFS     := $(OUT_DIR)/initramfs.cpio.gz
RELEASE_IMAGE := $(OUT_DIR)/monok8s-$(TAG).img.gz

KERNEL_IMAGE  := $(OUT_DIR)/Image.gz

BUILD_BASE_STAMP := $(OUT_DIR)/.build-base-$(TAG).stamp
CLITOOLS_BIN := bin/ctl-linux-$(ARCH)-$(TAG)

ALPINE_SERIES := $(word 1,$(subst ., ,$(ALPINE_VER))).$(word 2,$(subst ., ,$(ALPINE_VER)))

BUILD_VERSION   ?= $(KUBE_VERSION)
BUILD_DATE      := $(shell date -u +%Y-%m-%dT%H:%M:%SZ)
BUILD_GIT       := $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
BUILD_INFO_FILE := $(OUT_DIR)/build-info
BUILD_BASE_TAG := $(shell docker image inspect monok8s/build-base:dev | jq -r '.[].Id' | cut -d':' -f2 | cut -c -8 || echo dev)

# ---- File groups -------------------------------------------------------------

# Use find so adding new files under these dirs is automatically picked up.
ALPINE_SRCS    := $(shell find alpine -type f 2>/dev/null)
INITRAMFS_SRCS := $(shell find initramfs -type f 2>/dev/null)
KERNEL_SRCS    := $(shell find kernel-build -type f 2>/dev/null)

CLITOOLS_SRCS  := $(shell find clitools -type f 2>/dev/null)

BUILD_BASE_DEPS := \
	docker/build-base.Dockerfile \
	build.env \
	makefile

KERNEL_DEPS := \
	$(BUILD_BASE_STAMP) \
	$(NXP_TAR) \
	docker/kernel-build.Dockerfile \
	kernel-extra.config \
	$(KERNEL_SRCS) \
	build.env \
	makefile

INITRAMFS_DEPS := \
	$(KERNEL_IMAGE) \
	$(BUSYBOX_TAR) \
	$(E2FSPROGS_TAR) \
	docker/initramfs.Dockerfile \
	$(INITRAMFS_SRCS) \
	$(BUILD_INFO_FILE) \
	build.env \
	makefile

ITB_DEPS := \
	$(INITRAMFS) \
	docker/itb.Dockerfile \
	board.its \
	build.env \
	makefile

CLITOOLS := \
	$(CLITOOLS_SRCS)

RELEASE_DEPS := \
	$(BUILD_BASE_STAMP) \
	$(BUILD_INFO_FILE) \
	$(BOARD_ITB) \
	$(ALPINE_TAR) \
	$(CLITOOLS_BIN) \
	$(CRIO_TAR) \
	$(KUBELET_BIN) \
	$(KUBEADM_BIN) \
	$(KUBECTL_BIN) \
	docker/alpine.Dockerfile \
	$(ALPINE_SRCS) \
	build.env \
	makefile

# ---- Directory creation ------------------------------------------------------

$(PACKAGES_DIR):
	mkdir -p $@
	mkdir -p $@/kubernetes

$(OUT_DIR):
	mkdir -p $@

# ---- Package downloads -------------------------------------------------------
$(KUBELET_BIN): | $(PACKAGES_DIR)
	curl -L -o $@ "https://dl.k8s.io/$(KUBE_VERSION)/bin/linux/$(ARCH)/kubelet"

$(KUBEADM_BIN): | $(PACKAGES_DIR)
	curl -L -o $@ "https://dl.k8s.io/$(KUBE_VERSION)/bin/linux/$(ARCH)/kubeadm"

$(KUBECTL_BIN): | $(PACKAGES_DIR)
	curl -L -o $@ "https://dl.k8s.io/$(KUBE_VERSION)/bin/linux/$(ARCH)/kubectl"

$(BUSYBOX_TAR): | $(PACKAGES_DIR)
	curl -L -o $@ "https://github.com/mirror/busybox/archive/refs/tags/$(BUSYBOX_VERSION).tar.gz"

$(E2FSPROGS_TAR): | $(PACKAGES_DIR)
	curl -L -o $@ "https://github.com/tytso/e2fsprogs/archive/refs/tags/v$(E2FSPROGS_VERSION).tar.gz"

$(ALPINE_TAR): | $(PACKAGES_DIR)
	curl -L -o $@ "https://dl-cdn.alpinelinux.org/alpine/v$(ALPINE_SERIES)/releases/$(ALPINE_ARCH)/alpine-minirootfs-$(ALPINE_VER)-$(ALPINE_ARCH).tar.gz"

$(NXP_TAR): | $(PACKAGES_DIR)
	curl -L -o $@ "https://github.com/nxp-qoriq/linux/archive/refs/tags/$(NXP_VERSION).tar.gz"

$(CRIO_TAR): | $(PACKAGES_DIR)
	curl -L -o $@ "https://storage.googleapis.com/cri-o/artifacts/$(CRIO_VERSION).tar.gz"

# ---- Build stages ------------------------------------------------------------

$(BUILD_INFO_FILE):
	@mkdir -p $(dir $@)
	@printf '%s\n' \
		'export $(BUILD_TAG)_VERSION="$(BUILD_VERSION)"' \
		'export $(BUILD_TAG)_BUILD_DATE="$(BUILD_DATE)"' \
		'export $(BUILD_TAG)_GIT="$(BUILD_GIT)"' \
		'export $(BUILD_TAG)_RELEASE_IMAGE="$(notdir $(RELEASE_IMAGE))"' \
		> $@

$(BUILD_BASE_STAMP): $(BUILD_BASE_DEPS) | $(OUT_DIR)
	docker build \
		-f docker/build-base.Dockerfile \
		--build-arg TAG=$(TAG) \
		-t $(DOCKER_IMAGE_ROOT)/build-base:$(TAG) .
	@iid=$$(docker image inspect monok8s/build-base:$(TAG) | jq -r '.[].Id' | cut -d':' -f2 | cut -c -8); \
	docker tag monok8s/build-base:$(TAG) monok8s/build-base:$$iid; \
	touch $@

$(KERNEL_IMAGE): $(KERNEL_DEPS) | $(OUT_DIR)
	docker build \
		-f docker/kernel-build.Dockerfile \
		--build-arg DOCKER_IMAGE_ROOT=$(DOCKER_IMAGE_ROOT) \
		--build-arg TAG=$(TAG) \
		--build-arg ARCH=$(ARCH) \
		--build-arg CROSS_COMPILE=$(CROSS_COMPILE) \
		--build-arg NXP_VERSION=$(NXP_VERSION) \
		--build-arg DEVICE_TREE_TARGET=$(DEVICE_TREE_TARGET) \
		--output type=local,dest=./$(OUT_DIR) .
	test -f $@

$(INITRAMFS): $(INITRAMFS_DEPS) | $(OUT_DIR)
	docker build \
		-f docker/initramfs.Dockerfile \
		--build-arg DOCKER_IMAGE_ROOT=$(DOCKER_IMAGE_ROOT) \
		--build-arg TAG=$(TAG) \
		--build-arg ARCH=$(ARCH) \
		--build-arg CROSS_COMPILE=$(CROSS_COMPILE) \
		--build-arg BUSYBOX_VERSION=$(BUSYBOX_VERSION) \
		--build-arg E2FSPROGS_VERSION=$(E2FSPROGS_VERSION) \
		--build-arg BUILD_TAG=$(BUILD_TAG) \
		--output type=local,dest=./$(OUT_DIR) .
	test -f $@

$(CLITOOLS_BIN): $(CLITOOLS_SRCS)
	$(MAKE) -C clitools

$(BOARD_ITB): $(ITB_DEPS) | $(OUT_DIR)
	docker build \
		-f docker/itb.Dockerfile \
		--build-arg DOCKER_IMAGE_ROOT=$(DOCKER_IMAGE_ROOT) \
		--build-arg TAG=$(TAG) \
		--build-arg ARCH=$(ARCH) \
		--build-arg DEVICE_TREE_TARGET=$(DEVICE_TREE_TARGET) \
		--output type=local,dest=./$(OUT_DIR) .
	test -f $@

$(RELEASE_IMAGE): $(RELEASE_DEPS) | $(OUT_DIR)
	docker build \
		-f docker/alpine.Dockerfile \
		--no-cache \
		--build-arg DOCKER_IMAGE_ROOT=$(DOCKER_IMAGE_ROOT) \
		--build-arg TAG=$(TAG) \
		--build-arg ALPINE_ARCH=$(ALPINE_ARCH) \
		--build-arg ALPINE_VER=$(ALPINE_VER) \
		--build-arg KUBE_VERSION=$(KUBE_VERSION) \
		--build-arg CRIO_VERSION=$(CRIO_VERSION) \
		--build-arg DEVICE_TREE_TARGET=$(DEVICE_TREE_TARGET) \
		--build-arg BUILD_BASE_TAG=$(BUILD_BASE_TAG) \
		-t $(DOCKER_IMAGE_ROOT)/buildenv-alpine:$(TAG) .

	@cid=$$(docker create \
		--privileged \
		-v /cache/apk:/var/cache/apk \
		-v /cache/k8s-images:/var/cache/k8s-images \
		-v /var/run/docker.sock:/var/run/docker.sock \
		--device=/dev/loop0:/dev/loop0 \
		-e ALPINE_HOSTNAME=$(ALPINE_HOSTNAME) \
		-e ARCH=$(ARCH) \
		-e BUILD_DATE=$(BUILD_DATE) \
		-e BUILD_GIT=$(BUILD_GIT) \
		-e BUILD_VERSION=$(BUILD_VERSION) \
		-e DEVICE_TREE_TARGET=$(DEVICE_TREE_TARGET) \
		-e KUBE_IMG_CACHE=/var/cache/k8s-images \
		-e KUBE_VERSION=$(KUBE_VERSION) \
		-e RELEASE_IMAGE=$(RELEASE_IMAGE) \
		-e ROOTFS=/out/rootfs \
		-e TAG=$(TAG) \
		$(DOCKER_IMAGE_ROOT)/buildenv-alpine:$(TAG) \
		bash -lc '/build-rootfs.sh'); \
	docker start -a $$cid; \
	docker cp $$cid:/build/output.img.gz $@; \
	docker cp $$cid:/build/rootfs.ext4.zst $(OUT_DIR)/rootfs.ext4.zst; \
	docker rm $$cid

	test -f $@

check-functions:
	@echo "Checking function calls vs definitions..."
	@awk '/^main\(\)/ { in_main=1; next } \
	      in_main && /^\}/ { in_main=0 } \
	      in_main && /^[[:space:]]*[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*$$/ { \
	          gsub(/^[ \t]+/, "", $$0); \
	          print $$0 \
	      }' ./alpine/rootfs-extra/opt/scripts/bootstrap-cluster.sh \
	      | sort -u > /tmp/called.txt
	@grep -E '^[a-zA-Z_][a-zA-Z0-9_]*\(\)' ./alpine/rootfs-extra/opt/scripts/bootstrap-cluster.sh \
	      | sed 's/().*//' \
	      | sort -u > /tmp/defined.txt
	@echo "Missing functions:"
	@comm -23 /tmp/called.txt /tmp/defined.txt || true

# ---- config targets ------------------------------------------------------------

cluster-config: $(CLUSTER_ENV_DEFAULT) $(SCRIPTS_DIR)/merge-env.sh | $(OUT_DIR)
	sh $(SCRIPTS_DIR)/merge-env.sh $(CLUSTER_ENV_DEFAULT) $(CLUSTER_ENV)

cluster-defconfig: $(CLUSTER_ENV_DEFAULT) | $(OUT_DIR)
	cp $(CLUSTER_ENV_DEFAULT) $(CLUSTER_ENV)

cluster-print:
	@cat $(CLUSTER_ENV)

# ---- User targets ------------------------------------------------------------

release: $(RELEASE_IMAGE)

kernel: $(KERNEL_IMAGE)
initramfs: $(INITRAMFS)
itb: $(BOARD_ITB)
build-base: $(BUILD_BASE_STAMP)
clitools: $(CLITOOLS_BIN)

clean:
	rm -f \
		$(BUILD_BASE_STAMP) \
		$(KERNEL_IMAGE) \
		$(INITRAMFS) \
		$(BOARD_ITB) \
		$(RELEASE_IMAGE) \
		$(CLITOOLS_BIN)

distclean: clean
	rm -rf $(OUT_DIR)

pkgclean:
	rm -rf $(PACKAGES_DIR)

.PHONY: release kernel initramfs itb build-base clitools clean distclean pkgclean \
	cluster-config cluster-defconfig cluster-print