makefile

.SUFFIXES:
.DEFAULT_GOAL := help

DOCKER ?= docker

# Pins (CHISEL_REF, SPREAD_REF, GO_BUILDER_IMAGE, DOCKER_VERSION) and the
# matrix (VERSIONS, ARCHES, NATIVE_ARCHES) live in config.yaml. make re-reads
# this generated include whenever config.yaml changes.
include .stamp/config.mk
.stamp/config.mk: config.yaml hack/build_config.rb
	@mkdir -p .stamp
	@hack/build_config.rb --make > $@.tmp && mv $@.tmp $@

# Optional narrowing via env vars, e.g.:
#   make build-bread VER=24.04
#   make build-bread VER=24.04 ARCH=amd64
#   make build-bread-chisel-releases ARCH=arm64
VER  ?=
ARCH ?=
SELECTED_VERS   := $(if $(strip $(VER)),$(VER),$(VERSIONS))
SELECTED_ARCHES := $(if $(strip $(ARCH)),$(ARCH),$(ARCHES))
SELECTED_VER_ARCH := $(foreach v,$(SELECTED_VERS),$(foreach a,$(SELECTED_ARCHES),$(v)-$(a)))

# Host-arch detection (uname -m -> docker arch name). SELECTED_ARCH defaults to
# the host arch but honours an explicit ARCH=... override.
HOST_ARCH   := $(shell uname -m | sed -e 's/^x86_64$$/amd64/' -e 's/^aarch64$$/arm64/')
SELECTED_ARCH := $(if $(strip $(ARCH)),$(ARCH),$(HOST_ARCH))

# Full (non-narrowed) matrix used by `clean` so it nukes everything.
FULL_VER_ARCH := $(foreach v,$(VERSIONS),$(foreach a,$(ARCHES),$(v)-$(a)))

BREAD_STAMPS  := $(addprefix .stamp/bread-,$(SELECTED_VER_ARCH))
CHISEL_STAMPS := $(addprefix .stamp/bread-chisel-releases-,$(SELECTED_VER_ARCH))

# The test-host image only exists at 26.04, native arches only. ARCH
# narrowing applies.
BREAD_TEST_STAMPS := $(addprefix .stamp/bread-test-26.04-,$(if $(strip $(ARCH)),$(ARCH),$(NATIVE_ARCHES)))

