build

#!/usr/bin/env bash
##
## This script is used to build ockam code.
##
## The most common use is to run it with no arguments, for example:
##	./build
##
## This will run the clean, lint, test, release commands in sequence
## and place the resulting binaries in the .build directory.
##
## On Linux and OSX you can run:
##	./build install
##
## This will copy the operating system specific built binary
## from .build/ to /usr/local/bin/ockam
##
## USAGE:
##
## ./build [COMMAND] [ARGS]
##
[[ "${TRACE}" ]] && set -x

# Set Bash Options.
#
# -e option will cause the script to exit immediately when a command fails.
#
# -o pipefail option sets the exit code of a pipeline to that of the rightmost command to exit with a
# non-zero status, or zero if all commands of the pipeline exit successfully.
set -eo pipefail

# The name of this package.
PKG_NAME=ockam

# The version of this package, scraped from ockam.go file.
PKG_VERSION="$(awk -F\" '/version :=/ { print $2; exit }' < ockam.go)"

# The build directory used for this project.
PKG_BUILDDIR=".build"

# Extract and print help
help() {
	if [[ "$#" = 0 ]]; then
		# Extract all lines in this file that start with a double ##,
		# Concatenate them and display as help.
		# Lines starting with a single # are not included.
		grep "^##" "${BASH_SOURCE[0]}" | sed "s/^##//" | sed "s/^##//"
	else
		# If an argument is passed, look for help just for that command
		# Must start with '##	command' and end in '####'
		echo -e "\\n"
		grep "^##" "${BASH_SOURCE[0]}" | sed -nE "/^##	${1}/,/^####/p" | sed "s/^##//" | sed "s/^##//"
	fi
}

# Build and run a tool image that is defined in the Dockerfile, as a stage, in the same directory as this script
# The image that is built is tagged as ockam/tool/TOOLNAME:latest
# The image is run with the current directory mounted at /project
run_tool() {
	local interactive
	if [ "$1" == "--interactive" ] || [ "$1" == "-i" ]; then
		interactive="-it"
		shift
	fi

	# The first argument to this function should be the name of the tool to run
	# All remaining arguments are teated as arguments to the image run.
	local toolname="$1"
	shift

	local imagename="ockam/tool/$toolname:latest"
	local projectdir="/project"
	local o buildkit

	# Docker Buildkit improves the proformance of docker image builds.
	# Docker Buildkit is enabled by default, set DOCKER_BUILDKIT=0 to disable
	buildkit='1'
	[ -n "$DOCKER_BUILDKIT" ] && buildkit="$DOCKER_BUILDKIT"

	if [[ "$TRACE" ]]; then
		DOCKER_BUILDKIT=$buildkit docker build --target "$toolname" --tag "$imagename" .
	else
		o=$(DOCKER_BUILDKIT=$buildkit docker build --quiet --target "$toolname" --tag "$imagename" . 2>&1) || echo "$o"
	fi

	case "$toolname" in
		go) envs="--env GOOS --env GOARCH";;
		*) envs="";;
	esac

	if [[ "$TRACE" ]] || ! [[ "$OCKAM_TOOL_QUIET" ]] || [[ "$interactive" ]]; then
		docker run $envs $interactive --rm --volume "$(pwd):$projectdir" "$imagename" "$@"
	else
		o=$(docker run $envs --rm --volume "$(pwd):$projectdir" "$imagename" "$@" 2>&1) || echo "$o"
	fi
}

# if vendor directory doesn't exist, vendor the dependencies based on go mod.
ensure_vendored() {
	if [ ! -d "vendor" ]; then
		run_tool go mod vendor
	fi
}

# Run linter tools
lint() {
	ensure_vendored
	OCKAM_TOOL_QUIET=1
	if [[ "$#" = 0 ]]; then
		# if no args, then run all linters
		run_tool eclint
		run_tool commitlint
		run_tool shellcheck
		# run_tool gometalinter
	else
		for var in "$@"; do
			run_tool "$var"
		done
	fi
	OCKAM_TOOL_QUIET=0
}

# If GOOS is not explicitly set try to guess it
guess_goos() {
	if [[ -z "$GOOS" ]]; then
		uname -s | tr '[:upper:]' '[:lower:]'
	else
		echo "$GOOS"
	fi
}

# If GOARCH is not explicitly set try to guess it
guess_goarch() {
	if [[ -z "$GOARCH" ]]; then
		#
		case $(uname -m) in
			amd64|x86_64) echo "amd64";;
			i386|i686) echo "386";;
			arm) echo "arm";;
			*) echo "GOARCH must be set"; exit 1;;
		esac
	else
		echo "$GOARCH"
	fi
}

