uci-docker-build/lib/build.lib

383 lines
11 KiB
Bash
Executable File

#!/bin/bash
quiet () {
if [[ $VERBOSE ]]; then $@; fi
}
get_arch () {
local arch="$(uname -m)"
case "$arch" in
x86_64) arch='amd64' ;;
armhf) arch='armv6' ;;
armv7) arch='armv7' ;;
aarch64) arch='arm64' ;;
ppc64el|ppc64le) arch='ppc64le' ;;
s390x) arch='s390x';;
*) return 1 ;;\
esac;
echo $arch
}
isAbsPath() {
if [[ "${1:0:1}" == / || "${1:0:2}" == ~[/a-z] ]]
then
echo "true"
return 0
else
return 1
fi
}
sed_ignore_comments () {
cmd="sed -r 'h;s/[^#]*//1;x;s/#.*//;${1};G;s/(.*)\n/\1/'"
if (( $# == 2 )) ; then
eval $cmd <<< "$2"
else
eval $cmd < /dev/stdin
fi
}
clean_env_file () {
local compact; local lines
# -c will also remove comments and all empty lines
[[ $1 == "-c" ]] && compact=true && shift 1
#
# remove trailing spaces | remove double quotes
# | remove blanks after equals and quote value | remove any spaces before afer =
# remove blank lines | remove comment lines if requested
[[ -f $1 ]] && lines=$(<$1) || lines="$1"
echo "$lines" | sed_ignore_comments s/\\s*$//g | sed_ignore_comments s/\"//g \
| sed_ignore_comments s/\(=[[:blank:]]*\)\(.*\)/\\1\"\\2\"/ \
| sed_ignore_comments s/\\s*=\\s*/=/g \
| sed -rz 's/^\n+//; s/\n+$/\n/g' | if [[ $compact ]]; then grep -v '^#' | grep -v "^$" ; else cat; fi
}
env_file () {
local efile
efile=$(echo -- "$@" | grep -oP -- '(?<=-e )[^ ]*')
if [[ ! $efile ]]; then
[[ ! "$1" == *-* ]] && efile=${1:-.env}
fi
[[ -f "$(realpath "${efile}.env" 2> /dev/null)" ]] && { echo "${efile}.env"; return 0; } # || echo not ${efile}.env
[[ -f "$(realpath "${efile}/.env" 2> /dev/null)" ]] && { echo "${efile}/.env"; return 0; } # || echo not ${efile}/.env
[[ "${efile##*.}" == "env" ]] && [[ -f "$(realpath "${efile}" 2> /dev/null)" ]] && { echo $efile; return 0; } # || echo not $env
return 1
}
read_env_file() {
local evar
while read line; do
evar=$(echo $line | cut -d '=' -f1)
if [[ $(echo $(c() { echo $#; }; c $line)) -gt 1 ]];then
echo the environment file: $1
echo has a format error on this line
echo "--------------"
echo $line
echo "--------------"
echo you must correct this before the build can continue
return 1
fi
if [[ ! ${!evar} ]]; then
# echo DECLARE $evar via $line
if declare -gx "$(echo "${line}" | sed 's/\"//g' )"; then
quiet echo loaded: ${evar}=${!evar}
else
quiet echo error setting $evar
return 1
fi
else
quiet echo $evar already set to ${!evar}
fi
done < <(clean_env_file -c $1)
}
source_env_file () {
local default;local efile
if efile=$(env_file "${@:-$BUILD_EFILE}"); then
[[ $efile == ".env" ]] && default=true
[[ ! $(isAbsPath $efile) ]] && efile=$(realpath $efile)
quiet echo -e "\e[1;37m********************\e[0;37m"
quiet echo loading build environment with environment file
quiet echo $efile
quiet echo ----------------
quiet cat $efile
quiet echo ----------------
if read_env_file "$efile"; then
[[ $default ]] && quiet echo -e "\e[1;31mNOTE: sourced default .env file in present directory\e[0;37m"
quiet echo -e "\e[1;37m********************\e[0;37m"
BUILD_EFILE=$efile
else
quiet echo error occured while loading environment file
quiet echo $efile
quiet echo exiting
quiet echo -e "\e[1;37m********************\e[0;37m"
return 2
fi
else
if [[ $efile ]]; then
quiet echo unable to find an environment file with passed ${1}
else
quiet echo unable to find default environment file .env
quiet echo using the current environment plus default build options
fi
return 2
fi
}
load_csv () {
# add newline, remove comments, remove empty lines, remove leading whitepace, remove extra whitespace around ,
if [[ -f $1 ]]; then
sed -e '$a\' "$1" | \
sed -e '/\s*#.*$/d' | \
sed -e '/^\s*$/d' | \
sed 's/^\s*//g' | \
sed 's/\s*,\s*/,/g'
else
return 1
fi
}
get_distro_core_image_name () {
local distro; local imagename
distro=${1:-$LINUX_DISTRO}
if [[ $distro ]]; then
imagename=$(echo "$(load_csv $BDIR/distros.csv)" | grep "^${distro}," | cut -f2 -d, | sed "s/\s/|/g")
[[ $imagename ]] && echo $imagename || return 1
else
return 2
fi
}
get_distro_from_image () {
local temp=/tmp/os-release.tmp
local distro
local keep
[[ $1 == "-k" ]] && (keep=true;shift)
[[ ! $1 ]] && return 1
if docker create --name dummy $1 > /dev/null 2>&1; then
if docker cp -L dummy:${2:-/etc/os-release} $temp > /dev/null 2>&1; then
docker rm -f dummy > /dev/null
distro=$(cat $temp | grep "ID_LIKE=" | cut -f2 -d=)
if [[ ! "$distro" ]]; then
distro=$(cat $temp | grep "^ID=" | cut -f2 -d=)
fi
[[ "$distro" ]] && echo $distro || return 2
fi
else
return 1
fi
[[ ! $keep ]] && docker image rm $1 > /dev/null 2>&1
}
validate_distro() {
# only valid distros are ones in distros.csv
local distro; local set_distro;
distro=${1:-$LINUX_DISTRO}
if [[ $distro ]]; then
if [[ $BASE_IMAGE ]]; then
>&2 echo "FATAL: cannot specifiy both BASE_IMAGE ($BASE_IMAGE) and a LINUX_DISTRO ($LINUX_DISTRO), aborting build"
return 2
fi
else
if [[ $BASE_IMAGE ]]; then
echo validate from base image
if ! distro=$(get_distro_from_image $BASE_IMAGE); then
>&2 echo "ERROR: unable to get distro from BASE_IMAGE $BASE_IMAGE, can't validate"
return 2
fi
set_distro=true
else
echo "WARNING: neither LINUX_DISTRO nor BASE_IMAGE image specified"
echo "Setting LINUX_DISTRO to default (alpine)"
set_distro=true
distro=alpine
fi
fi
distros=$(echo $(echo "$(load_csv $BDIR/distros.csv)" | grep -Eo "^[^,]+") | sed "s/\s/|/g" | tr '[:upper:]' '[:lower:]')
if [[ ! "$distros" == *"${distro}"* ]]; then
>&2 echo "distro $distro is not a valid uci-docker-build distro ($distros)"
return 1
fi
[[ ! $BASE_NAME ]] && BASE_IMAGE=$(get_distro_core_image_name $distro)
if [[ $set_distro ]] && [[ ! "$1" ]]; then LINUX_DISTRO=$distro; fi
}
# delete
# get_base_image() {
# [[ ! $BASE_IMAGE ]] && BASE_IMAGE=$(get_default_distro_image)
# if [[ $BASE_IMAGE ]]; then
# quiet echo determining DISTRO of base image: $BASE_IMAGE
# if ! validate_image_distro $BASE_IMAGE; then
# echo "unable to get or use base image: $BASE_IMAGE, aborting build" && return 5
# fi
# quiet echo $BASE_IMAGE is built from distro $LINUX_DISTRO
# else
# echo unable to determine a base image, aborting build
# return 6
# fi
# }
make_image_name () {
local arch
# echo making image name $@
# echo name: $NAME
# echo APPEND: $APPEND_DISTRO
# echo user: $RUSER
# echo distro $LINUX_DISTRO
if [[ $1 ]]; then
# [[ $NAME ]] && echo changing image name from $NAME to $1
NAME=$1
fi
if [[ $2 ]]; then
# [[ $RUSER ]] && echo changing image username from $RUSER to $2
RUSER=$2
fi
if [[ $NAME ]]; then
[[ $APPEND_DISTRO ]] && NAME=$NAME-${LINUX_DISTRO}
else
# echo no image name supplied using distro name ${LINUX_DISTRO:-alpine}
NAME=${LINUX_DISTRO:-alpine}
fi
[[ $TARGET == "arm64" && ! $TARGET == $(get_arch) ]] && arch=-$TARGET
[[ $TARGET == "amd64" && ! $TARGET == $(get_arch) ]] && arch=-$TARGET
echo $([[ $RUSER ]] && echo ${RUSER}/)${NAME}$arch
}
get_build_src () {
# processing the build source directory
local src; local spath; local spaths
# will determine if there are any minimal build source files/directories
check_dir () {
if
[ $(ls $1/packages/*system.pkgs 2> /dev/null) ] || \
[ $(ls $1/packages/system/*.pkgs 2> /dev/null) ] || \
[ -f $1/packages/repositories.sh ] || \
[ -f $1/packages/packages.sh ]
then
_packages_=true
return 0
fi
[[ -f $1/init/init.sh ]] && return 0
[[ -d $1/rootfs ]] && return 0
return 1
}
src=${1:-$BUILD_SRC}
[[ $src == "_core_" ]] && return 0
src=${src:-src}
unset BUILD_SRC
if check_dir $src; then
BUILD_SRC=$(realpath $src)
echo $BUILD_SRC
return 0
fi
quiet echo build source path \'$src\' not initially found, echo looking
quiet echo in \$PWD,\$PWD/src/,../\$PWD/src for valid build source
quiet echo to avoid this search use BUILD_SRC= in an environment file
spaths="$PWD $PWD/src $(dirname $PWD)/$src $(dirname $PWD)"
for spath in $spaths; do
quiet echo checking for source in: $spath
if check_dir $spath; then
quiet echo found valid source directory!
BUILD_SRC=$spath
echo $BUILD_SRC
return 0
fi
done
quiet echo -e "\e[1;31mERROR: unable to find a build source directory as $src \e[1;37m"
return 1
}
build_info () {
if [[ $VERBOSE ]]; then
echo -e "\n!!!!!!!!!!!!!!!!EXTRA BUILD INFO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
pushd "$BDIR" > /dev/null || return 3
docker buildx bake --print $TARGET
popd > /dev/null || return 4
if [[ $BUILD_SRC == "_core_" ]]; then
echo building only core
cat $BDIR/core/core.sh
ls -la $BDIR/core
else
echo -e "\n---------------------------------"
echo "build source at $BUILD_SRC to be mounted to /build in container ***** "
ls -la $BUILD_SRC
echo -e "\n----- base init script init.sh ------\n"
cat $BUILD_SRC/init/init.sh
echo -e "\n----- end base init script init.sh ------"
echo -e "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
fi
fi
echo -e "\e[1;37m**************BUILD PARAMETERS *******************************"
echo "Architecture of this machine doing the building: $ARCH"
if [[ "$BUILD_SRC" == "_core_" ]] ;then
echo Building ONLY the UCI core
else
echo "Using scripts source directory at $BUILD_SRC"
fi
echo "Building with base image: $BASE_IMAGE"$([[ "${BASE_IMAGE}" == *":"* ]] || echo :latest)
echo "Build logs can be found in directory $log_dir"
echo "Linux Distro of Image: $LINUX_DISTRO"
echo "Using build target: ${TARGET}"
if [[ -f $APPEND_BUILD_ENV ]]; then
echo "Will append contents of $APPEND_BUILD_ENV to build envionrment"
echo "-------"
cat $APPEND_BUILD_ENV
echo "-------"
fi
echo "----- output --------"
echo creating image
case $TARGET in
multi)
echo "names for both amd64 and arm64, image without architecture suffix is $ARCH"
echo -e "\e[1;31m$IMAGE_NAME$([[ ! $ARCH == amd64 ]] && echo -amd64):${TAG:-latest}\n$IMAGE_NAME$([[ ! $ARCH == arm64 ]] && echo -arm64):${TAG:-latest}\e[1;37m"
echo "building locally and then pushing to ${REPO:-hub.docker.com}"
if [[ ! $REPO ]]; then
echo "NOTE: use target 'publish' to build and push these both"
echo "to docker hub without architecture suffix or local copy"
fi
;;
dev)
;&
default)
echo -e "name => \e[1;31m$IMAGE_NAME:${TAG:-latest}\e[1;37m"
echo "Will build this single image on this machine with architecture $ARCH"
;;
arm64)
echo -e "name => \e[1;31m$IMAGE_NAME$([[ ! $ARCH == arm64 ]] && echo -arm64):${TAG:-latest}\e[1;37m"
echo "Will build this single arm64 image on this machine"
;;
amd64)
echo -e "name => \e[1;31m$IMAGE_NAME$([[ ! $ARCH == amd64 ]] && echo -amd64):${TAG:-latest}\e[1;37m"
echo "Will build this single amd64 image on this machine"
;;
publish)
echo -e "image name \e[1;31m$IMAGE_NAME:${TAG:-latest}\e[1;37m"
echo "Will build and push both amd64 and arm64"
echo "architecture images to hub.docker.com with this single name"
echo "and no local copy will remain"
;;
esac
echo "------------------"
echo -e "********************\e[0;37m"
}