383 lines
11 KiB
Bash
Executable File
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"
|
|
|
|
} |