Makefile

# Copyright (c) 2017-2018 Intel 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.

# Determine the lower-case name of the distro
distro := $(shell \
for file in /etc/os-release /usr/lib/os-release; do \
    if [ -e $$file ]; then \
        grep ^ID= $$file|cut -d= -f2-|tr -d '"'; \
        break; \
    fi \
done)

GOARCH=$(shell go env GOARCH)
HOST_ARCH=$(shell arch)

ifeq ($(ARCH),)
	ARCH = $(GOARCH)
endif

ARCH_DIR = arch
ARCH_FILE_SUFFIX = -options.mk
ARCH_FILE = $(ARCH_DIR)/$(ARCH)$(ARCH_FILE_SUFFIX)
ARCH_FILES = $(wildcard arch/*$(ARCH_FILE_SUFFIX))
ALL_ARCHES = $(patsubst $(ARCH_DIR)/%$(ARCH_FILE_SUFFIX),%,$(ARCH_FILES))

# Load architecture-dependent settings
include $(ARCH_FILE)

#------------------------------
# project-specifics

# build type for Clear Containers
CC_TYPE = cc

CC_PROJECT_NAME = Intel® Clear Containers
CC_PROJECT_TAG = clear-containers
CC_PROJECT_URL = https://github.com/clearcontainers
CC_BUG_URL = $(CC_PROJECT_URL)/runtime/issues/new

# build type for Kata Containers
KATA_TYPE = kata

KATA_PROJECT_NAME = Kata Containers
KATA_PROJECT_TAG = kata-containers
KATA_PROJECT_URL = https://github.com/kata-containers
KATA_BUG_URL = $(KATA_PROJECT_URL)/kata-containers/issues/new

#------------------------------

# all supported project types
PROJECT_TYPES = $(CC_TYPE) $(KATA_TYPE)

# If this environment variable is set to any value,
# enable the Clear Containers system build.
ifneq (,$(CC_SYSTEM_BUILD))
    system_build_type = $(CC_TYPE)
endif

# If this environment variable is set to any value,
# enable the Kata Containers system build.
ifneq (,$(KATA_SYSTEM_BUILD))
    system_build_type = $(KATA_TYPE)
endif

ifneq ($(SYSTEM_BUILD_TYPE),)
    ifeq ($(SYSTEM_BUILD_TYPE),$(CC_TYPE))
        system_build_type = $(CC_TYPE)
    endif

    ifeq ($(SYSTEM_BUILD_TYPE),$(KATA_TYPE))
        system_build_type = $(KATA_TYPE)
    endif
endif

# A particular project system build is either triggered by
# specifying a special target or via an environment variable.
cc_system_build_requested := $(foreach f,\
    build-$(CC_TYPE)-system install-$(CC_TYPE)-system,\
    $(findstring $(f),$(MAKECMDGOALS)))
ifneq (,$(strip $(cc_system_build_requested)))
    cc_system_build = yes
else
    cc_system_build = no
endif

kata_system_build_requested := $(foreach f,\
    build-$(KATA_TYPE)-system install-$(KATA_TYPE)-system,\
    $(findstring $(f),$(MAKECMDGOALS)))
ifneq (,$(strip $(kata_system_build_requested)))
    kata_system_build = yes
else
    kata_system_build = no
endif

ifeq ($(cc_system_build),yes)
    system_build_type = $(CC_TYPE)
endif

ifeq ($(kata_system_build),yes)
    system_build_type = $(KATA_TYPE)
endif

# If this environment variable is set to a valid build type,
# use the value as the build type.

ifeq ($(system_build_type),)
    # Default built is for CC
    PROJECT_TYPE = $(CC_TYPE)

    PROJECT_NAME = $(CC_PROJECT_NAME)
    PROJECT_TAG = $(CC_PROJECT_TAG)
    PROJECT_URL = $(CC_PROJECT_URL)
    PROJECT_BUG_URL = $(CC_BUG_URL)
else
    ifeq ($(system_build_type),$(CC_TYPE))
        PROJECT_TYPE = $(CC_TYPE)

        PROJECT_NAME = $(CC_PROJECT_NAME)
        PROJECT_TAG = $(CC_PROJECT_TAG)
        PROJECT_URL = $(CC_PROJECT_URL)
        PROJECT_BUG_URL = $(CC_BUG_URL)
    endif

    ifeq ($(system_build_type),$(KATA_TYPE))
        PROJECT_TYPE = $(KATA_TYPE)

        PROJECT_NAME = $(KATA_PROJECT_NAME)
        PROJECT_TAG = $(KATA_PROJECT_TAG)
        PROJECT_URL = $(KATA_PROJECT_URL)
        PROJECT_BUG_URL = $(KATA_BUG_URL)
    endif
endif

BIN_PREFIX = $(PROJECT_TYPE)
PROJECT_DIR = $(PROJECT_TAG)
IMAGENAME = $(PROJECT_TAG).img

TARGET = $(BIN_PREFIX)-runtime
DESTDIR :=

installing = $(findstring install,$(MAKECMDGOALS))

ifneq ($(system_build_type),)
    # Configure the build for a standard system that is
    # using OBS-generated packages.
    PREFIX        := /usr
    BINDIR        := $(PREFIX)/bin
    DESTBINDIR    := /usr/local/bin
    QEMUBINDIR    := $(BINDIR)
    SYSCONFDIR    := /etc
    LOCALSTATEDIR := /var

    ifeq (,$(installing))
        # Force a rebuild to ensure version details are correct
        # (but only for a non-install build phase).
        EXTRA_DEPS = clean
    endif
else
    # standard build
    PREFIX        := /usr/local
    BINDIR        := $(PREFIX)/bin
    DESTBINDIR    := $(DESTDIR)/$(BINDIR)
    QEMUBINDIR    := $(BINDIR)
    SYSCONFDIR    := $(PREFIX)/etc
    LOCALSTATEDIR := $(PREFIX)/var
endif

LIBEXECDIR := $(PREFIX)/libexec
SHAREDIR := $(PREFIX)/share
DEFAULTSDIR := $(SHAREDIR)/defaults

PKGDATADIR := $(SHAREDIR)/$(PROJECT_DIR)
PKGRUNDIR := $(LOCALSTATEDIR)/run/$(PROJECT_DIR)
PKGLIBEXECDIR := $(LIBEXECDIR)/$(PROJECT_DIR)

KERNELPATH := $(PKGDATADIR)/vmlinuz.container
IMAGEPATH := $(PKGDATADIR)/$(IMAGENAME)
FIRMWAREPATH :=

QEMUPATH := $(QEMUBINDIR)/$(QEMUCMD)

SHIMCMD := $(BIN_PREFIX)-shim
SHIMPATH := $(PKGLIBEXECDIR)/$(SHIMCMD)

PROXYCMD := $(BIN_PREFIX)-proxy
PROXYPATH := $(PKGLIBEXECDIR)/$(PROXYCMD)

# Default number of vCPUs
DEFVCPUS := 1
# Default memory size in MiB
DEFMEMSZ := 2048
#Default number of bridges
DEFBRIDGES := 1
#Default network model
DEFNETWORKMODEL := macvtap

DEFDISABLEBLOCK := false
DEFBLOCKSTORAGEDRIVER := virtio-scsi
DEFENABLEMEMPREALLOC := false
DEFENABLEHUGEPAGES := false
DEFENABLESWAP := false
DEFENABLEDEBUG := false
DEFDISABLENESTINGCHECKS := false

SED = sed

SOURCES := $(shell find . 2>&1 | grep -E '.*\.(c|h|go)$$')
VERSION := ${shell cat ./VERSION}
COMMIT_NO := $(shell git rev-parse HEAD 2> /dev/null || true)
COMMIT := $(if $(shell git status --porcelain --untracked-files=no),${COMMIT_NO}-dirty,${COMMIT_NO})

CONFIG_FILE = configuration.toml
CONFIG = config/$(CONFIG_FILE)
CONFIG_IN = $(CONFIG).in

DESTTARGET := $(abspath $(DESTBINDIR)/$(TARGET))

DESTCONFDIR := $(DESTDIR)/$(DEFAULTSDIR)/$(PROJECT_DIR)
DESTSYSCONFDIR := $(DESTDIR)/$(SYSCONFDIR)/$(PROJECT_DIR)

# Main configuration file location for stateless systems
DESTCONFIG := $(abspath $(DESTCONFDIR)/$(CONFIG_FILE))

# Secondary configuration file location. Note that this takes precedence
# over DESTCONFIG.
DESTSYSCONFIG := $(abspath $(DESTSYSCONFDIR)/$(CONFIG_FILE))

DESTSHAREDIR := $(DESTDIR)/$(SHAREDIR)

BASH_COMPLETIONS_SRC := data/completions/bash/runtime.in
BASH_COMPLETIONS := data/completions/bash/$(TARGET)
BASH_COMPLETIONS_PROJ := $(BASH_COMPLETIONS).in

BASH_COMPLETIONSDIR := $(DESTSHAREDIR)/bash-completion/completions
GENERATED_FILES += $(BASH_COMPLETIONS)

COLLECT_SCRIPT_SRC = data/collect-data.sh.in
COLLECT_SCRIPT = data/$(PROJECT_TYPE)-collect-data.sh
COLLECT_SCRIPT_PROJ = $(COLLECT_SCRIPT).in

SCRIPTS += $(COLLECT_SCRIPT)
SCRIPTS_DIR := $(BINDIR)

GENERATED_FILES += $(COLLECT_SCRIPT)

# list of variables the user may wish to override
USER_VARS += ARCH
USER_VARS += BASH_COMPLETIONSDIR
USER_VARS += BINDIR
USER_VARS += CC_SYSTEM_BUILD
USER_VARS += DESTCONFIG
USER_VARS += DESTDIR
USER_VARS += DESTSYSCONFIG
USER_VARS += DESTTARGET
USER_VARS += IMAGENAME
USER_VARS += IMAGEPATH
USER_VARS += MACHINETYPE
USER_VARS += KATA_SYSTEM_BUILD
USER_VARS += KERNELPATH
USER_VARS += FIRMWAREPATH
USER_VARS += MACHINEACCELERATORS
USER_VARS += KERNELPARAMS
USER_VARS += LIBEXECDIR
USER_VARS += LOCALSTATEDIR
USER_VARS += PKGDATADIR
USER_VARS += PKGLIBEXECDIR
USER_VARS += PKGRUNDIR
USER_VARS += PREFIX
USER_VARS += PROJECT_NAME
USER_VARS += PROJECT_PREFIX
USER_VARS += PROJECT_TYPE
USER_VARS += PROXYPATH
USER_VARS += QEMUBINDIR
USER_VARS += QEMUCMD
USER_VARS += QEMUPATH
USER_VARS += SHAREDIR
USER_VARS += SHIMPATH
USER_VARS += SYSTEM_BUILD_TYPE
USER_VARS += SYSCONFDIR
USER_VARS += DEFVCPUS
USER_VARS += DEFMEMSZ
USER_VARS += DEFBRIDGES
USER_VARS += DEFNETWORKMODEL
USER_VARS += DEFDISABLEBLOCK
USER_VARS += DEFBLOCKSTORAGEDRIVER
USER_VARS += DEFENABLEMEMPREALLOC
USER_VARS += DEFENABLEHUGEPAGES
USER_VARS += DEFENABLESWAP
USER_VARS += DEFENABLEDEBUG
USER_VARS += DEFDISABLENESTINGCHECKS

V              = @
Q              = $(V:1=)
QUIET_BUILD    = $(Q:@=@echo    '     BUILD   '$@;)
QUIET_CHECK    = $(Q:@=@echo    '     CHECK   '$@;)
QUIET_CLEAN    = $(Q:@=@echo    '     CLEAN   '$@;)
QUIET_CONFIG   = $(Q:@=@echo    '     CONFIG  '$@;)
QUIET_GENERATE = $(Q:@=@echo    '     GENERATE '$@;)
QUIET_INST     = $(Q:@=@echo    '     INSTALL '$@;)
QUIET_TEST     = $(Q:@=@echo    '     TEST    '$@;)

# Return non-empty string if specified directory exists
define DIR_EXISTS
$(shell test -d $(1) && echo "$(1)")
endef

# $1: name of architecture to display
define SHOW_ARCH
  $(shell printf "\\t%s%s\\\n" "$(1)" $(if $(filter $(ARCH),$(1))," (default)",""))
endef

# Only install git hooks if working in a git clone
ifneq (,$(call DIR_EXISTS,.git))
	HANDLE_GIT_HOOKS = install-git-hooks
endif

# Don't install hooks when running under the CI as they will stop the
# tests from running.
#
# See: https://github.com/clearcontainers/runtime/issues/984
ifneq (,$(CI))
	HANDLE_GIT_HOOKS =
endif

default: $(TARGET) $(CONFIG) $(HANDLE_GIT_HOOKS)
.DEFAULT: default

build: default

build-cc-system: default
install-cc-system: install

build-kata-system: default
install-kata-system: install

define GENERATED_CODE
// WARNING: This file is auto-generated - DO NOT EDIT!
//
// Note that some variables are "var" to allow them to be modified
// by the tests.
package main

import (
	"fmt"
)

// name is the name of the runtime
const name = "$(TARGET)"

// name of the project
const project = "$(PROJECT_NAME)"

// prefix used to denote non-standard CLI commands and options.
const projectPrefix = "$(PROJECT_TYPE)"

// systemdUnitName is the systemd(1) target used to launch the agent.
const systemdUnitName = "$(PROJECT_TAG).target"

// original URL for this project
const projectURL = "$(CC_PROJECT_URL)"

// commit is the git commit the runtime is compiled from.
var commit = "$(COMMIT)"

// version is the runtime version.
var version = "$(VERSION)"

// project-specific command names
var envCmd = fmt.Sprintf("%s-env", projectPrefix)
var checkCmd = fmt.Sprintf("%s-check", projectPrefix)

// project-specific option names
var configFilePathOption = fmt.Sprintf("%s-config", projectPrefix)
var showConfigPathsOption = fmt.Sprintf("%s-show-default-config-paths", projectPrefix)

var defaultHypervisorPath = "$(QEMUPATH)"
var defaultImagePath = "$(IMAGEPATH)"
var defaultKernelPath = "$(KERNELPATH)"
var defaultFirmwarePath = "$(FIRMWAREPATH)"
var defaultMachineAccelerators = "$(MACHINEACCELERATORS)"
var defaultShimPath = "$(SHIMPATH)"

const defaultKernelParams = "$(KERNELPARAMS)"
const defaultMachineType = "$(MACHINETYPE)"
const defaultRootDirectory = "$(PKGRUNDIR)"

const defaultVCPUCount uint32 = $(DEFVCPUS)
const defaultMemSize uint32 = $(DEFMEMSZ) // MiB
const defaultBridgesCount uint32 = $(DEFBRIDGES)
const defaultInterNetworkingModel = "$(DEFNETWORKMODEL)"
const defaultDisableBlockDeviceUse bool = $(DEFDISABLEBLOCK)
const defaultBlockDeviceDriver = "$(DEFBLOCKSTORAGEDRIVER)"
const defaultEnableMemPrealloc bool = $(DEFENABLEMEMPREALLOC)
const defaultEnableHugePages bool = $(DEFENABLEHUGEPAGES)
const defaultEnableSwap bool = $(DEFENABLESWAP)
const defaultEnableDebug bool = $(DEFENABLEDEBUG)
const defaultDisableNestingChecks bool = $(DEFDISABLENESTINGCHECKS)

// Default config file used by stateless systems.
var defaultRuntimeConfiguration = "$(DESTCONFIG)"

// Alternate config file that takes precedence over
// defaultRuntimeConfiguration.
var defaultSysConfRuntimeConfiguration = "$(DESTSYSCONFIG)"

var defaultProxyPath = "$(PROXYPATH)"
endef

export GENERATED_CODE

#Install an executable file
# params:
# $1 : file to install
# $2 : directory path where file will be installed
define INSTALL_EXEC
	$(QUIET_INST)install -D $1 $(DESTDIR)$2/$(notdir $1);
endef

GENERATED_GO_FILES += config-generated.go

config-generated.go: Makefile VERSION
	$(QUIET_GENERATE)echo "$$GENERATED_CODE" >$@

$(TARGET): $(EXTRA_DEPS) $(SOURCES) $(GENERATED_GO_FILES) $(GENERATED_FILES) Makefile | show-summary
	$(QUIET_BUILD)go build -i -o $@ .

.PHONY: \
	check \
	check-go-static \
	check-go-test \
	coverage \
	default \
	install \
	install-git-hooks \
	show-header \
	show-summary \
	show-variables

$(TARGET).coverage: $(SOURCES) $(GENERATED_FILES) Makefile
	$(QUIET_TEST)go test -o $@ -covermode count

GENERATED_FILES += $(CONFIG)

$(COLLECT_SCRIPT_PROJ): $(COLLECT_SCRIPT_SRC)
	$(QUIET_GENERATE)cp $< $(@)

$(BASH_COMPLETIONS_PROJ): $(BASH_COMPLETIONS_SRC)
	$(QUIET_GENERATE)cp $< $(@)

$(GENERATED_FILES): %: %.in Makefile VERSION
	$(QUIET_CONFIG)$(SED) \
		-e "s|@COMMIT@|$(COMMIT)|g" \
		-e "s|@VERSION@|$(VERSION)|g" \
		-e "s|@CONFIG_IN@|$(CONFIG_IN)|g" \
		-e "s|@DESTCONFIG@|$(DESTCONFIG)|g" \
		-e "s|@DESTSYSCONFIG@|$(DESTSYSCONFIG)|g" \
		-e "s|@IMAGEPATH@|$(IMAGEPATH)|g" \
		-e "s|@KERNELPATH@|$(KERNELPATH)|g" \
		-e "s|@FIRMWAREPATH@|$(FIRMWAREPATH)|g" \
		-e "s|@MACHINEACCELERATORS@|$(MACHINEACCELERATORS)|g" \
		-e "s|@KERNELPARAMS@|$(KERNELPARAMS)|g" \
		-e "s|@LOCALSTATEDIR@|$(LOCALSTATEDIR)|g" \
		-e "s|@PKGLIBEXECDIR@|$(PKGLIBEXECDIR)|g" \
		-e "s|@PROXYPATH@|$(PROXYPATH)|g" \
		-e "s|@PROJECT_BUG_URL@|$(PROJECT_BUG_URL)|g" \
		-e "s|@PROJECT_URL@|$(PROJECT_URL)|g" \
		-e "s|@PROJECT_NAME@|$(PROJECT_NAME)|g" \
		-e "s|@PROJECT_TAG@|$(PROJECT_TAG)|g" \
		-e "s|@PROJECT_TYPE@|$(PROJECT_TYPE)|g" \
		-e "s|@PROJECT_TYPES@|$(PROJECT_TYPES)|g" \
		-e "s|@QEMUPATH@|$(QEMUPATH)|g" \
		-e "s|@RUNTIME_NAME@|$(TARGET)|g" \
		-e "s|@MACHINETYPE@|$(MACHINETYPE)|g" \
		-e "s|@SHIMPATH@|$(SHIMPATH)|g" \
		-e "s|@DEFVCPUS@|$(DEFVCPUS)|g" \
		-e "s|@DEFMEMSZ@|$(DEFMEMSZ)|g" \
		-e "s|@DEFBRIDGES@|$(DEFBRIDGES)|g" \
		-e "s|@DEFNETWORKMODEL@|$(DEFNETWORKMODEL)|g" \
		-e "s|@DEFDISABLEBLOCK@|$(DEFDISABLEBLOCK)|g" \
		-e "s|@DEFBLOCKSTORAGEDRIVER@|$(DEFBLOCKSTORAGEDRIVER)|g" \
		-e "s|@DEFENABLEMEMPREALLOC@|$(DEFENABLEMEMPREALLOC)|g" \
		-e "s|@DEFENABLEHUGEPAGES@|$(DEFENABLEHUGEPAGES)|g" \
		-e "s|@DEFENABLEMSWAP@|$(DEFENABLESWAP)|g" \
		-e "s|@DEFENABLEDEBUG@|$(DEFENABLEDEBUG)|g" \
		-e "s|@DEFDISABLENESTINGCHECKS@|$(DEFDISABLENESTINGCHECKS)|g" \
		$< > $@

generate-config: $(CONFIG)

check: check-go-static check-go-test

check-go-test: $(GENERATED_FILES)
	$(QUIET_TEST).ci/go-test.sh

check-go-static:
	$(QUIET_CHECK).ci/go-static-checks.sh $(GO_STATIC_CHECKS_ARGS)
	$(QUIET_CHECK).ci/go-no-os-exit.sh

coverage:
	$(QUIET_TEST).ci/go-test.sh html-coverage

install: default install-completions install-scripts
	$(QUIET_INST)install -D $(TARGET) $(DESTTARGET)
	$(QUIET_INST)install -D $(CONFIG) $(DESTCONFIG)

install-completions:
	$(QUIET_INST) test -e $(BASH_COMPLETIONS) \
		&& install --mode 0644 -D $(BASH_COMPLETIONS) $(BASH_COMPLETIONSDIR) || true

install-scripts:
	$(foreach f,$(SCRIPTS),$(call INSTALL_EXEC,$f,$(SCRIPTS_DIR)))

clean:
	$(QUIET_CLEAN)rm -f $(TARGET) $(CONFIG) $(GENERATED_GO_FILES) $(GENERATED_FILES) $(COLLECT_SCRIPT_PROJ) $(BASH_COMPLETIONS_PROJ)

show-usage: show-header
	@printf "• Overview:\n"
	@printf "\n"
	@printf "\tTo build $(TARGET), just run, \"make\".\n"
	@printf "\n"
	@printf "\tFor a verbose build, run \"make V=1\".\n"
	@printf "\n"
	@printf "• Additional targets:\n"
	@printf "\n"
	@printf "\tbuild               : standard build [1].\n"
	@printf "\tdefault             : same as 'build'.\n"
	@printf "\tbuild-$(CC_TYPE)-system     : build using standard $(CC_PROJECT_NAME) system paths.\n"
	@printf "\tbuild-$(KATA_TYPE)-system   : build using standard $(KATA_PROJECT_NAME) system paths.\n"
	@printf "\tcheck               : run tests.\n"
	@printf "\tclean               : remove built files.\n"
	@printf "\tcoverage            : run coverage tests.\n"
	@printf "\tdefault             : same as just \"make\".\n"
	@printf "\tgenerate-config     : create configuration file.\n"
	@printf "\tinstall             : install files [2].\n"
	@printf "\tinstall-$(CC_TYPE)-system   : install using standard $(CC_PROJECT_NAME) system paths.\n"
	@printf "\tinstall-$(KATA_TYPE)-system : install using standard $(KATA_PROJECT_NAME) system paths.\n"
	@printf "\tshow-arches         : show supported architectures (ARCH variable values).\n"
	@printf "\tshow-summary        : show install locations.\n"
	@printf "\n"
	@printf "  Notes:\n"
	@printf "\n"
	@printf "  [1] - Equivalent to:\n"
	@printf "        - 'build-cc-system' if CC_SYSTEM_BUILD is set.\n"
	@printf "        - 'build-kata-system' if KATA_SYSTEM_BUILD is set.\n"
	@printf "        - 'build' for the project specified by SYSTEM_BUILD_TYPE.\n"
	@printf "\n"
	@printf "  [2] - Equivalent to:\n"
	@printf "        - 'install-cc-system' if CC_SYSTEM_BUILD is set.\n"
	@printf "        - 'install-kata-system' if KATA_SYSTEM_BUILD is set.\n"
	@printf "        - 'install' for the project specified by SYSTEM_BUILD_TYPE.\n"
	@printf "\n"

handle_help: show-usage show-summary show-variables show-footer

usage: handle_help
help: handle_help

show-variables:
	@printf "• Variables affecting the build:\n\n"
	@printf \
          "$(foreach v,$(sort $(USER_VARS)),$(shell printf "\\t$(v)='$($(v))'\\\n"))"
	@printf "\n"

show-header:
	@printf "%s - version %s (commit %s)\n\n" $(TARGET) $(VERSION) $(COMMIT)

show-arches: show-header
	@printf "Supported architectures (possible values for ARCH variable):\n\n"
	@printf \
		"$(foreach v,$(ALL_ARCHES),$(call SHOW_ARCH,$(v)))\n"

show-footer:
	@printf "• Project:\n"
	@printf "\tHome: $(PROJECT_URL)\n"
	@printf "\tBugs: $(PROJECT_BUG_URL)\n\n"

show-summary: show-header
	@printf "• architecture:\n"
	@printf "\tHost: $(HOST_ARCH)\n"
	@printf "\tgolang: $(GOARCH)\n"
	@printf "\tBuild: $(ARCH)\n"
	@printf "\n"
	@printf "• golang:\n"
	@printf "\t"
	@go version
	@printf "\n"
	@printf "• Summary:\n"
	@printf "\n"
	@printf "\tProject system build type             : $(system_build_type)\n"
	@printf "\n"
	@printf "\tbinary install path (DESTTARGET)      : %s\n" $(DESTTARGET)
	@printf "\tconfig install path (DESTCONFIG)      : %s\n" $(DESTCONFIG)
	@printf "\talternate config path (DESTSYSCONFIG) : %s\n" $(DESTSYSCONFIG)
	@printf "\thypervisor path (QEMUPATH)            : %s\n" $(QEMUPATH)
	@printf "\tassets path (PKGDATADIR)              : %s\n" $(PKGDATADIR)
	@printf "\tproxy+shim path (PKGLIBEXECDIR)       : %s\n" $(PKGLIBEXECDIR)
	@printf "\n"


# The following git hooks handle HEAD changes:
# post-checkout <prev_head> <new_head> <file_or_branch_checkout>
# post-commit # no parameters
# post-merge <squash_or_not>
# post-rewrite <amend_or_rebase>
#
define GIT_HOOK_POST_CHECKOUT
#!/usr/bin/env bash
prev_head=$$1
new_head=$$2
[[ "$$prev_head" == "$$new_head" ]] && exit
printf "\nexecuting post-checkout git hook\n\n"
rm -f config-generated.go
endef
export GIT_HOOK_POST_CHECKOUT

define GIT_HOOK_POST_GENERIC
#!/usr/bin/env bash
printf "\n executing $$0 git hook\n\n"
rm -f config-generated.go
endef
export GIT_HOOK_POST_GENERIC

# This git-hook is executed after every checkout git operation
.git/hooks/post-checkout: Makefile
	@ mkdir -p .git/hooks/
	$(QUIET_INST)echo "$$GIT_HOOK_POST_CHECKOUT" >$@
	@ chmod +x $@

# This git-hook is executed after every commit, merge, amend or rebase git
# operation
.git/hooks/post-commit .git/hooks/post-merge .git/hooks/post-rewrite: Makefile
	@ mkdir -p .git/hooks/
	$(QUIET_INST)echo "$$GIT_HOOK_POST_GENERIC" >$@
	@ chmod +x $@

install-git-hooks: .git/hooks/post-checkout .git/hooks/post-commit \
    .git/hooks/post-merge .git/hooks/post-rewrite