TEMPLATES := $(wildcard templates/*.yaml.in)
INLINED   := $(patsubst templates/%.yaml.in,inlined/%.yaml,$(TEMPLATES))

SCRIPTS := $(wildcard scripts/*.sh)

.PHONY: help
help:  ## Show this help
	@grep -hE '^[a-zA-Z_./-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | \
		awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-40s\033[0m %s\n", $$1, $$2}'

.PHONY: all
all: build-all inline  ## Build all images + generate inlined yamls

.PHONY: build-all
build-all: build-bread build-bread-chisel-releases  ## Build all images (narrow via VER=... ARCH=...)

.PHONY: build-bread
build-bread: $(BREAD_STAMPS)  ## Build bread images (narrow via VER=... ARCH=...)

.PHONY: build-bread-chisel-releases
build-bread-chisel-releases: $(CHISEL_STAMPS)  ## Build bread-chisel-releases images (narrow via VER=... ARCH=...)

.PHONY: build-bread-test
build-bread-test: $(BREAD_TEST_STAMPS)  ## Build the bread-test (26.04 only, native arches) test-host image

.PHONY: binaries
binaries: $(addprefix .stamp/binaries-,$(SELECTED_ARCHES))  ## Cross-compile chisel + spread + docker cli (narrow via ARCH=...)

# Run the contract/integration spread suite (tests/spread.yaml). Builds the
# test-host image + inlined yamls first. Pass extra spread args via SPREAD_ARGS,
# e.g. make test SPREAD_ARGS='-debug'.
SPREAD_ARGS ?=
# The contract-bread-chisel-releases run task allocates the per-version
# bread-chisel-releases:<ver>-<arch> images via the host docker socket, so all
# versions (host arch) must exist before the suite runs.
TEST_STAMPS := .stamp/bread-test-26.04-$(SELECTED_ARCH) \
	$(foreach v,$(VERSIONS),.stamp/bread-chisel-releases-$(v)-$(SELECTED_ARCH))
.PHONY: test
test: $(TEST_STAMPS) inline  ## Run the spread test suite (host arch; ARCH=... to override, SPREAD_ARGS=... for flags)
	cd tests && spread $(SPREAD_ARGS) outer:ubuntu-26.04-$(SELECTED_ARCH)

.PHONY: check-base
check-base:  ## Report upstream ubuntu base-image digest drift (non-zero exit on drift)
	@hack/check_base.sh --check

.PHONY: update-base
update-base:  ## Rewrite base Dockerfile @sha256 pins to the current upstream digests
	@hack/check_base.sh --write

# Demo runs only on LTS versions (24.04, 26.04) x native arches, regardless of VER/ARCH narrowing.
DEMO_STAMPS := $(foreach a,$(NATIVE_ARCHES),.stamp/bread-24.04-$(a) .stamp/bread-26.04-$(a))

.PHONY: demo
demo: $(DEMO_STAMPS)  ## Run the spread demo on LTS systems (24.04 + 26.04, native arches)
	$(MAKE) -C demo run

.PHONY: inline
inline: $(INLINED)  ## Generate inlined/*.yaml from templates/*.yaml.in

# Hash-stamp pattern: stamp file contents = hash of all inputs that affect
# this image. FORCE-dep makes us recompute hash each run; stamp content only
# updates when inputs change, so downstream rebuilds only fire on a real
# input change. Heavy lifting lives in hack/build_image.sh.
.PHONY: FORCE
FORCE:

.PRECIOUS: .stamp/bread-% .stamp/bread-chisel-releases-% .stamp/bread-test-% .stamp/binaries-%

.stamp:
	@mkdir -p $@

# Static pattern rules over the full matrix: an implicit .stamp/bread-% would
# also match bread-chisel-releases-* and win whenever a prerequisite stamp is
# not on disk yet.
FULL_BINARIES_STAMPS := $(addprefix .stamp/binaries-,$(ARCHES))
FULL_BREAD_STAMPS    := $(addprefix .stamp/bread-,$(FULL_VER_ARCH))
FULL_CHISEL_STAMPS   := $(addprefix .stamp/bread-chisel-releases-,$(FULL_VER_ARCH))
FULL_TEST_STAMPS     := $(addprefix .stamp/bread-test-26.04-,$(ARCHES))

# Cross-compile chisel + spread + docker cli for one arch in a Canonical
# ubuntu/go:1.25-26.04_edge builder container. Stamp content = hash of inputs
# (version pins + builder image + script + patches + arch).
BINARIES_ENV := CHISEL_REF="$(CHISEL_REF)" SPREAD_REF="$(SPREAD_REF)" GO_BUILDER_IMAGE="$(GO_BUILDER_IMAGE)" DOCKER_VERSION="$(DOCKER_VERSION)"

$(FULL_BINARIES_STAMPS): .stamp/binaries-%: FORCE | .stamp
	@set -e ; \
		new=$$($(BINARIES_ENV) hack/hash_inputs.rb binaries-$*) ; \
		cur=$$(cat $@ 2>/dev/null || true) ; \
		if [ "$$new" != "$$cur" ]; then \
			echo "==> building go binaries for $* (chisel + spread + docker)" ; \
			$(BINARIES_ENV) TARGET_ARCHES="$*" hack/build_binaries.sh ; \
			echo "$$new" > $@ ; \
		else \
			echo "==> go binaries for $* up-to-date (stamp matches)" ; \
		fi

$(FULL_BREAD_STAMPS): .stamp/bread-%: FORCE | .stamp
	@hack/build_image.sh bread-$*

# The arch is the last dash-separated field of a <ver>-<arch> stem.
arch_of = $(lastword $(subst -, ,$(1)))

.SECONDEXPANSION:
$(FULL_CHISEL_STAMPS): .stamp/bread-chisel-releases-%: .stamp/bread-% .stamp/binaries-$$(call arch_of,$$*) FORCE | .stamp
	@hack/build_image.sh bread-chisel-releases-$*

$(FULL_TEST_STAMPS): .stamp/bread-test-%: .stamp/bread-% .stamp/binaries-$$(call arch_of,$$*) FORCE | .stamp
	@hack/build_image.sh bread-test-$*

inlined/%.yaml: templates/%.yaml.in hack/inline_scripts.rb $(SCRIPTS)
	@mkdir -p inlined
	ruby hack/inline_scripts.rb $< $@

.PHONY: shell
shell: .stamp/bread-26.04-$(SELECTED_ARCH)  ## Drop into a bread:26.04 shell (host arch). Override via ARCH=...
	$(DOCKER) run --rm -it \
		--platform "linux/$(SELECTED_ARCH)" \
		bread:26.04-$(SELECTED_ARCH) bash

.PHONY: nuke-spread
nuke-spread:  ## Kill stray spread processes + force-remove bread containers
	-pkill spread
	-$(DOCKER) ps -aq --filter label=spread-bread | xargs -r $(DOCKER) rm --force
	-$(DOCKER) ps -aq --filter name='^bread-' | xargs -r $(DOCKER) rm --force

.PHONY: clean
clean:  ## Remove built images, stamps, generated inlined yamls, cached binaries
	-@$(foreach va,$(FULL_VER_ARCH), \
		$(DOCKER) rmi -f bread:$(va) bread-chisel-releases:$(va) 2>/dev/null ; )
	-@$(foreach a,$(NATIVE_ARCHES), \
		$(DOCKER) rmi -f bread-test:26.04-$(a) 2>/dev/null ; )
	rm -rf .stamp
	rm -rf cache
	rm -f $(INLINED)

.PHONY: clean-stamps
clean-stamps:  ## Remove only the .stamp/ dir (forces full rebuild on next run)
	rm -rf .stamp