# Compile "cmd/ockam/main.go" to the ockam binary
binary() {
	local os arch target

	# try to guess GOOS/GOARCH, this could fail.
	os=$(guess_goos)
	arch=$(guess_goarch)

	ensure_vendored

	target="$PKG_BUILDDIR/${PKG_NAME}_${PKG_VERSION}_${os}_${arch}"

	if [[ "$os" = "windows" ]]; then
		target+='.exe'
	fi

	echo -n "Building $target ... "

	# make the build directory exists
	mkdir -p "$PKG_BUILDDIR"

	# -mod=vendor uses the vendor directory.
	# -ldflags="-s -w" strips debug info.
	# -o "$target" outputs the binary at the target path
	GOOS=$os GOARCH=$arch run_tool go build -mod=vendor -ldflags="-s -w" -o "$target" cmd/ockam/*.go
	echo "Done."
}

# Run tests
test() {
	run_tool go test -v -mod=vendor -cover ./...
}

# build ockam binaries for multiple GOOS/GOARCH combination
release() {
	local platforms=(
		"linux/amd64"
		"linux/arm64"
		"darwin/amd64"
		"windows/amd64"
	)

	for platform in "${platforms[@]}"; do
		GOOS="${platform%/*}" GOARCH="${platform#*/}" binary
	done
}

# Try to guess the current GOOS/GOARCH and then copy .build/ockam_VERSION_GOOS_GOARCH to
# /usr/local/bin/ockam
install() {
	local os arch target
	os=$(guess_goos)
	arch=$(guess_goarch)
	target="$PKG_BUILDDIR/${PKG_NAME}_${PKG_VERSION}_${os}_${arch}"

	if [[ -d "/usr/local/bin" ]]; then
		cp "$target" "/usr/local/bin/${PKG_NAME}"
	else
		"Error: install command is only supported if /usr/local/bin directory exists."
		exit 1
	fi
}

# Remove the /usr/local/bin/ockam file, if present.
uninstall() {
	if [[ -d "/usr/local/bin" ]]; then
		rm -f "/usr/local/bin/${PKG_NAME}"
	else
		"Error: uninstall command is only supported if /usr/local/bin directory exists."
		exit 1
	fi
}

# Cleanup, delete the package build directory
clean() {
	rm -rf "$PKG_BUILDDIR"
}

if [[ "$#" == 0 ]]; then
	clean && lint && test && release && exit 0
fi

##
## Optionally, you may specify one of the below commands to run.
##
## COMMANDS:
##
case "$1" in
##	binary				Build the ockam binary for the current GOOS/GOARCH.
##
##					If GOOS or GOARCH is not set, this script will try to guess
##					using `uname`.
##
##					Examples:
##						./build binary
##						GOOS=windows GOARCH=amd64 ./build binary
##
####
binary) shift; binary;;
##	clean				Remove the project build directory.
##
##					Examples:
##						./build clean
##
####
clean) shift; clean;;
##
##	help [COMMAND]			Display help.
##
##					Displays all help by default.
##
##					Optionally, you may pass in a specific command to see help
##					about just that command.
##
##					Examples:
##						./build help
##						./build help lint
##
####
help) shift; help "$@";;
##	install				Copy ockam binary to /usr/local/bin/ockam, for OSX
##					or Linux environments.
##
##					Examples:
##						./build install
##
####
install) shift; install;;
##	lint [LINTERS]			Run linters.
##
##					Runs all linters by default:
##						eclint, commitlint, shellcheck & gometalinter
##
##					Optionally, you may pass in exactly which linters to run as
##					arguments.
##
##					Examples:
##						./build lint
##						./build lint shellcheck gometalinter
##
####
lint) shift; lint "$@";;
##	release				Build the ockam binaries for release.
##
##					Builds for the following GOOS/GOARCH platforms:
##						"linux/amd64"
##						"linux/arm64"
##						"darwin/amd64"
##						"windows/amd64"
##
##					Examples:
##						./build release
##
####
release) shift; release;;
##
##	run [OPTIONS] TOOL [ARGS]	Run a build tool.
##
##					Build and run a tool image that is defined in the multi-stage
##					Dockerfile as a stage
##
##					OPTIONS:
##					 -i | --interactive	Run the image in interactive mode
##
##					Examples:
##						./build run --interactive go
##						./build run -i go
##
##					The above example would build and run the image
##					'ockam/tool/go:latest' based on the Dockerfile
##					stage 'go' with '-it' options set for 'docker run'
##
####
run) shift; run_tool "$@";;
##	test				Run tests.
##
##					Examples:
##						./build test
##
####
test) shift; test;;
##	uninstall			Remove ockam binary from /usr/local/bin/ockam.
##
##					Examples:
##						./build uninstall
##
####
uninstall) shift; uninstall;;
# If the command is unknown, print help and exit with exit code 1
*) help; exit 1;;
esac
##
##
## TRACING:
##
## If the TRACE environment variable is truthy turn on tracing using the
## bash -x option. This is useful when debugging this script.
##
## TRACE=1 ./build
##