1232 lines
44 KiB
Bash
Executable file
1232 lines
44 KiB
Bash
Executable file
#!/bin/bash
|
|
# Part of the SMLinux distribution
|
|
# http://git.pktsurf.in
|
|
|
|
# Exit on any error
|
|
set -e
|
|
|
|
# All variable names are to be in upper-case, function names in lower-xase.
|
|
|
|
# Store the source directory path the build was initiated from
|
|
SRCDIR="$PWD"
|
|
|
|
# Get relative directory name from SRCDIR
|
|
SRCDIRRPATH="$(basename $SRCDIR)"
|
|
|
|
# Generate sha512sums in the build file
|
|
genchecksum() {
|
|
echo "Discarding old SHA512SUMS from $SRCDIRRPATH.SMBuild"
|
|
sed -E -i \
|
|
-e '/^SHA512SUMS=".*"$/d' \
|
|
-e '/^SHA512SUMS="/,/"$/d' \
|
|
-e "/^SHA512SUMS='.*'\$/d" \
|
|
-e "/^SHA512sums='/,/'\$/d" \
|
|
"$SRCDIRRPATH".SMBuild
|
|
|
|
echo "Adding new SHA512SUMS in $SRCDIRRPATH.SMBuild..."
|
|
printf 'SHA512SUMS="\n' >> "$SRCDIRRPATH".SMBuild
|
|
|
|
# File types
|
|
FILES=( *.tar.* *.zip *.t?z *.patch *.diff *.c *.h )
|
|
|
|
# Checksum digest to be used along with arguments
|
|
CHECKSUMBINARY="sha512sum"
|
|
|
|
for FILE in ${FILES[@]} ; do
|
|
if [ -f "$FILE" ] ; then
|
|
$CHECKSUMBINARY $FILE >> "$SRCDIRRPATH".SMBuild
|
|
fi
|
|
done
|
|
printf '"' >> "$SRCDIRRPATH".SMBuild
|
|
echo "You may now run bldpkg again without any arguments"
|
|
exit 0
|
|
}
|
|
|
|
# If the first argument is "genchecksum", invoke the genchecksum function.
|
|
# Else if the first argument is filename, then get the build extension of that file and source it, else throw an error
|
|
# Else if no argument is given, get the basename of the directory and look for a matching package build file name.
|
|
# If a package build file is found, source that file and that will initiate the build.
|
|
if [ -n "$1" ] && [ "$1" = "genchecksum" ] ; then
|
|
genchecksum
|
|
elif [ -n "$1" ] ; then
|
|
EXTENSION="${1##*.}"
|
|
if [ -f "$1" ] && [ "$EXTENSION" == "SMBuild" ] ; then
|
|
source "$1"
|
|
else
|
|
echo "Invalid file!"
|
|
exit 1
|
|
fi
|
|
elif [ -z $1 ] && [ -f "$SRCDIRRPATH".SMBuild ]; then
|
|
source "$SRCDIRRPATH".SMBuild
|
|
else
|
|
echo "Please provide a build file as an argument"
|
|
exit 1
|
|
fi
|
|
|
|
# If any of the following variables are not set, abort.
|
|
if [ -z "$APP" ] || [ -z "$VERSION" ] || [ -z "$BUILD" ] || [ -z "$HOMEPAGE" ] || [ -z "$DOWNLOAD" ] || [ -z "$DESC" ] || [ -z "$REQUIRES" ] ; then
|
|
echo "One or more required variables not set. Please check your build file."
|
|
echo "Aborting."
|
|
exit 1
|
|
fi
|
|
|
|
# Display the package and its version we are building
|
|
echo "[INFO] Building package $APP version $VERSION ..."
|
|
sleep 0.5
|
|
|
|
# Then source the configuration file holding all values
|
|
if [ -f /etc/bldpkg.conf ] ; then
|
|
. /etc/bldpkg.conf
|
|
else
|
|
echo "/etc/bldpkg.conf not found! Aborting!"
|
|
fi
|
|
|
|
# Create the $SM_PARENTTEMP directory. This directory is used for everything related to the build process outside
|
|
#the source directory $SRCDIR
|
|
mkdir -p $SM_PARENTTMP
|
|
|
|
# If $SM_HTMLOUTPUT is set to 1, echo $APP, $VERSION and $BUILD as file names inside the parent build directory.
|
|
# This will output into an HTML file so that the basic status of the build process (whether started, stopped,
|
|
# interrupted or failed) can be viewed in the web browser.
|
|
if [ "$SM_HTMLOUTPUT" = "1" ] ; then
|
|
echo $APP > $SM_PARENTTMP/$APP.APP
|
|
echo $VERSION > $SM_PARENTTMP/$APP.VERSION
|
|
echo $BUILD > $SM_PARENTTMP/$APP.BUILD
|
|
fi
|
|
|
|
# Function to specifically match arrays inside a value. This function will be used later on to perform package
|
|
# and directory matches using certain conditions. Note: "${ARRAY[@]}" =~ "${VARIABLE}" isn't fool-proof.
|
|
inarray() {
|
|
local n=$1 h
|
|
shift
|
|
for h ;
|
|
do
|
|
[[ $n = "$h" ]] && return
|
|
done
|
|
return 1
|
|
}
|
|
|
|
# Time when the build commenced. Note: elapsed time is logged by the runtime function way below. This output goes
|
|
# into package build summary.
|
|
SM_COMMENCEDATE="$(date '+%a, %d %b %Y, %T')"
|
|
|
|
if [ "$SM_HTMLOUTPUT" = "1" ] ; then
|
|
if [ -n "$SM_AUTOBUILD" ] ; then
|
|
cat << EOF >> $SM_PARENTTMP/BUILDMONITOR
|
|
<b>$SM_COMMENCEDATE | Building package # $CURRENTPKGNUMBER / $TOTALPKGNUMBER: <i><a href="/smlinux/pkgresults?pkg=$APP&smver=1.0&arch=all&resultnum=25">$APP $VERSION</a></i></b>
|
|
EOF
|
|
else
|
|
cat << EOF >> $SM_PARENTTMP/BUILDMONITOR
|
|
<b>$SM_COMMENCEDATE | Building package <i><a href="/smlinux/pkgresults?pkg=$APP&smver=1.0&arch=all&resultnum=25">$APP $VERSION</a></i></b>
|
|
EOF
|
|
fi
|
|
|
|
touch $SM_PARENTTMP/BUILDING
|
|
fi
|
|
|
|
# Validate compressor and set extension
|
|
SM_VALIDPKGEXTENSIONS=( "tgz" "tbz" "tlz" "txz" )
|
|
if ! inarray "${PKGEXT}" "${SM_VALIDPKGEXTENSIONS[@]}" ; then
|
|
echo "[ERROR] $PKGEXT is not a valid package extension for an SMLinux"
|
|
echo "[ERROR] installer file! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
# Figure out the compression tool to be used based on the $PKGEXT variable set in buildvars.conf. At the same time,
|
|
# export the compressor options set for makepkg to import from the build environment.
|
|
case "$PKGEXT" in
|
|
tgz) COMPRESSOR=gzip
|
|
COMPRESSOPTS="$SM_GZIPOPTS"
|
|
export COMPRESSOPTS ;;
|
|
tbz) COMPRESSOR=bzip2
|
|
COMPRESSOPTS="$SM_BZIPOPTS"
|
|
export COMPRESSOPTS ;;
|
|
tlz) COMPRESSOR=lzip
|
|
COMPRESSOPTS="$SM_LZIPOPTS"
|
|
export COMPRESSOPTS ;;
|
|
txz) COMPRESSOR=xz
|
|
COMPRESSOPTS="$SM_XZOPTS"
|
|
export COMPRESSOPTS ;;
|
|
esac
|
|
|
|
echo -n "Validating $COMPRESSOR...."
|
|
# Borrowed from slackware's installpkg utility
|
|
if ! $COMPRESSOR --help 1> /dev/null 2> /dev/null ; then
|
|
echo "[FAILED]"
|
|
exit 1
|
|
else
|
|
echo "[OK]"
|
|
fi
|
|
|
|
# Validate the TMPFS directory. If SM_USETMPFS is set to 1 and SM_TMPFSDIR variable is set, then check for
|
|
# genuineness of the TMPFS directory. If it fails, declare a variable for the build summary.
|
|
if [ "$SM_USETMPFS" = "1" ] && [ -n "$SM_TMPFSDIR" ]; then
|
|
if [ ! -d "$SM_TMPFSDIR" ] || [ ! -w "$SM_TMPFSDIR" ] \
|
|
|| [ "$(findmnt -no TARGET $SM_TMPFSDIR)" != "$SM_TMPFSDIR" ] \
|
|
|| [ "$(findmnt -no FSTYPE $SM_TMPFSDIR)" != "tmpfs" ]; then
|
|
SM_TMPFSCHECKFAILED=1
|
|
fi
|
|
fi
|
|
|
|
# Validate system swap if SM_SWAPCHECK is defined and set to 1
|
|
if [ "$SM_SWAPCHECK" = "1" ]; then
|
|
if inarray "${APP}" "${SM_PACKAGESREQUIRINGSWAP[@]}" ; then
|
|
|
|
# Here we determine available system swap size needed to compile exceptional packages that pull in a lot of RAM.
|
|
# Those packages are listed under the SM_PACKAGESREQUIRINGSWAP array in /etc/buildvars.conf. Check whether swap
|
|
#is available on the system and if it is, determine its size. If its size is >= SM_SWAPSIZE, we are all good.
|
|
#If it's less than SM_SWAPSIZE, we exit with a status 1.
|
|
|
|
SM_SWAPCHECK="$(grep "SwapFree" /proc/meminfo | awk '{print $2}')"
|
|
if [ "$SM_SWAPCHECK" -lt "$SM_SWAPSIZE" ]; then
|
|
echo "[ERROR] Insufficient swap to build '"$APP"' which is listed"
|
|
echo "[ERROR] in $SM_PACKAGESREQUIRINGSWAP. Kindly add/increase"
|
|
echo "[ERROR] swap size on this system and try again. Aborting!"
|
|
exit 1
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Set the temporary directory for building the package. Also define package staging directory. This is where package
|
|
# files that get "installed" go into, for example 'make install DESTDIR=$PKG' or 'DESTDIR="$PKG" ninja install'.
|
|
|
|
# If SM_USETMPFS is set to 1, SM_TMPFSDIR is defined and SM_TMPFSCHECKFAILED variable is unset, determine if the
|
|
# $APP is in the exception list and whether to build inside or outside the TMPFS directory.
|
|
if [ "$SM_USETMPFS" = "1" ] && [ -n "$SM_TMPFSDIR" ] && \
|
|
[ -z "$SM_TMPFSCHECKFAILED" ] ; then
|
|
|
|
# If $APP is in the TMPFS exception list inside /etc/bldpkg.conf, compile it *OUTSIDE* the TMPFS directory, i.e
|
|
# the non-TMPFS directory, else compile it *INSIDE* the TMPFS directory. This if/else is solely for deciding
|
|
# whether $APP is in the exception list or not.
|
|
if inarray "${APP}" "${SM_TMPFSEXCEPTIONLIST[@]}" ; then
|
|
|
|
# We DO NOT compile inside tmpfsdir
|
|
SM_TMPFSENABLEDFORTHISPACKAGE=0
|
|
|
|
# In the absence of tmpfs, we use the normal directory
|
|
SM_TMP="$SM_NONTMPFSDIR/$APP.src"
|
|
PKG=${PKG:-$SM_NONTMPFSDIR/package-$APP}
|
|
else
|
|
# We compile inside tmpfsdir. Set the TMPFSENABLEDFORTHISPACKAGE variable here to inform build summary function at the bottom
|
|
SM_TMPFSENABLEDFORTHISPACKAGE=1
|
|
|
|
# Disable ccache
|
|
SM_CCACHE=0
|
|
|
|
# Override SM_PRESERVEBUILDDIR and SM_PRESERVEPACKAGEDIR to remove both build and package directories
|
|
SM_PRESERVEBUILDDIR=0
|
|
SM_PRESERVEPACKAGEDIR=0
|
|
|
|
# Get the directory from the SM_TMPFSDIR variable for extracting the source
|
|
SM_TMP="$SM_TMPFSDIR/$APP.src"
|
|
PKG=${PKG:-$SM_TMPFSDIR/package-$APP}
|
|
fi
|
|
else
|
|
# If SM_USETMPFS is disabled, we compile in the non-TMPFS directory
|
|
SM_TMP="$SM_NONTMPFSDIR/$APP.src"
|
|
PKG=${PKG:-$SM_NONTMPFSDIR/package-$APP}
|
|
fi
|
|
|
|
|
|
# Validate and export $SM_CPUTHREADS as MAKEFLAGS variable
|
|
if [ -n "$SM_CPUTHREADS" ]; then
|
|
# export the user-defined number
|
|
MAKEFLAGS="$SM_CPUTHREADS"
|
|
export MAKEFLAGS
|
|
else
|
|
# Or fetch the number from nproc
|
|
MAKEFLAGS="$(nproc --all)"
|
|
export MAKEFLAGS
|
|
fi
|
|
|
|
# Validate all compilers
|
|
# Validate everything related to distcc if SM_GLOBALDISTCC is set
|
|
if [ "$SM_GLOBALDISTCC" = "1" ] ; then
|
|
# Check if distcc exists and is an executable
|
|
if [ ! -x "$SM_DISTCCBINPATH" ]; then
|
|
echo "[ERROR] Oops! Distcc binary was not found but building with it"
|
|
echo "[ERROR] was requested! Either ensure distcc is in your "'$PATH'" or"
|
|
echo "[ERROR] disable this option in buildvars file. buildvars file"
|
|
echo "[ERROR] is located in $BUILDVARS ! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
# Check if the symlinks are right
|
|
if [ ! "$(echo "$PATH" | grep "$SM_DISTCCSYMPATH")" ] ; then
|
|
echo "[ERROR] $SM_DISTCCSYMPATH not found in "'$PATH'"! Fix it please."
|
|
exit 1
|
|
elif [ ! -d "$SM_DISTCCSYMPATH" ] ; then
|
|
echo "[ERROR] $SM_DISTCCSYMPATH directory containing symlinks to distcc"
|
|
echo "[ERROR] does not exist! Kindly create it and create symlinks"
|
|
echo "[ERROR] based on instructions in buildvars.conf! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
# Trace symlinks to the binary
|
|
for f in gcc g++ cc c++ ; do
|
|
if [ -e "$SM_DISTCCSYMPATH/$f" ] && [ -L "$SM_DISTCCSYMPATH/$f" ]; then
|
|
# We use "realpath" to follow the $SM_DISTCCSYMPATH/$f symlink and act on the exit code.
|
|
if [ "$(realpath -e "$SM_DISTCCSYMPATH/$f")" != "$SM_DISTCCBINPATH" ] ; then
|
|
echo "[ERROR] $SM_DISTCCSYMPATH/$f does not point to $SM_DISTCCBINPATH. "
|
|
echo "[ERROR] Kindly fix this! Aborting!"
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "[ERROR] $f either does not exist or is not a symlink inside"
|
|
echo "[ERROR] $SM_DISTCCSYMPATH. Kindly fix this! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
#echo -n "Validating distcc $f compiler... "
|
|
|
|
# This is a really small C program taken from autoconf tests
|
|
#cat << EOF > $SM_PARENTTMP/distcccheck-"$f".c
|
|
#int
|
|
#main()
|
|
#{
|
|
# ;
|
|
# return 0;
|
|
#}
|
|
#EOF
|
|
|
|
#"$SM_DISTCCSYMPATH/$f" -o $SM_PARENTTMP/distcccheck-"$f" $SM_PARENTTMP/distcccheck-"$f".c
|
|
#CHECKSTATUS="$?"
|
|
|
|
# Discard the files once the validation passes/fails
|
|
#if [ "$CHECKSTATUS" == "0" ] ; then
|
|
# echo "[OK]"
|
|
# rm $SM_PARENTTMP/distcccheck-"$f"{,.c}
|
|
#else
|
|
# echo "Something's up with distcc $f"
|
|
# rm $SM_PARENTTMP/distcccheck-"$f"{,.c}
|
|
# exit 1
|
|
#fi
|
|
|
|
done
|
|
|
|
# If SM_DISTCC=0 is set in the package build file to disable distcc, remove the value of $SM_DISTCCSYMPATH from
|
|
# $PATH otherwise export DISTCC_HOSTS and DISTCC_IO_TIMEOUT variables.
|
|
if [ "$SM_DISTCC" = "0" ] ; then
|
|
PATH="$(echo "$PATH" | sed "s@:$SM_DISTCCSYMPATH@@g")"
|
|
export PATH
|
|
else
|
|
export DISTCC_HOSTS DISTCC_IO_TIMEOUT
|
|
fi
|
|
else
|
|
# Remove $SM_DISTCCSYMPATH
|
|
PATH="$(echo "$PATH" | sed "s@:$SM_DISTCCSYMPATH@@g")"
|
|
export PATH
|
|
fi
|
|
|
|
# Validate everything related to ccache if SM_GLOBALCCACHE is set
|
|
if [ "$SM_GLOBALCCACHE" = "1" ]; then
|
|
if [ ! -x "$SM_CCACHEBINPATH" ] ; then
|
|
echo "[ERROR] Oops! ccache binary was not found but building with it"
|
|
echo "[ERROR] was requested! Either ensure ccache is in your "'$PATH'" or"
|
|
echo "[ERROR] disable this option in buildvars.conf. buildvars.conf"
|
|
echo "[ERROR] file is located in $BUILDVARS . Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! "$(echo $PATH | grep "$SM_CCACHESYMPATH")" ] ; then
|
|
echo "[ERROR] $SM_CCACHESYMPATH not found in "'$PATH!'" Fix it please."
|
|
exit 1
|
|
elif [ ! -d "$SM_CCACHESYMPATH" ] ; then
|
|
echo "[ERROR] $SM_CCACHESYMPATH directory containing symlinks to ccache"
|
|
echo "[ERROR] does not exist! Kindly create it and create symlinks"
|
|
echo "[ERROR] based on instructions in buildvars.conf. Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
for f in gcc g++ cc c++ ; do
|
|
if [ -e "$SM_CCACHESYMPATH/$f" ] && [ -L "$SM_CCACHESYMPATH/$f" ]; then
|
|
# We use "realpath" to follow the $SM_CCACHESYMPATH/$f symlink and act on the exit code
|
|
if [ "$(realpath -e "$SM_CCACHESYMPATH/$f")" != "$SM_CCACHEBINPATH" ] ; then
|
|
echo "[ERROR] $SM_CCACHESYMPATH/$f does not point to $SM_CCACHEBINPATH. "
|
|
echo "[ERROR] Kindly fix this! Aborting!"
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "[ERROR] $f either does not exist or is not a symlink inside $SM_CCACHESYMPATH"
|
|
echo "[ERROR] Kindly fix this! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
#echo -n "Validating ccache $f compiler... "
|
|
|
|
# This is a really small C program taken from autoconf tests
|
|
#cat << EOF > $SM_PARENTTMP/ccachecheck-"$f".c
|
|
#int
|
|
#main()
|
|
#{
|
|
# ;
|
|
# return 0;
|
|
#}
|
|
#EOF
|
|
|
|
#"$SM_CCACHESYMPATH/$f" -o $SM_PARENTTMP/ccachecheck-"$f" $SM_PARENTTMP/ccachecheck-"$f".c
|
|
#CHECKSTATUS="$?"
|
|
|
|
# Discard the files once the validation passes/fails
|
|
#if [ "$CHECKSTATUS" == "0" ] ; then
|
|
# echo "[OK]"
|
|
# rm $SM_PARENTTMP/ccachecheck-"$f"{,.c}
|
|
#else
|
|
# echo "Something's up with ccache $f"
|
|
# rm $SM_PARENTTMP/ccachecheck-"$f"{,.c}
|
|
# exit 1
|
|
#fi
|
|
|
|
done
|
|
|
|
# If SM_CCACHE=0 is set in the package build file to disable ccache, remove the value of SM_CCACHESYMPATH
|
|
# from $PATH and export it again
|
|
if [ "$SM_CCACHE" = "0" ]; then
|
|
PATH="$(echo "$PATH" | sed "s@$SM_CCACHESYMPATH:@@g")"
|
|
export PATH
|
|
fi
|
|
else
|
|
# Remove $SM_CCACHESYMPATH
|
|
PATH="$(echo "$PATH" | sed "s@$SM_CCACHESYMPATH:@@g")"
|
|
export PATH
|
|
fi
|
|
|
|
# Validate everything related to sccache if SM_GLOBALCCACHE is set
|
|
if [ "$SM_GLOBALSCCACHE" = "1" ]; then
|
|
if [ ! -x "$SM_SCCACHEBINPATH" ] ; then
|
|
echo "[ERROR] Oops! sccache binary was not found but building with it"
|
|
echo "[ERROR] was requested! Either ensure sccache is in your "'$PATH'" or"
|
|
echo "[ERROR] disable this option in buildvars.conf. buildvars.conf"
|
|
echo "[ERROR] file is located in $BUILDVARS . Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! "$(echo $PATH | grep "$SM_SCCACHEPATH")" ] ; then
|
|
echo "[ERROR] $SM_SCCACHEPATH not found in "'$PATH!'" Fix it please."
|
|
exit 1
|
|
elif [ ! -d "$SM_SCCACHEPATH" ] ; then
|
|
echo "[ERROR] $SM_SCCACHEPATH directory containing symlinks to ccache"
|
|
echo "[ERROR] does not exist! Kindly create it and create symlinks"
|
|
echo "[ERROR] based on instructions in buildvars.conf. Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
for f in gcc g++ cc c++ ; do
|
|
# A hard link is basically a copy of a file with the same inode number stored in a different location.
|
|
# We are trying a bit hard to ascertain whether a binary is a hard link or not.
|
|
# First get the inode number of the binary in the original location
|
|
SM_SCCACHE_BINARY_INODE_NUM="$(stat --printf '%i\n' $SM_SCCACHEBINPATH)"
|
|
# Then get the inode number of the file inside the hard link path
|
|
SM_SCCACHE_HARDLINK_FILE_INODE_NUM="$(stat --printf '%i\n' $SM_SCCACHEPATH/$f)"
|
|
|
|
if [ ! -e "$SM_SCCACHEPATH/$f" ] ; then
|
|
echo "[ERROR] $f either does not exist inside $SM_SCCACHEPATH"
|
|
echo "[ERROR] Kindly fix this! Aborting!"
|
|
exit 1
|
|
# If the hard link's inode number does not match the original binary's inode number, throw an error and exit
|
|
elif [ "$SM_SCCACHE_HARDLINK_FILE_INODE_NUM" != "$SM_SCCACHE_BINARY_INODE_NUM" ] ; then
|
|
echo "[ERROR] File '"$f"' inside $SM_SCCACHEPATH is not a hard link!"
|
|
echo "[ERROR] Kindly fix this! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
#echo -n "Validating sccache $f compiler... "
|
|
|
|
# This is a really small C program taken from autoconf tests
|
|
#cat << EOF > $SM_PARENTTMP/sccachecheck-"$f".c
|
|
#int
|
|
#main()
|
|
#{
|
|
# ;
|
|
# return 0;
|
|
#}
|
|
#EOF
|
|
|
|
#"$SM_SCCACHEPATH/$f" -o $SM_PARENTTMP/sccachecheck-"$f" $SM_PARENTTMP/sccachecheck-"$f".c
|
|
#CHECKSTATUS="$?"
|
|
|
|
# Discard the files once the validation passes/fails
|
|
#if [ "$CHECKSTATUS" == "0" ] ; then
|
|
# echo "[OK]"
|
|
# rm $SM_PARENTTMP/sccachecheck-"$f"{,.c}
|
|
#else
|
|
# echo "Something's up with sccache $f"
|
|
# rm $SM_PARENTTMP/sccachecheck-"$f"{,.c}
|
|
# exit 1
|
|
#fi
|
|
|
|
done
|
|
|
|
# If SM_SCCACHE=0 is set in the package build file to disable sccache, remove the value of SM_SCCACHEPATH
|
|
# from $PATH and export it again
|
|
if [ "$SM_SCCACHE" = "0" ]; then
|
|
PATH="$(echo "$PATH" | sed "s@$SM_SCCACHEPATH:@@g")"
|
|
export PATH
|
|
fi
|
|
else
|
|
# Remove $SM_SCCACHEPATH
|
|
PATH="$(echo "$PATH" | sed "s@$SM_SCCACHEPATH:@@g")"
|
|
export PATH
|
|
fi
|
|
|
|
# Apply CPU-specific compiler variables defined inside bldpkg.conf
|
|
# https://github.com/sakaki-/gentoo-on-rpi-64bit/blob/master/reference/compile_run_benchmarks.sh
|
|
# https://www.raspberrypi.org/forums/viewtopic.php?t=11629
|
|
# noarch is set inside initfs, pkgtools, GTK themes and some other stuff.
|
|
|
|
# If $ARCH has not been exported by autobuild or not set in the individual build files that have ARCH=noarch, we set our own
|
|
# $HOSTTYPE is only set in the bash shell.
|
|
[ -z "$ARCH" ] && ARCH="$HOSTTYPE"
|
|
|
|
if [ "$ARCH" = "noarch" ]; then
|
|
CFLAGS=""
|
|
export CFLAGS
|
|
|
|
elif [ "$ARCH" = "aarch64" ]; then
|
|
HOSTDIST="$SM_AARCH64HOSTDIST"
|
|
BUILDDIST="$SM_AARCH64BUILDDIST"
|
|
if [ -n "$SM_DEBUG" ]; then
|
|
CFLAGS="$(echo $SM_GCCDEBUG $SM_AARCH64CFLAGS)"
|
|
else
|
|
CFLAGS="$SM_AARCH64CFLAGS"
|
|
fi
|
|
CXXFLAGS="$CFLAGS"
|
|
export HOSTDIST BUILDDIST CFLAGS CXXFLAGS
|
|
|
|
elif [ "$ARCH" = "x86_64" ]; then
|
|
BUILDDIST="$SM_X8664BUILDDIST"
|
|
if [ -n "$SM_DEBUG" ]; then
|
|
CFLAGS="$(echo $SM_GCCDEBUG $SM_X8664CFLAGS)"
|
|
else
|
|
CFLAGS="$SM_X8664CFLAGS"
|
|
fi
|
|
CXXFLAGS="$CFLAGS"
|
|
export BUILDDIST CFLAGS CXXFLAGS
|
|
|
|
else
|
|
echo "[ERROR] Sorry! '$ARCH' CPU architecture not supported by SMLinux! Aborting!"
|
|
exit 1
|
|
fi
|
|
|
|
# Do a preliminary package dependency check
|
|
echo "Parsing $APP 's dependency list..."
|
|
|
|
for PACKAGEDEP in $REQUIRES; do
|
|
DEPCOUNT="$(find /doc -name $PACKAGEDEP.SMBuild | wc -l)"
|
|
# If count is 1, we are ok
|
|
if [ "$DEPCOUNT" == "1" ] ; then
|
|
echo "Found dependency $PACKAGEDEP"
|
|
# If count is 0, we exit, because we are in trouble
|
|
elif [ "$DEPCOUNT" == "0" ] ; then
|
|
echo "Did not find dependency $PACKAGEDEP ! Aborting!"
|
|
exit 1
|
|
# If count is greater than or equal to 2, we are in slightly less trouble
|
|
elif [ "$DEPCOUNT" -ge "2" ] ; then
|
|
echo "Warning! Found multiple versions of $PACKAGEDEP !"
|
|
sleep 0.5
|
|
fi
|
|
done
|
|
|
|
# If $SM_NOAUTOCONFSITE is unset in an individual package build file, export CONFIG_SITE variable into the build
|
|
# environment for a package's configure script to pickup. Most autoconf-compatible configure scripts will
|
|
# automatically pick up this variable from the environment and speed up the initial configure process.
|
|
if [ -z "$SM_NOAUTOCONFSITE" ] ; then
|
|
if [ -n "$SM_CONFIGSITE" ]; then
|
|
CONFIG_SITE="$SM_CONFIGSITE"
|
|
if [ -e "$CONFIG_SITE" ]; then
|
|
export CONFIG_SITE
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Condition to reuse the AUTOBUILDTEMP file if set from autobuild or make a new temporary file
|
|
if [ -n "$SM_AUTOBUILDTEMP" ]; then
|
|
SM_TEMPFILE="$SM_AUTOBUILDTEMP"
|
|
else
|
|
SM_TEMPFILE="$(mktemp $SM_PARENTTMP/SMBUILD.XXXXXX)"
|
|
fi
|
|
|
|
# Only verify source checksums if SM_SKIPCHECKSUM is not set in the build file
|
|
if [ -z "$SM_SKIPCHECKSUM" ] ; then
|
|
if [ -z "$SHA512SUMS" ] ; then
|
|
echo "sha512 checksums don't exist in $SRCDIRRPATH.SMBuild !"
|
|
echo "Please run bldpkg genchecksum"
|
|
exit 1
|
|
fi
|
|
|
|
eval sums=\"\$SHA512SUMS\"
|
|
|
|
echo "Verifying Checksums..."
|
|
IFS=$'\n'
|
|
for src in $sums; do
|
|
echo "$src" | sha512sum -c
|
|
done
|
|
unset IFS
|
|
echo "Looks good..."
|
|
fi
|
|
#build
|
|
|
|
# Function to prevent a package from compiling on an unsupported architecture
|
|
compileonlyfor() {
|
|
# usage: compileonlyfor <arch>
|
|
# will cause compilation to exit with 0 if uname -m does not match <arch>
|
|
archname="$(uname -m)"
|
|
archargument=$1
|
|
if [ "$archname" != "$archargument" ]; then
|
|
echo ""
|
|
echo "[INFO] '"$APP"' not supported on '"$archname"' and hence not"
|
|
echo "[INFO] not being built. Exiting."
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
# Function to remove old package directories and make new ones.
|
|
# To be invoked inside a package build file.
|
|
mkandenterbuilddir() {
|
|
# $TMP, $PKG and $PKGDEST are set in buildvars.conf.
|
|
PKGDOCS="$PKG/doc/$APP-$VERSION"
|
|
# Remove any old $PKG staging directory left by any previous build.
|
|
# We are about to rm -rf something, so trying a bit hard not to delete
|
|
# the wrong directory
|
|
if ! inarray "${PKG}" "${SM_PROTECTEDDIRECTORIES[@]}" ; then
|
|
rm -rf "$PKG"
|
|
else
|
|
systemdirectorydeletionmessage
|
|
echo "'"$PKG"' IS LISTED AS A PROTECTED DIRECTORY BUT
|
|
ACCIDENTALLY LISTED AS A VALUE FOR "'$PKG'" VARIABLE!! ABORTING!!"
|
|
exit 1
|
|
fi
|
|
|
|
# Now create all essential build-related directories
|
|
mkdir -p "$SM_TMP" "$PKG" "$PKGDOCS" "$PKGDEST"
|
|
|
|
echo "[INFO] Leaving source directory $SRCDIR"
|
|
echo "[INFO] Entering build directory $SM_TMP"
|
|
cd "$SM_TMP"
|
|
}
|
|
|
|
# Function to fix permissions inside the build directory
|
|
# To be invoked inside a package build file.
|
|
fixbuilddirpermissions() {
|
|
echo -n "[INFO] Fixing permissions in the newly-created build directory..."
|
|
chown -R root.root .
|
|
find -L . -perm /111 -a \! -perm 755 -a -exec chmod 755 {} \+ -o \
|
|
\! -perm /111 -a \! -perm 644 -a -exec chmod 644 {} \+ || true
|
|
echo " done."
|
|
}
|
|
|
|
# This function will set the interrupt variable so prepbuildsummary can output the right build status on receiving
|
|
# ctrl-c from the user during a manual build.
|
|
interruptsummary() {
|
|
echo "Caught Keyboard Interrupt..."
|
|
SM_WASINTERRUPTED="1"
|
|
# If SM_INSTALLPROMPT and SM_EXTRACTPROMPT are set and the prompt is invoked after a successful build, hitting
|
|
# ctrl-C will only set the above SM_WASINTERRUPTED variable repeatedly and won't return user to the shell because
|
|
# of the interrupt (SIGINT) trap set way below. Putting exit 0 is a decent way to get out of that prompt
|
|
|
|
# Clean up stale files like $APP.APP, $APP.BUILD and $APP.VERSION
|
|
if [ -z "$SM_AUTOBUILD" ] ; then
|
|
rm -f $SM_PARENTTMP/$APP.{APP,BUILD,VERSION}
|
|
fi
|
|
|
|
exit 0
|
|
}
|
|
|
|
systemdirectorydeletionmessage() {
|
|
echo "############ ATTENTION ############"
|
|
echo "I JUST STOPPED AN IMPORTANT SYSTEM DIRECTORY FROM BEING DELETED!!"
|
|
}
|
|
|
|
# Function to calculate elapsed build time. runtime takes the $SECONDS variable as an argument. $SECONDS is an
|
|
# environment variable set by bash to show the number of whole seconds the shell has been running.
|
|
runtime() {
|
|
[ -z "$1" ] && return 1
|
|
|
|
local D=$(( $1 / 86400 ))
|
|
local H=$(( ($1 - ($D * 86400)) / 3600 ))
|
|
local M=$(( ($1 - ($D * 86400) - ($H * 3600)) / 60 ))
|
|
local S=$(( $1 - ($D * 86400) - ($H * 3600) - ($M * 60) ))
|
|
|
|
if [ "$D" -gt "0" ]; then
|
|
echo -n "${D}d, ${H}h ${M}m ${S}s"
|
|
else
|
|
echo -n "${H}h, ${M}m ${S}s"
|
|
fi
|
|
return 0
|
|
}
|
|
|
|
# Function to prepare runit service directories for a particular daemon
|
|
# To be invoked inside a package build file.
|
|
preprunitservice() {
|
|
|
|
# usage: $ preprunitservice <chrony> <down> <finish>
|
|
# Will create the chrony service directories with a down and a finish file to prevent auto-execution at next boot
|
|
# and to provide a clean exit respectively. Use the first argument to define the service name
|
|
rsname=$1
|
|
# Use the second argument to add the down file
|
|
down=$2
|
|
# Use the third argument to add the finish file
|
|
finish=$3
|
|
|
|
# Enter the staging directory
|
|
cd "$PKG"
|
|
|
|
# Create the service directories
|
|
mkdir -p "etc/service/$1" var/service
|
|
|
|
# Copy the service run file from the source directory into etc/service/$1
|
|
if [ -f "$SRCDIR/$1.run" ] ; then
|
|
cp "$SRCDIR/$1.run" "etc/service/$1/run"
|
|
else
|
|
echo "$1.run does not exist! Exiting"
|
|
exit 1
|
|
fi
|
|
|
|
# If the second argument is "down", or if the second argument is "finish", create that file inside etc/service/$1/
|
|
if [ "$2" = "down" ]; then
|
|
touch "etc/service/$1/down"
|
|
elif [ "$2" = "finish" ]; then
|
|
cp "$SRCDIR/$1.$2" "etc/service/$1/finish"
|
|
fi
|
|
|
|
# If the third argument is "finish", copy that file from the source directory into etc/service/$1/
|
|
[ -n "$3" ] && cp "$SRCDIR/$1.$3" "etc/service/$1/finish"
|
|
|
|
# Create the symlinks between etc/service and var/service
|
|
ln -s "../../etc/service/$1" "var/service/$1"
|
|
|
|
# Finally set the executable permissions on the run file
|
|
chmod 0755 "$PKG/etc/service/$1/run"
|
|
}
|
|
|
|
# Function to remove static libraries for use inside build scripts
|
|
# To be invoked inside a package build file.
|
|
removestaticlibs() {
|
|
echo "[INFO] Discarding static libraries..."
|
|
find "$PKG" -name "*.a" -exec rm -fv {} \;
|
|
}
|
|
|
|
# Function to perform post-compile tasks:
|
|
# To be invoked inside a package build file.
|
|
mkfinalpkg() {
|
|
# Now we attempt to split the total time we'll get when making the summary into two times: compile time and
|
|
# packaging time. Here we store the value of $SECONDS variable the moment makefinalpkg is invoked. We use this
|
|
# value as the compile time, because this is the next function that's called by the build script the moment a
|
|
# successful compile make install DESTDIR=$PKG or something similar.
|
|
|
|
# SM_COMPILETIMEA will store the exact seconds
|
|
SM_COMPILETIMEA="$SECONDS"
|
|
|
|
# SM_COMPILETIMEB will run the runtime function against SM_COMPILETIMEA and store the resulting output
|
|
SM_COMPILETIMEB="$( runtime $SM_COMPILETIMEA )"
|
|
|
|
echo "[INFO] Leaving build directory $SM_TMP"
|
|
echo "[INFO] Entering staging directory $PKG"
|
|
cd $PKG
|
|
echo "[INFO] Just a min..."
|
|
|
|
# Check if /lib64 was created inside $PKG
|
|
if [ -d "$PKG/lib64" ] ; then
|
|
echo "$APP has /lib64 directory. Musl does not support multilib."
|
|
echo "Please fix the build options and ensure the /lib64 is not created".
|
|
echo "Aborting."
|
|
exit 1
|
|
fi
|
|
|
|
# Check if /usr and /sbin were created inside $PKG
|
|
for directory in /usr /sbin ; do
|
|
if [ -d "$PKG/$directory" ] ; then
|
|
echo "$APP has $directory directory which is a symlink to /bin on SMLinux."
|
|
echo "Please fix the build options and ensure /usr is not created. Aborting!"
|
|
exit 1
|
|
fi
|
|
done
|
|
|
|
echo "[INFO] Copying post-install files..."
|
|
mkdir -p "$PKG/install"
|
|
|
|
[ -e "$SRCDIR/doinst.sh" ] && cp "$SRCDIR/doinst.sh" "$PKG/install/"
|
|
|
|
# Compress and link manpages
|
|
if [ -d "$PKG/share/man" ]; then
|
|
echo "[INFO] Compressing and linking man pages..."
|
|
( cd "$PKG/share/man"
|
|
for manpagedir in $(find . -type d -name "man*") ; do
|
|
( cd "$manpagedir"
|
|
for eachpage in $( find . -type l -maxdepth 1) ; do
|
|
ln -s "$( readlink "$eachpage" ).gz" "$eachpage".gz
|
|
rm "$eachpage"
|
|
done
|
|
gzip -9 ./*.? >/dev/null 2>&1 || true
|
|
)
|
|
done
|
|
)
|
|
fi
|
|
|
|
# Remove .la files similar to what slackware devs are doing in slackware-current, but in a more efficient manner :)
|
|
echo "[INFO] Discarding any libtool archive (.la) files..."
|
|
find "$PKG" ! -type d -name "*.la" -exec rm -v {} \;
|
|
|
|
# Provide a copy of the package build file so that users know the build options that went into compiling the package
|
|
install -Dm 644 "$SRCDIR/$APP.SMBuild" "$PKGDOCS/$APP.SMBuild"
|
|
|
|
# Now strip the binaries and shared libraries
|
|
if [ -z "$SM_DEBUG" ] && [ "$SM_DEBUG" != "1" ]; then
|
|
find "$PKG" -print0 | xargs -0 file -m /etc/file/magic/elf | \
|
|
grep -E "executable|shared object|statically linked" | grep "ELF" | \
|
|
cut -d: -f1 | xargs strip --strip-unneeded 2>/dev/null || true
|
|
fi
|
|
|
|
# And static libraries separately unconditionally
|
|
find "$PKG" -print0 | xargs -0 file -m /etc/file/magic/archive | \
|
|
grep -E "current ar archive" | awk '{print $1}' | cut -d: -f1 | \
|
|
xargs strip --strip-unneeded 2>/dev/null || true
|
|
|
|
if [ "$SM_SHOWSUMMARY" == "1" ] ; then
|
|
SM_TOTALFILECOUNT="$(find $PKG -type f | wc -l)"
|
|
SM_TOTALDIRCOUNT="$(find $PKG -type d | wc -l)"
|
|
SM_TOTALSYMCOUNT="$(find $PKG -type l | wc -l)"
|
|
SM_PACKUSIZE1="$(du -s $PKG | awk '{print $1}')"
|
|
|
|
# Here we ascertain the packaging time taken to actually prepare the final package. For this, we must reset the
|
|
# SECONDS variable to ensure accuracy
|
|
SECONDS=0
|
|
fi
|
|
|
|
# Finally create the package
|
|
/bin/makepkg -l y -c n "$PKGDEST/$APP-$VERSION-$ARCH-$BUILD.$PKGEXT"
|
|
SM_PKGSTATUS=$?
|
|
|
|
# Store package location inside this variable:
|
|
SM_PACKLOCATION="$PKGDEST/$APP-$VERSION-$ARCH-$BUILD.$PKGEXT"
|
|
|
|
echo "[INFO] Leaving staging directory $PKG"
|
|
|
|
# cd back to $SRCDIR when SM_PRESERVEPACKAGEDIR is set to 0 to prevent this error: shell-init: error retrieving
|
|
# current directory: getcwd: cannot access parent directories: No such file or directory
|
|
echo "[INFO] Re-entering source directory $SRCDIR"
|
|
cd "$SRCDIR"
|
|
|
|
# Discard $APP.APP, $APP.BUILD and $APP.VERSION files if SM_AUTOBUILDTEMP is not set. If SM_AUTOBUILDTEMP is set,
|
|
# there's no need to discard these files because it's auto-discarded by the section build file itself.
|
|
if [ "$SM_HTMLOUTPUT" = "1" ] ; then
|
|
if [ -z "$SM_AUTOBUILDTEMP" ] ; then
|
|
rm -f $SM_PARENTTMP/$APP.{APP,BUILD,VERSION}
|
|
fi
|
|
fi
|
|
|
|
if [ "$SM_SHOWSUMMARY" == "1" ]; then
|
|
# With SECONDS reset, the shell will add in a fresh value, which we can now use to ascertain the packaging time,
|
|
# by again passing that value as an argument to the runtime function
|
|
SM_PACKAGETIMEA="$SECONDS"
|
|
SM_PACKAGETIMEB="$( runtime $SM_PACKAGETIMEA )"
|
|
|
|
# Determine size of SRCDIR aka source directory
|
|
SM_SRCDIRSIZE="$(du -s $SRCDIR | awk '{print $1}')"
|
|
# Determine size of SM_TMP aka build directory size
|
|
SM_BUILDDIRSIZE="$(du -s $SM_TMP | awk '{print $1}')"
|
|
|
|
# Calculate SSD write savings if TMPFS has been used
|
|
if [ "$SM_USETMPFS" = "1" ] && \
|
|
[ "$SM_TMPFSENABLEDFORTHISPACKAGE" = "1" ] ; then
|
|
|
|
# Determine size of staging directory
|
|
SM_PKGDIRSIZE="$(du -s $PKG | awk '{print $1}')"
|
|
|
|
# Sum total of the above two variables is the amount of writes we saved
|
|
SM_TMPFSSAVINGSSUM0="$(( $SM_BUILDDIRSIZE + $SM_PKGDIRSIZE ))"
|
|
|
|
# We'll get sum in kB. Convert that to MB.
|
|
SM_TMPFSSAVINGSSUM1="$(echo "scale=2 ; "$SM_TMPFSSAVINGSSUM0" / 1024" | bc)"
|
|
|
|
# Store the result for build summary to pickup.
|
|
SM_TMPFSSAVINGSSIZE="$(echo and $SM_TMPFSSAVINGSSUM1"MB" writes to SSD saved)"
|
|
fi
|
|
fi
|
|
|
|
# Delete the build directory if SM_PRESERVEBUILDDIR is set to 0
|
|
if [ "$SM_PRESERVEBUILDDIR" = "0" ] ; then
|
|
if ! inarray "${SM_TMP}" "${SM_PROTECTEDDIRECTORIES[@]}" ; then
|
|
rm -rf "$SM_TMP"
|
|
else
|
|
systemdirectorydeletionmessage
|
|
echo "'"$SM_TMP"' IS LISTED AS A PROTECTED DIRECTORY BUT \
|
|
ACCIDENTALLY LISTED AS A VALUE FOR "'$SM_TMP'" VARIABLE!! EXITING!!"
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# Delete the package build directory if SM_PRESERVEPACKAGEDIR is set to 0
|
|
if [ "$SM_PRESERVEPACKAGEDIR" = "0" ] ; then
|
|
if [[ ! "${SM_PROTECTEDDIRECTORIES[@]}" =~ "${PKG}" ]] ; then
|
|
rm -rf "$PKG"
|
|
else
|
|
systemdirectorydeletionmessage
|
|
echo "'"$PKG"' IS LISTED AS A PROTECTED DIRECTORY BUT ACCIDENTALLY\
|
|
LISTED AS A VALUE FOR "'$PKG'" VARIABLE!! EXITING!!"
|
|
exit 1
|
|
fi
|
|
fi
|
|
}
|
|
|
|
prepbuildsummary() {
|
|
# Start of the SM_SHOWSUMMARY if/else check
|
|
if [ "$SM_SHOWSUMMARY" = "1" ]; then
|
|
# Get the build completion time and store it in a variable
|
|
SM_FINISHDATE="$(date '+%a, %d %b %Y, %T')"
|
|
|
|
# Stick to 8/16 colours, those are supported on most terminals
|
|
if [ "$SM_COLOURS" = "1" ]; then
|
|
SM_COLOURSCHECK="$(tput colors 2>/dev/null)"
|
|
if [ "$?" = "0" ] && [ "$SM_COLOURSCHECK" -gt "2" ] ; then
|
|
# Red when the build fails
|
|
SM_COLOURR="\e[41m"
|
|
# Yellow when the build is interrupted
|
|
SM_COLOURY="\e[93m"
|
|
# Green when the build succeeds
|
|
SM_COLOURG="\e[92m"
|
|
# Cyan for the short questions
|
|
SM_COLOURC="\e[96m"
|
|
# APPNAME/VERSION Colours
|
|
SM_COLOURV="\e[92m"
|
|
# Restore to default
|
|
SM_COLOURD="\e[0m"
|
|
fi
|
|
fi
|
|
|
|
# Determine the build type
|
|
if [ -n "$SM_AUTOBUILD" ]; then
|
|
# We are using Tadgy's autobuild system
|
|
SM_BUILDSYS="SSB Autobuild"
|
|
else
|
|
# We compiled the package manually
|
|
SM_BUILDSYS="Manual"
|
|
fi
|
|
|
|
|
|
# Determine if distcc was used. If SM_GLOBALDISTCC is enabled and set to 1 and SM_DISTCC is not declared in the
|
|
# package build file, then set SM_DSTATS in the build summary
|
|
if [ "$SM_GLOBALDISTCC" = "1" ] && \
|
|
[ -z "$SM_DISTCC" ]; then
|
|
SM_DSTATS="Yes"
|
|
# Else if SM_GLOBALDISTCC is enabled and set to 1 and SM_DISTCC is set to 0 in the package build file, then set
|
|
# SM_DSTATS in the build summary
|
|
elif [ "$SM_GLOBALDISTCC" = "1" ] && \
|
|
[ "$SM_DISTCC" = "0" ]; then
|
|
SM_DSTATS="Nope, disabled but global variable set"
|
|
# Else If SM_GLOBALDISTCC is unset, set SM_DSTATS in the build summary
|
|
elif [ -z "$SM_GLOBALDISTCC" ] || [ "$SM_GLOBALDISTCC" = "0" ]; then
|
|
SM_DSTATS="No, disabled globally"
|
|
fi
|
|
|
|
|
|
# Determine if ccache was used. Ccache caches compiler objects to disk, which speeds up subsequent compiles.
|
|
# However, if we are compiling inside tmpfs, we are not using ccache at all. So we set SM_CSTATS accordingly
|
|
# in the build summary
|
|
if [ "$SM_GLOBALCCACHE" = "1" ] && \
|
|
[ -n "$SM_USETMPFS" ] && [ "$SM_USETMPFS" = "1" ] && \
|
|
[ -n "$SM_TMPFSENABLEDFORTHISPACKAGE" ] && \
|
|
[ "$SM_TMPFSENABLEDFORTHISPACKAGE" = "1" ] ; then
|
|
SM_CSTATS="Enabled globally but disabled due to tmpfs"
|
|
|
|
elif [ -n "$SM_GLOBALCCACHE" ] && [ "$SM_GLOBALCCACHE" = "1" ] && \
|
|
[ -n "$SM_USETMPFS" ] && [ "$SM_USETMPFS" = "0" ] ; then
|
|
SM_CSTATS="Yes"
|
|
|
|
elif [ "$SM_GLOBALCCACHE" = "1" ] && \
|
|
[ -z "$SM_USETMPFS" ] ; then
|
|
SM_CSTATS="Yes"
|
|
|
|
elif [ -z "$SM_GLOBALCCACHE" ] || [ "$SM_GLOBALCCACHE" = "0" ] ; then
|
|
SM_CSTATS="No, disabled globally"
|
|
fi
|
|
|
|
|
|
# Determine the build type
|
|
if [ "$SM_DEBUG" = "1" ] ; then
|
|
SM_BLDTYPE="*DEBUG* build"
|
|
else
|
|
SM_BLDTYPE="General build, no debug symbols"
|
|
fi
|
|
|
|
|
|
# Determine whether tmpfs was used
|
|
if [ "$SM_USETMPFS" = "1" ] && \
|
|
[ "$SM_TMPFSENABLEDFORTHISPACKAGE" = "1" ] ; then
|
|
SM_TMPFSSTATE="Yes"
|
|
|
|
elif [ "$SM_USETMPFS" = "1" ] && \
|
|
[ "$SM_TMPFSENABLEDFORTHISPACKAGE" = "0" ]; then
|
|
SM_TMPFSSTATE="*Not for this package* but enabled globally"
|
|
|
|
elif [ "$SM_USETMPFS" = "1" ] && \
|
|
[ "$SM_TMPFSCHECKFAILED" = "1" ]; then
|
|
SM_TMPFSSTATE="*NOPE, TMPFS DIRECTORY CHECK FAILED* but enabled globally"
|
|
|
|
else
|
|
SM_TMPFSSTATE="No, disabled globally"
|
|
fi
|
|
|
|
|
|
if [ -n "$SM_CPUTHREADS" ]; then
|
|
SM_MAKEFLAGS="$MAKEFLAGS, manually set"
|
|
else
|
|
SM_MAKEFLAGS="$MAKEFLAGS, auto-detected"
|
|
fi
|
|
|
|
# If SM_COMPILETIMEA is set, then do a sum total of SM_COMPILETIMEA and SM_PACKAGETIMEA variables to get the
|
|
# total time in seconds and use that as an argument for the runtime function. If SM_COMPILETIMEA is not set,
|
|
# invoke the runtime function alone on new reset $SECONDS
|
|
if [ -n "$SM_COMPILETIMEA" ]; then
|
|
SM_FINALCOMPILETIME="$(( $SM_COMPILETIMEA + $SM_PACKAGETIMEA ))"
|
|
SM_TOTALTIME="$( runtime $SM_FINALCOMPILETIME )"
|
|
else
|
|
SM_TOTALTIME="$( runtime $SECONDS )"
|
|
fi
|
|
|
|
# Determine if the build was successful or not
|
|
if [ "$SM_PKGSTATUS" = "0" ] ; then
|
|
SM_BLDSTATUS="$(echo -e "$SM_COLOURG"'Successful! :-D' \
|
|
"$SM_COLOURD")"
|
|
|
|
if [ "$SM_HTMLOUTPUT" = "1" ] ; then
|
|
cat << EOF >> $SM_PARENTTMP/BUILDMONITOR.html
|
|
<tr><td><b><i><a href="/smlinux/pkgresults?pkg=$APP&smver=1.0&arch=all&resultnum=25">$APP $VERSION</a></i></b></td><td>$SM_COMMENCEDATE</td><td>$SM_FINISHDATE</td><td>$SM_TOTALTIME</td><td><b style="color:#00cc00;">SUCCEEDED</b></td></tr>
|
|
EOF
|
|
|
|
rm -f $SM_PARENTTMP/BUILDING
|
|
fi
|
|
|
|
# Determine the compressed size
|
|
SM_PACKSIZE="$(du -bk "$SM_PACKLOCATION" | awk '{print $1}')"
|
|
|
|
# Determine the uncompressed size
|
|
SM_PACKUSIZE="$(echo $SM_PACKUSIZE1)"
|
|
|
|
elif [ "$SM_WASINTERRUPTED" = "1" ]; then
|
|
SM_BLDSTATUS="$(echo -e "$SM_COLOURY"\
|
|
'** INTERRUPTED ** :-/'"$SM_COLOURD")"
|
|
|
|
if [ "$SM_HTMLOUTPUT" = "1" ] ; then
|
|
cat << EOF >> $SM_PARENTTMP/BUILDMONITOR.html
|
|
<tr><td><b><i><a href="/smlinux/pkgresults?pkg=$APP&smver=1.0&arch=all&resultnum=25">$APP $VERSION</a></i></b></td><td>$SM_COMMENCEDATE</td><td>$SM_FINISHDATE</td><td>$SM_TOTALTIME</td><td><b>INTERRUPTED</b></td></tr>
|
|
EOF
|
|
|
|
rm -f $SM_PARENTTMP/BUILDING
|
|
fi
|
|
|
|
else
|
|
SM_BLDSTATUS="$(echo -e "$SM_COLOURR"'!! FAILED !! :-('\
|
|
"$SM_COLOURD")"
|
|
|
|
if [ -n "$SM_HTMLOUTPUT" ] && [ "$SM_HTMLOUTPUT" = "1" ] ; then
|
|
cat << EOF >> $SM_PARENTTMP/BUILDMONITOR.html
|
|
<tr><td><b><i><a href="/smlinux/pkgresults?pkg=$APP&smver=1.0&arch=all&resultnum=25">$APP $VERSION</a></i></b></td><td>$SM_COMMENCEDATE</td><td>$SM_FINISHDATE</td><td>$SM_TOTALTIME></td><td><b style="color:#ff1a1a;">FAILED</b></td></tr>
|
|
EOF
|
|
|
|
rm -f $SM_PARENTTMP/BUILDING
|
|
fi
|
|
|
|
|
|
fi
|
|
|
|
|
|
# Finally prepare the summary
|
|
echo "" >> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC"---------------------------------------------\
|
|
----------------------------------" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e " BUILD SUMMARY FOR PACKAGE "$SM_COLOURD"'"$SM_COLOURV"\
|
|
"$APP""$SM_COLOURD"'"$SM_COLOURC" VERSION "$SM_COLOURD"'"$SM_COLOURV"\
|
|
"$VERSION"'" "$SM_COLOURC"TAG"$SM_COLOURV" "'$BUILD'"$SM_COLOURD"" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC"---------------------------------------------\
|
|
----------------------------------"$SM_COLOURD"" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" Build Status:"$SM_COLOURD" \
|
|
$SM_BLDSTATUS" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
|
|
# Output the section name if SM_AUTOBUILDTEMP is set. This means we are running an autobuild.
|
|
if [ -n "$SM_AUTOBUILDTEMP" ]; then
|
|
echo -e ""$SM_COLOURC" Build Section:"$SM_COLOURD" $SECTION" \
|
|
>> "$SM_TEMPFILE"
|
|
fi
|
|
|
|
|
|
# If we have $SM_COMPILETIMEB set, then assume the compile went well and output compile and packaging times
|
|
# into SM_TEMPFILE.
|
|
if [ -n "$SM_TOTALTIME" ] && [ -z "$SM_PACKAGETIMEB" ]; then
|
|
echo -e ""$SM_COLOURC" Total Time: "$SM_COLOURD" $SM_TOTALTIME" \
|
|
>> "$SM_TEMPFILE"
|
|
elif [ -n "$SM_TOTALTIME" ] && [ -n "$SM_PACKAGETIMEB" ]; then
|
|
echo -e ""$SM_COLOURC" Total Time: "$SM_COLOURD" $SM_TOTALTIME \
|
|
( $SM_COMPILETIMEB Compile ) + ( $SM_PACKAGETIMEB Packaging )" \
|
|
>> "$SM_TEMPFILE"
|
|
fi
|
|
|
|
|
|
echo -e ""$SM_COLOURC" Started:"$SM_COLOURD" $SM_COMMENCEDATE" \
|
|
>> "$SM_TEMPFILE"
|
|
echo -e ""$SM_COLOURC" Stopped:"$SM_COLOURD" $SM_FINISHDATE" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
# If the package was built successfully, output the installer sizes
|
|
if [ "$SM_PKGSTATUS" = "0" ]; then
|
|
#SM_COMPRESSEDSIZE="$(echo $(($SM_PACKSIZE * 100 / $SM_PACKUSIZE)))"
|
|
# Space saving = 1 - Compressed Size / Uncompressed size.
|
|
# Also, bc code taken from:
|
|
# https://stackoverflow.com/questions/56945130/bash-echo-percentage-with-no-decimal-point-with-result-returned-from-bc-comman
|
|
SM_COMPRESSEDSIZE="$(echo $(echo "scale=2 ; 1 - "$SM_PACKSIZE" / \
|
|
"$SM_PACKUSIZE"" | bc ) | sed 's@.@@')"
|
|
|
|
echo -e ""$SM_COLOURC" Source Size: "$SM_COLOURD" Compressed: \
|
|
$SM_SRCDIRSIZE"K", Uncompressed: $SM_BUILDDIRSIZE"K"" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" Package Size: "$SM_COLOURD" Uncompressed: \
|
|
$SM_PACKUSIZE"K", Compressed: $SM_PACKSIZE"K" ("$SM_COMPRESSEDSIZE'%'")" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" Package Has: "$SM_COLOURD" \
|
|
$SM_TOTALFILECOUNT files and $SM_TOTALSYMCOUNT symlinks in $SM_TOTALDIRCOUNT \
|
|
directories" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
fi
|
|
|
|
|
|
# If ccache was used, output the current cache used size and max allocated size
|
|
if [ "$SM_GLOBALCCACHE" = "1" ] && [ "$SM_CCACHE" != "0" ] && \
|
|
[ "$SM_CSTATS" = "Yes" ]; then
|
|
SM_CCACHEUSEDSIZE="$(ccache -s | grep "cache size" | head -n 1 | \
|
|
awk '{ $1=$2="" ; print $0}')"
|
|
SM_CCACHETOTALSIZE="$(ccache -s | grep "max cache size" | \
|
|
awk '{ $1=$2=$3="" ; print $0}')"
|
|
|
|
echo -e ""$SM_COLOURC" Ccache Used?"$SM_COLOURD" "$SM_CSTATS",\
|
|
"$SM_CCACHEUSEDSIZE" /"$SM_CCACHETOTALSIZE" Allocated" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
else
|
|
echo -e ""$SM_COLOURC" Ccache Used?"$SM_COLOURD" "$SM_CSTATS"" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
fi
|
|
|
|
echo -e ""$SM_COLOURC" Distcc Used?"$SM_COLOURD" $SM_DSTATS" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
|
|
# If distcc was used, cut out --randomize and output rest of the DISTCC_HOSTS variable
|
|
if [ "$SM_GLOBALDISTCC" = "1" ] && [ "$SM_DISTCC" != "0" ]; then
|
|
echo -e ""$SM_COLOURC" Distcc Args: "$SM_COLOURD" $(echo \
|
|
"$DISTCC_HOSTS" | sed 's@--randomize@@')" \
|
|
>> "$SM_TEMPFILE"
|
|
fi
|
|
|
|
|
|
echo -e ""$SM_COLOURC" TMPFS Used? "$SM_COLOURD" "$SM_TMPFSSTATE" $SM_TMPFSSAVINGSSIZE" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" CPU Threads: "$SM_COLOURD" $(echo $SM_MAKEFLAGS | \
|
|
sed 's@-j@@')" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" CFLAGS Used: "$SM_COLOURD" $CFLAGS" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" Compressor: "$SM_COLOURD" $COMPRESSOR \
|
|
($COMPRESSOPTS)" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC" Build Type:" $SM_COLOURD" $SM_BUILDSYS \
|
|
& $SM_BLDTYPE" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
echo -e ""$SM_COLOURC"---------------------------------------------------\
|
|
----------------------------"$SM_COLOURD"" \
|
|
>> "$SM_TEMPFILE"
|
|
|
|
|
|
# Output the build summary to the user on every build
|
|
cat $SM_TEMPFILE
|
|
|
|
# Once the output is shown, discard all temporary files
|
|
rm -f $SM_TEMPFILE
|
|
if [ -z "$SM_AUTOBUILD" ] ; then
|
|
rm -f $SM_PARENTTMP/$APP.{APP,BUILD,VERSION}
|
|
fi
|
|
fi
|
|
# Completion of the SM_SHOWSUMMARY if/else check
|
|
|
|
# Invoke promptuser function
|
|
promptuser
|
|
}
|
|
|
|
promptuser() {
|
|
# Prompt the user at the end of a build whether to extract contents of a newly-built installer into a subdirectory
|
|
# called "test" inside the package source directory the build was manually initiated from. Has no effect on
|
|
# autobuilds since they are simply installed right away.
|
|
if [ "$SM_EXTRACTPROMPT" = "1" ] && [ -z "$SM_AUTOBUILD" ] && [ -n "$SM_PACKLOCATION" ] ; then
|
|
while true ; do
|
|
echo
|
|
echo "[NOTIFY] '"$APP"' has been built and SM_EXTRACTPROMPT is enabled in"
|
|
echo "[NOTIFY] buildvars.conf file. Would you like to extract and examine contents"
|
|
echo "[NOTIFY] of its package installer in a 'test' directory within the"
|
|
echo "[NOTIFY] current source directory"
|
|
echo "[NOTIFY] ($SRCDIR) ?"
|
|
|
|
read -r -p "[NOTIFY] Old test directory, if it exists already, will be overwritten. (y/N) " yn
|
|
|
|
case $yn in
|
|
[Yy]* ) echo "[INFO] Wise choice :-) ";
|
|
mkdir -p "$SRCDIR"/test
|
|
tar xvf "$SM_PACKLOCATION" -C "$SRCDIR"/test
|
|
echo ""
|
|
echo "[INFO] '"$APP"' package installer file successfully extracted"
|
|
break;;
|
|
*) echo "[INFO] Nope? Alright." ; break ;;
|
|
esac
|
|
done
|
|
fi
|
|
|
|
# Prompt the user at the end of a successful build whether to install the newly created package. Has no effect on
|
|
# autobuilds because packages there are installed automatically.
|
|
if [ "$SM_INSTALLPROMPT" = "1" ] && [ -z "$SM_AUTOBUILD" ] && [ -n "$SM_PACKLOCATION" ] ; then
|
|
while true ; do
|
|
echo
|
|
|
|
echo "[NOTIFY] '"$APP"' successfully built and SM_INSTALLPROMPT is enabled in the buildvars.conf file."
|
|
|
|
read -r -p "[NOTIFY] Would you like to install/upgrade it? (y/N) " yn
|
|
case $yn in
|
|
[Yy]* ) echo "[INFO] Wise choice :-) "
|
|
upgradepkg --install-new "$SM_PACKLOCATION"
|
|
break;;
|
|
*) echo "[INFO] Nope? Alright." ; exit 0 ;;
|
|
esac
|
|
done
|
|
fi
|
|
|
|
if [ "$SM_PKGSTATUS" = "0" ]; then
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
# https://unix.stackexchange.com/questions/462392/bash-the-function-is-executed-twice
|
|
# https://stackoverflow.com/questions/9256644/identifying-received-signal-name-in-bash/9256709
|
|
# We use two traps to identify the signals, EXIT and INT. EXIT will invoke 'prepbuildsummary' function on any exit
|
|
# status >= 0. The script fail status is determined by the above SM_PKGSTATUS or any premature compile failure.
|
|
# The 'interrruptsummary' function is invoked when the user sends CTRL-C aka SIGINT. The SIGINT trap does not work
|
|
# for auto builds, it has been added in the section build file too.
|
|
|
|
trap "prepbuildsummary" EXIT
|
|
trap "interruptsummary" INT
|
|
|
|
build
|