build/functions.sh - trafficcontrol - Git at Google

 #!/usr/bin/env sh
 # 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.
 #
 # shellcheck shell=ash

 if ! type -p realpath; then
 	# by default, macOS does not have realpath
 	realpath() {
 		ls "$(
 			cd "$(dirname "$0")"
 			pwd -P # -P resolves symlinks
 		)/$(basename "$0")"
 	}
 	export -f realpath
 fi;

 if { ! stat -c%u . >/dev/null && stat -f%u .; } >/dev/null 2>&1; then
 	#BSD stat uses -f as its formatting flag instead of -c
 	stat() {
 		local format=''
 		while getopts c: option; do
 			case "$option" in
 				c) format="$OPTARG";;
 				*) return 1
 			esac
 		done
 		shift $(( OPTIND - 1 ))
 		unset OPTIND
 		$(which stat) "-f${format}" "$@"
 	}
 	export -f stat
 fi

 removeFirstArg() {
 	shift
 	echo "$@"
 }

 # ---------------------------------------
 # versionOk checks version number against required version.
 #   ``versionOk 1.2.3 2.0.4.7'' returns false value indicating
 #       version you have is not at least version you need
 #   if versionOk $haveversion $needversion; then
 #      echo "Need at least version $needversion"; return 1
 #   fi
 versionOk() {
 	local h="$1" n="$2"
 	# string compare -- no need to do more if the same
 	[ "$h" = "$n" ] && return 0

 	# split into fields
 	local have="${h//\./ }"
 	local need="${n//\./ }"
 	# cmp first entry of each array.  Bail when unequal.
 	while [ -n "$have" ] && [ "$have" = "$need" ]; do
 		# pop 1st entry from each
 		have="$(removeFirstArg ${have})"
 		need="$(removeFirstArg ${need})"
 	done
 	have="${have%% *}";
 	need="${need%% *}";
 	if [ "${have:-0}" -lt "${need:-0}" ]; then
 		return 1
 	fi
 	return 0
 }

 # ---------------------------------------
 getRevCount() {
 	local buildNum
 	buildNum=$(getBuildNumber)
 	echo "${buildNum%.*}"
 }

 # ---------------------------------------
 isInGitTree() {
 	# ignore output -- use exit status
 	git rev-parse --is-inside-work-tree >/dev/null 2>&1
 }

 # ---------------------------------------
 getBuildNumber() {
 	local in_git=''
 	if isInGitTree; then
 		local commits sha
 		commits="$(git rev-list HEAD 2>/dev/null | wc -l | awk '{print $1}')" # awk is for BSD compatibility
 		sha="$(git rev-parse --short=8 HEAD)"
 		echo "$commits.$sha"
 	else
 		# Expect it's from the released tarball -- if BUILD_NUMBER file is not present,  abort
 		if [ ! -f "${TC_DIR}/BUILD_NUMBER" ]; then
 			echo "Not in git repository and no BUILD_NUMBER present -- aborting!"
 			return 1
 		fi
 		grep -v '^#' "${TC_DIR}/BUILD_NUMBER"
 	fi
 }

 # ---------------------------------------
 getGoVersion() {
 	local directory="$1"
 	local go_version_file="$directory/GO_VERSION"
 	[ -r "$go_version_file" ] || { echo "Could not read $go_version_file: $!"; return 1; }
 	cat "$go_version_file"
 }

 # ---------------------------------------
 getVersion() {
 	local d="$1"
 	local vf="$d/VERSION"
 	[ -r "$vf" ] || { echo "Could not read $vf: $!"; return 1; }
 	cat "$vf"
 }

 # ---------------------------------------
 getRhelVersion() {
 	local releasever=${RHEL_VERSION:-}
 	if [ -n "$releasever" ]; then
 		echo "el${releasever}"
 		return
 	fi

 	local redhat_release=/etc/redhat-release
 	local default_version=7
 	if [ -e $redhat_release ]; then
 		releasever="$(rpm -q --qf '%{version}' -f $redhat_release)"
 		releasever="${releasever%%.*}"
 	else
 		echo "${redhat_release} not found, defaulting to major release ${default_version}" >/dev/stderr
 		releasever=${default_version}
 	fi;

 	echo "el${releasever}"
 }

 # ---------------------------------------
 getCommit() {
 	local buildNum
 	buildNum="$(getBuildNumber)"
 	echo "${buildNum%.*}"
 }

 # ---------------------------------------
 checkEnvironment() {
 	include_programs='' exclude_programs=''
 	while getopts i:e: option; do
 		case "$option" in
 			i) include_programs="$OPTARG";;
 			e) exclude_programs="$OPTARG";;
 			*) return 1
 		esac
 	done
 	unset OPTIND
 	include_file="$(mktemp)"
 	exclude_file="$(mktemp)"
 	printf '%s\n' git rpmbuild  ${include_programs//,/ } | sort >"$include_file"
 	printf '%s\n' ${exclude_programs//,/ } | sort >"$exclude_file"
 	programs="$(comm -23 "$include_file" "$exclude_file")"
 	rm "$include_file" "$exclude_file"

 	# verify required tools available in path -- extra tools required by subsystem are passed in
 	for program in $programs; do
 		if ! type "$program"; then
 			echo "$program not found in PATH"
 			return 1
 		fi
 	done
 	# verify git version
 	requiredGitVersion=1.7.12
 	if ! versionOk "$(git --version | tr -dc 0-9. )" "$requiredGitVersion"; then
 		echo "$(git --version) must be at least $requiredGitVersion"
 		return 1
 	fi

 	TC_VERSION='' BUILD_NUMBER='' RPMBUILD='' DIST=''
 	TC_VERSION="$(getVersion "$TC_DIR")"
 	BUILD_NUMBER="$(getBuildNumber)"
 	GO_VERSION="$(getGoVersion "$TC_DIR")"
 	RHEL_VERSION="$(getRhelVersion)"
 	WORKSPACE="${WORKSPACE:-$TC_DIR}"
 	RPMBUILD="$WORKSPACE/rpmbuild"
 	GOOS="${GOOS:-linux}"
 	RPM_TARGET_OS="${RPM_TARGET_OS:-$GOOS}"
 	DIST="$WORKSPACE/dist"
 	export TC_VERSION BUILD_NUMBER GO_VERSION RHEL_VERSION WORKSPACE RPMBUILD GOOS RPM_TARGET_OS DIST

 	mkdir -p "$DIST" || { echo "Could not create ${DIST}: ${?}"; return 1; }

 	echo "Build environment has been verified."

 	echo "=================================================="
 	echo "WORKSPACE: $WORKSPACE"
 	echo "BUILD_NUMBER: $BUILD_NUMBER"
 	echo "RHEL_VERSION: $RHEL_VERSION"
 	echo "TC_VERSION: $TC_VERSION"
 	echo "--------------------------------------------------"
 }

 # ---------------------------------------
 createSourceDir() {
 	local target="${1}-${TC_VERSION}"
 	local srcpath="$RPMBUILD/SOURCES/$target"
 	mkdir -p "$srcpath" || { echo "Could not create $srcpath: $?"; return 1; }
 	echo "$srcpath"
 }

 # ---------------------------------------
 buildRpm() {
 	for package in "$@"; do
 		local pre="${package}-${TC_VERSION}-${BUILD_NUMBER}.${RHEL_VERSION}"
 		local rpm
 		rpm="${pre}.$(uname -m).rpm"
 		local srpm="${pre}.src.rpm"
 		echo "Building the rpm."
 		{ set +o nounset
 		set -- # Clear arguments for reuse
 		if [ "$DEBUG_BUILD" = true ]; then
 			echo 'RPM will not strip binaries before packaging.';
 			set -- "$@" --define '%__os_install_post %{nil}' # Do not strip binaries before packaging
 		fi;
 		set -- "$@" --define '%_source_payload w2.xzdio' # xz level 2 compression for text files
 		set -- "$@" --define '%_binary_payload w2.xzdio' # xz level 2 compression for binary files
 		set -o nounset; }

 		build_flags="-ba";
 		if [[ "$NO_SOURCE" -eq 1 ]]; then
 			build_flags="-bb";
 		fi

 		pushd "$RPMBUILD";

 		rpmbuild --define "_topdir $(pwd)" \
 			--define "traffic_control_version $TC_VERSION" \
 			--define "go_version $GO_VERSION" \
 			--define "commit $(getCommit)" \
 			--define "build_number $BUILD_NUMBER.$RHEL_VERSION" \
 			--define "_target_os $RPM_TARGET_OS" \
 			"$build_flags" SPECS/$package.spec \
 			"$@";
 		code=$?
 		if [[ "$code" -ne 0 ]]; then
 			echo "RPM BUILD FAILED: $code" >&2;
 			return $code;
 		fi

 		echo
 		echo "========================================================================================"
 		echo "RPM BUILD FOR $package SUCCEEDED, See $DIST/$rpm for the newly built rpm."
 		echo "========================================================================================"
 		echo

 		rpmDest=".";
 		srcRPMDest=".";
 		if [[ "$SIMPLE" -eq 1 ]]; then
 			rpmDest="${package}.rpm";
 			srcRPMDest="${package}.src.rpm";
 		fi

 		cp -f "$RPMBUILD/RPMS/$(uname -m)/$rpm" "$DIST/$rpmDest";
 		code="$?";
 		if [[ "$code" -ne 0 ]]; then
 			echo "Could not copy $rpm to $DIST: $code" >&2;
 			return "$code";
 		fi

 		if [[ "$NO_SOURCE" -eq 1 ]]; then
 			return 0;
 		fi

 		cp -f "$RPMBUILD/SRPMS/$srpm" "$DIST/$srcRPMDest";
 		code="$?";
 		if [[ "$code" -ne 0 ]]; then
 			echo "Could not copy $srpm to $DIST: $code" >&2;
 			return "$code";
 		fi
 	done
 }

 # ---------------------------------------
 createTarball() {
 	local projDir
 	projDir="$(cd "$1"; pwd)"
 	local projName=trafficcontrol
 	local version
 	version="$(getVersion "$TC_DIR")"
 	local tarball="dist/apache-${projName}-${version}.tar.gz"
 	local tarDir
 	tarDir="$(basename "$tarball" .tar.gz)"
 	local tarLink
 	( trap 'rm -f "${projDir}/BUILD_NUMBER" "$projLink"' EXIT
 	projLink="$(dirname "$projDir")/${tarDir}"
 	ln -sf "$projDir" "$projLink"

 	# Create a BUILDNUMBER file and add to tarball
 	getBuildNumber >"${projDir}/BUILD_NUMBER"

 	# create the tarball from BUILD_NUMBER and files tracked in git
 	git ls-files |
 		sed "s|^|${tarDir}/|g" |
 		tar -czf "$tarball" -C "${projLink}/.." -T - "${tarDir}/BUILD_NUMBER"
 		# ^ read files from stdin to avoid tar argument limit
 	)
 	echo "$tarball"
 }

 # ---------------------------------------
 createDocsTarball() {
 	local projDir
 	projDir="$(cd "$1"; pwd)"
 	local projName=trafficcontrol
 	local version
 	version="$(getVersion "$TC_DIR")"
 	local tarball="dist/apache-$projName-$version-docs.tar.gz"
 	local tarDir="${projDir}/docs/build/"

 	# Create a BUILDNUMBER file and add to tarball
 	getBuildNumber >"${tarDir}/BUILD_NUMBER"

 	# create the tarball only from files in repo and BUILD_NUMBER
 	tar -czf "$tarball" -C "$tarDir" .
 	rm "${tarDir}/BUILD_NUMBER"
 	echo "$tarball"
 }

 # ----------------------------------------
 # verify whether the minor-level version of the go compiler is greater or equal
 # to the minor-level version in the GO_VERSION file: returns 0 if if not.
 # returns 1 if it is.
 #
 verify_and_set_go_version() {
 	if [ -v GO_VERSION ]; then
 		GO_VERSION="$(getGoVersion .)"
 	else
 		GO_VERSION=''
 	fi
 	local major_version="$(echo "$GO_VERSION" | awk -F. '{print $1}')"
 	local minor_version="$(echo "$GO_VERSION" | awk -F. '{print $2}')"
 	GO_VERSION="none"
 	GO="none"
 	go_in_path="$(type -p go)"
 	local group_1='' group_2=''
 	for g in "$go_in_path" /usr/bin/go /usr/local/go/bin/go; do
 		if [ -z "$g" ] || [ ! -x "$g" ]; then
 			continue
 		fi

 		go_version="$($g version | awk '{print $3}')"

 		version_pattern='.*go([1-9]+)\.([1-9]+).*'
 		if echo "$go_version" | grep -E "$version_pattern"; then
 			group_1="$(echo "$go_version" | sed -E "s/${version_pattern}/\1/")"
 			group_2="$(echo "$go_version" | sed -E "s/${version_pattern}/\2/")"
 			if [ ! "$group_1" -ge "$major_version" ] || [ ! "$group_2" -ge "$minor_version" ]; then
 				GO_VERSION="${group_1}.${group_2}"; export GO_VERSION
 				echo "go version for $g is ${group_1}.${group_2}"
 				continue
 			fi
 			GO_VERSION="${group_1}.${group_2}"; export GO_VERSION
 			GO=$g; export GO
 			PATH="$(dirname "$g"):${PATH}"; export PATH
 			echo "go version for $g is ${group_1}.${group_2}"
 			echo "will use $g"
 			return 0
 		fi
 	done

 	if [ "$GO" = none ]; then
 		echo "ERROR: this build needs go ${major_version}.${minor_version} or greater and no usable go compiler was found, found GO_VERSION: $GO_VERSION"
 		unset GO_VERSION
 		return 1
 	fi
 }
	#!/usr/bin/env sh
	# 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.
	#
	# shellcheck shell=ash

	if ! type -p realpath; then
	# by default, macOS does not have realpath
	realpath() {
	ls "$(
	cd "$(dirname "$0")"
	pwd -P # -P resolves symlinks
	)/$(basename "$0")"
	}
	export -f realpath
	fi;

	if { ! stat -c%u . >/dev/null && stat -f%u .; } >/dev/null 2>&1; then
	#BSD stat uses -f as its formatting flag instead of -c
	stat() {
	local format=''
	while getopts c: option; do
	case "$option" in
	c) format="$OPTARG";;
	*) return 1
	esac
	done
	shift $(( OPTIND - 1 ))
	unset OPTIND
	$(which stat) "-f${format}" "$@"
	}
	export -f stat
	fi

	removeFirstArg() {
	shift
	echo "$@"
	}

	# ---------------------------------------
	# versionOk checks version number against required version.
	# ``versionOk 1.2.3 2.0.4.7'' returns false value indicating
	# version you have is not at least version you need
	# if versionOk $haveversion $needversion; then
	# echo "Need at least version $needversion"; return 1
	# fi
	versionOk() {
	local h="$1" n="$2"
	# string compare -- no need to do more if the same
	[ "$h" = "$n" ] && return 0

	# split into fields
	local have="${h//\./ }"
	local need="${n//\./ }"
	# cmp first entry of each array. Bail when unequal.
	while [ -n "$have" ] && [ "$have" = "$need" ]; do
	# pop 1st entry from each
	have="$(removeFirstArg ${have})"
	need="$(removeFirstArg ${need})"
	done
	have="${have%% *}";
	need="${need%% *}";
	if [ "${have:-0}" -lt "${need:-0}" ]; then
	return 1
	fi
	return 0
	}

	# ---------------------------------------
	getRevCount() {
	local buildNum
	buildNum=$(getBuildNumber)
	echo "${buildNum%.*}"
	}

	# ---------------------------------------
	isInGitTree() {
	# ignore output -- use exit status
	git rev-parse --is-inside-work-tree >/dev/null 2>&1
	}

	# ---------------------------------------
	getBuildNumber() {
	local in_git=''
	if isInGitTree; then
	local commits sha
	commits="$(git rev-list HEAD 2>/dev/null \| wc -l \| awk '{print $1}')" # awk is for BSD compatibility
	sha="$(git rev-parse --short=8 HEAD)"
	echo "$commits.$sha"
	else
	# Expect it's from the released tarball -- if BUILD_NUMBER file is not present, abort
	if [ ! -f "${TC_DIR}/BUILD_NUMBER" ]; then
	echo "Not in git repository and no BUILD_NUMBER present -- aborting!"
	return 1
	fi
	grep -v '^#' "${TC_DIR}/BUILD_NUMBER"
	fi
	}

	# ---------------------------------------
	getGoVersion() {
	local directory="$1"
	local go_version_file="$directory/GO_VERSION"
	[ -r "$go_version_file" ] \|\| { echo "Could not read $go_version_file: $!"; return 1; }
	cat "$go_version_file"
	}

	# ---------------------------------------
	getVersion() {
	local d="$1"
	local vf="$d/VERSION"
	[ -r "$vf" ] \|\| { echo "Could not read $vf: $!"; return 1; }
	cat "$vf"
	}

	# ---------------------------------------
	getRhelVersion() {
	local releasever=${RHEL_VERSION:-}
	if [ -n "$releasever" ]; then
	echo "el${releasever}"
	return
	fi

	local redhat_release=/etc/redhat-release
	local default_version=7
	if [ -e $redhat_release ]; then
	releasever="$(rpm -q --qf '%{version}' -f $redhat_release)"
	releasever="${releasever%%.*}"
	else
	echo "${redhat_release} not found, defaulting to major release ${default_version}" >/dev/stderr
	releasever=${default_version}
	fi;

	echo "el${releasever}"
	}

	# ---------------------------------------
	getCommit() {
	local buildNum
	buildNum="$(getBuildNumber)"
	echo "${buildNum%.*}"
	}

	# ---------------------------------------
	checkEnvironment() {
	include_programs='' exclude_programs=''
	while getopts i:e: option; do
	case "$option" in
	i) include_programs="$OPTARG";;
	e) exclude_programs="$OPTARG";;
	*) return 1
	esac
	done
	unset OPTIND
	include_file="$(mktemp)"
	exclude_file="$(mktemp)"
	printf '%s\n' git rpmbuild ${include_programs//,/ } \| sort >"$include_file"
	printf '%s\n' ${exclude_programs//,/ } \| sort >"$exclude_file"
	programs="$(comm -23 "$include_file" "$exclude_file")"
	rm "$include_file" "$exclude_file"

	# verify required tools available in path -- extra tools required by subsystem are passed in
	for program in $programs; do
	if ! type "$program"; then
	echo "$program not found in PATH"
	return 1
	fi
	done
	# verify git version
	requiredGitVersion=1.7.12
	if ! versionOk "$(git --version \| tr -dc 0-9. )" "$requiredGitVersion"; then
	echo "$(git --version) must be at least $requiredGitVersion"
	return 1
	fi

	TC_VERSION='' BUILD_NUMBER='' RPMBUILD='' DIST=''
	TC_VERSION="$(getVersion "$TC_DIR")"
	BUILD_NUMBER="$(getBuildNumber)"
	GO_VERSION="$(getGoVersion "$TC_DIR")"
	RHEL_VERSION="$(getRhelVersion)"
	WORKSPACE="${WORKSPACE:-$TC_DIR}"
	RPMBUILD="$WORKSPACE/rpmbuild"
	GOOS="${GOOS:-linux}"
	RPM_TARGET_OS="${RPM_TARGET_OS:-$GOOS}"
	DIST="$WORKSPACE/dist"
	export TC_VERSION BUILD_NUMBER GO_VERSION RHEL_VERSION WORKSPACE RPMBUILD GOOS RPM_TARGET_OS DIST

	mkdir -p "$DIST" \|\| { echo "Could not create ${DIST}: ${?}"; return 1; }

	echo "Build environment has been verified."

	echo "=================================================="
	echo "WORKSPACE: $WORKSPACE"
	echo "BUILD_NUMBER: $BUILD_NUMBER"
	echo "RHEL_VERSION: $RHEL_VERSION"
	echo "TC_VERSION: $TC_VERSION"
	echo "--------------------------------------------------"
	}

	# ---------------------------------------
	createSourceDir() {
	local target="${1}-${TC_VERSION}"
	local srcpath="$RPMBUILD/SOURCES/$target"
	mkdir -p "$srcpath" \|\| { echo "Could not create $srcpath: $?"; return 1; }
	echo "$srcpath"
	}

	# ---------------------------------------
	buildRpm() {
	for package in "$@"; do
	local pre="${package}-${TC_VERSION}-${BUILD_NUMBER}.${RHEL_VERSION}"
	local rpm
	rpm="${pre}.$(uname -m).rpm"
	local srpm="${pre}.src.rpm"
	echo "Building the rpm."
	{ set +o nounset
	set -- # Clear arguments for reuse
	if [ "$DEBUG_BUILD" = true ]; then
	echo 'RPM will not strip binaries before packaging.';
	set -- "$@" --define '%__os_install_post %{nil}' # Do not strip binaries before packaging
	fi;
	set -- "$@" --define '%_source_payload w2.xzdio' # xz level 2 compression for text files
	set -- "$@" --define '%_binary_payload w2.xzdio' # xz level 2 compression for binary files
	set -o nounset; }

	build_flags="-ba";
	if [[ "$NO_SOURCE" -eq 1 ]]; then
	build_flags="-bb";
	fi

	pushd "$RPMBUILD";

	rpmbuild --define "_topdir $(pwd)" \
	--define "traffic_control_version $TC_VERSION" \
	--define "go_version $GO_VERSION" \
	--define "commit $(getCommit)" \
	--define "build_number $BUILD_NUMBER.$RHEL_VERSION" \
	--define "_target_os $RPM_TARGET_OS" \
	"$build_flags" SPECS/$package.spec \
	"$@";
	code=$?
	if [[ "$code" -ne 0 ]]; then
	echo "RPM BUILD FAILED: $code" >&2;
	return $code;
	fi

	echo
	echo "========================================================================================"
	echo "RPM BUILD FOR $package SUCCEEDED, See $DIST/$rpm for the newly built rpm."
	echo "========================================================================================"
	echo

	rpmDest=".";
	srcRPMDest=".";
	if [[ "$SIMPLE" -eq 1 ]]; then
	rpmDest="${package}.rpm";
	srcRPMDest="${package}.src.rpm";
	fi

	cp -f "$RPMBUILD/RPMS/$(uname -m)/$rpm" "$DIST/$rpmDest";
	code="$?";
	if [[ "$code" -ne 0 ]]; then
	echo "Could not copy $rpm to $DIST: $code" >&2;
	return "$code";
	fi

	if [[ "$NO_SOURCE" -eq 1 ]]; then
	return 0;
	fi

	cp -f "$RPMBUILD/SRPMS/$srpm" "$DIST/$srcRPMDest";
	code="$?";
	if [[ "$code" -ne 0 ]]; then
	echo "Could not copy $srpm to $DIST: $code" >&2;
	return "$code";
	fi
	done
	}

	# ---------------------------------------
	createTarball() {
	local projDir
	projDir="$(cd "$1"; pwd)"
	local projName=trafficcontrol
	local version
	version="$(getVersion "$TC_DIR")"
	local tarball="dist/apache-${projName}-${version}.tar.gz"
	local tarDir
	tarDir="$(basename "$tarball" .tar.gz)"
	local tarLink
	( trap 'rm -f "${projDir}/BUILD_NUMBER" "$projLink"' EXIT
	projLink="$(dirname "$projDir")/${tarDir}"
	ln -sf "$projDir" "$projLink"

	# Create a BUILDNUMBER file and add to tarball
	getBuildNumber >"${projDir}/BUILD_NUMBER"

	# create the tarball from BUILD_NUMBER and files tracked in git
	git ls-files \|
	sed "s\|^\|${tarDir}/\|g" \|
	tar -czf "$tarball" -C "${projLink}/.." -T - "${tarDir}/BUILD_NUMBER"
	# ^ read files from stdin to avoid tar argument limit
	)
	echo "$tarball"
	}

	# ---------------------------------------
	createDocsTarball() {
	local projDir
	projDir="$(cd "$1"; pwd)"
	local projName=trafficcontrol
	local version
	version="$(getVersion "$TC_DIR")"
	local tarball="dist/apache-$projName-$version-docs.tar.gz"
	local tarDir="${projDir}/docs/build/"

	# Create a BUILDNUMBER file and add to tarball
	getBuildNumber >"${tarDir}/BUILD_NUMBER"

	# create the tarball only from files in repo and BUILD_NUMBER
	tar -czf "$tarball" -C "$tarDir" .
	rm "${tarDir}/BUILD_NUMBER"
	echo "$tarball"
	}

	# ----------------------------------------
	# verify whether the minor-level version of the go compiler is greater or equal
	# to the minor-level version in the GO_VERSION file: returns 0 if if not.
	# returns 1 if it is.
	#
	verify_and_set_go_version() {
	if [ -v GO_VERSION ]; then
	GO_VERSION="$(getGoVersion .)"
	else
	GO_VERSION=''
	fi
	local major_version="$(echo "$GO_VERSION" \| awk -F. '{print $1}')"
	local minor_version="$(echo "$GO_VERSION" \| awk -F. '{print $2}')"
	GO_VERSION="none"
	GO="none"
	go_in_path="$(type -p go)"
	local group_1='' group_2=''
	for g in "$go_in_path" /usr/bin/go /usr/local/go/bin/go; do
	if [ -z "$g" ] \|\| [ ! -x "$g" ]; then
	continue
	fi

	go_version="$($g version \| awk '{print $3}')"

	version_pattern='.go([1-9]+)\.([1-9]+).'
	if echo "$go_version" \| grep -E "$version_pattern"; then
	group_1="$(echo "$go_version" \| sed -E "s/${version_pattern}/\1/")"
	group_2="$(echo "$go_version" \| sed -E "s/${version_pattern}/\2/")"
	if [ ! "$group_1" -ge "$major_version" ] \|\| [ ! "$group_2" -ge "$minor_version" ]; then
	GO_VERSION="${group_1}.${group_2}"; export GO_VERSION
	echo "go version for $g is ${group_1}.${group_2}"
	continue
	fi
	GO_VERSION="${group_1}.${group_2}"; export GO_VERSION
	GO=$g; export GO
	PATH="$(dirname "$g"):${PATH}"; export PATH
	echo "go version for $g is ${group_1}.${group_2}"
	echo "will use $g"
	return 0
	fi
	done

	if [ "$GO" = none ]; then
	echo "ERROR: this build needs go ${major_version}.${minor_version} or greater and no usable go compiler was found, found GO_VERSION: $GO_VERSION"
	unset GO_VERSION
	return 1
	fi
	}