PktSurf
73cff466bf
* Added code that detects stripped binaries before we actually strip them of debug symbols Fixed various typos and code
1400 lines
48 KiB
Bash
Executable file
1400 lines
48 KiB
Bash
Executable file
#!/bin/bash
|
|
# Part of the SMLinux distribution
|
|
# http://git.pktsurf.in/smlinux
|
|
#
|
|
# Bash script to build SMLinux-specific and general Slackware packages
|
|
#
|
|
# Copyright (c) 2022 PktSurf <smlinux@pktsurf.in>
|
|
#
|
|
# Permission to use, copy, modify, and distribute this software for any
|
|
# purpose with or without fee is hereby granted, provided that the above
|
|
# copyright notice and this permission notice appear in all copies.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
############
|
|
|
|
# TODO
|
|
# -> Uncomment entirety of the code where compilers are to be hard-validated and improve C code
|
|
# in the test files and also add suitable bldpkg.conf switches for it
|
|
# -> Give a warning when more than two directories, a source and a staging directory
|
|
# not belonging to the current build are present inside tmpfs
|
|
# -> Warn user when /share/icons or /share/applications directory is present but
|
|
# a doinst.sh file that should update the icon caching is absent in the source directory
|
|
|
|
# Begin subshell
|
|
(
|
|
|
|
# Exit on any error
|
|
set -e
|
|
|
|
# Time when the build commenced. Note: elapsed time is logged by the runtime function way below. This output goes
|
|
# into package build summary.
|
|
commencedate="$(date '+%a, %d %b %Y, %T')"
|
|
|
|
# Then source the configuration file holding all values
|
|
if [ -f /etc/bldpkg.conf ] ; then
|
|
source /etc/bldpkg.conf
|
|
else
|
|
echo "[ERROR] /etc/bldpkg.conf not found!"
|
|
exit 1
|
|
fi
|
|
|
|
# Store the source directory path the build was initiated from
|
|
srcdir="$PWD"
|
|
|
|
# Get relative directory name from SRCDIR
|
|
srcdirpath="$(basename $srcdir)"
|
|
buildfile="$srcdirpath.SMBuild"
|
|
|
|
sourcebuildfile() {
|
|
if [ -f "$buildfile" ] ; then
|
|
source "$buildfile"
|
|
else
|
|
# We expect a filename as part of -f argument
|
|
echo "[ERROR] No build file to source from! If you used -f argument, make sure it is"
|
|
echo "[ERROR] the first argument pointing to a build file before any other argument."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
setbuildfile() {
|
|
buildfile0="$OPTARG"
|
|
if [ ! -f "$OPTARG" ] ; then
|
|
echo "[ERROR] Build file $buildfile0 not found!"
|
|
exit 1
|
|
fi
|
|
buildfile="$buildfile0"
|
|
sourcebuildfile
|
|
}
|
|
|
|
# Function to invoke bash shell's -x mode for troubleshooting
|
|
tracemode() {
|
|
set -x
|
|
sourcebuildfile
|
|
}
|
|
|
|
debugmode() {
|
|
debug=1
|
|
sourcebuildfile
|
|
}
|
|
|
|
autoextractmode() {
|
|
# Override extractprompt in bldpkg.conf
|
|
extractprompt=0
|
|
autoextract=1
|
|
sourcebuildfile
|
|
}
|
|
|
|
displaysummary() {
|
|
# Override showsummary in bldpkg.conf
|
|
showsummary=1
|
|
sourcebuildfile
|
|
}
|
|
|
|
setcputhreads() {
|
|
cputhreads0="$OPTARG"
|
|
# Validate if the argument is a number. If not, throw an error and exit.
|
|
if ! echo "$cputhreads0" | egrep -q '^[0-9]+$' ; then
|
|
echo "[ERROR] Invalid CPU job number. Please try again."
|
|
exit 1
|
|
fi
|
|
cputhreads="$cputhreads0"
|
|
sourcebuildfile
|
|
}
|
|
|
|
# Generate sha512sums in the build file
|
|
genchecksum() {
|
|
echo "[INFO] Discarding old sha512sums from $buildfile"
|
|
tempbuildfile="$buildfile"
|
|
sed -E -i \
|
|
-e '/^sha512sums=".*"$/d' \
|
|
-e '/^sha512sums="/,/"$/d' \
|
|
-e "/^sha512sums='.*'\$/d" \
|
|
"$buildfile"
|
|
|
|
echo "[INFO] Adding new sha512sums in $tempbuildfile"
|
|
printf 'sha512sums="\n' >> "$tempbuildfile"
|
|
|
|
# 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 >> "$tempbuildfile"
|
|
fi
|
|
done
|
|
|
|
printf '"' >> "$tempbuildfile"
|
|
echo "[INFO] You may now run bldpkg again"
|
|
exit 0
|
|
}
|
|
|
|
# Function to generate help message
|
|
help() {
|
|
cat << EOF
|
|
Bash script for building SMLinux-compatible packages from source.
|
|
Any option used as an argument with this script overrides the
|
|
corresponding option, if present, in /etc/bldpkg.conf
|
|
|
|
If no arguments are provided, this script attempts to build a package
|
|
by matching the parent directory name with a build file that matches
|
|
that directory's name.
|
|
|
|
For example, if the build directory is $HOME/smlinux/alsa-lib, this script will
|
|
look and source from alsa-lib.SMBuild and build alsa-lib package if the user
|
|
has cd'd to $HOME/smlinux/alsa-lib
|
|
|
|
# pwd
|
|
/home/smlinux/alsa-lib
|
|
|
|
# ls
|
|
alsa-lib.SMBuild
|
|
|
|
# bldpkg
|
|
Building package 'alsa-lib' version '1.x' build '1sml'...
|
|
...build output...
|
|
|
|
Usage:
|
|
|
|
-d : Produce a package with debug symbols preserved
|
|
|
|
-e : Extract the package installer file in the user's PWD if the build
|
|
completes successfully.
|
|
|
|
-f : Alternate build file to source build variables.
|
|
NOTE: This argument, if used, must come before any other argument
|
|
|
|
-g : Generate SHA512 checksums of all tarballs and patches and insert them
|
|
into the package build file
|
|
|
|
-h : Show this help message
|
|
|
|
-j<N> : Provide a number of jobs to be run simultaneously
|
|
|
|
-s : Display build summary. A summary is produced whenever a build is either
|
|
interrupted, exits cleanly or aborts due to a build error
|
|
|
|
-x : Invoke bash shell command trace mode. This one isn't akin to running
|
|
bash -x <script> but close enough, because the mode is inserted
|
|
half way while bldpkg is running
|
|
|
|
EOF
|
|
exit 0
|
|
}
|
|
|
|
# Function for providing handy arguments to users
|
|
while getopts ':def:ghj:sx' option; do
|
|
case "$option" in
|
|
d) debugmode ;;
|
|
e) autoextractmode ;;
|
|
f) setbuildfile "$OPTARG" ;;
|
|
g) genchecksum ;;
|
|
h) help ;;
|
|
j) setcputhreads "$OPTARG" ;;
|
|
s) displaysummary ;;
|
|
x) tracemode ;;
|
|
*) help ;;
|
|
esac
|
|
done
|
|
|
|
# If no argument is given, or if argument is greater than 1, invoke sourcebuildfile function.
|
|
if [ "$OPTIND" -ge 1 ] ; then
|
|
sourcebuildfile
|
|
fi
|
|
|
|
# Determine whether we are using bash version 4 and later
|
|
if [ "${BASH_VERSINFO[0]}" -lt 4 ] ; then
|
|
echo "[ERROR] bldpkg requires a minimum of version 4 and later to run"
|
|
exit 1
|
|
fi
|
|
|
|
# Validate the build file. If any of the following variables are not set in the build file, abort.
|
|
for buildvariables in app version build homepage desc requires ; do
|
|
if [[ ! "${!buildvariables}" ]] ; then
|
|
echo "[ERROR] Required variable \"${buildvariables}\" is not set. Please check your build file."
|
|
exit 1
|
|
fi
|
|
done
|
|
|
|
# Validate $app
|
|
if ! echo "$app" | egrep -q '^[a-z0-9-]+$' ; then
|
|
echo "[ERROR] Only lower case, numeric characters and dash allowed in the '"'app'"' variable in the build file."
|
|
exit 1
|
|
fi
|
|
|
|
# Validate $version
|
|
if ! echo "$version" | egrep -q '^[a-z0-9.]+$' ; then
|
|
echo "[ERROR] Only lower case, numeric characters and a period allowed in the '"'version'"' variable in the build file."
|
|
exit 1
|
|
fi
|
|
|
|
# Validate $homepage
|
|
if ! echo "$homepage" | egrep -q '^http://|^https://|^ftp://' ; then
|
|
echo "[ERROR] Invalid URL in the '"'homepage'"' variable in the build file."
|
|
exit 1
|
|
fi
|
|
|
|
# Validate $download
|
|
if [ -n "$download" ]; then
|
|
if ! echo "$download" | egrep -q '^http://|^https://|^ftp://' ; then
|
|
echo "[ERROR] Invalid URL in the '"'download'"' variable in the build file."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
# Validate $desc
|
|
if [ "$(echo "$desc" | wc -c)" -gt 100 ] ; then
|
|
echo "[ERROR] Package description should not exceed 100 characters in the build file."
|
|
exit 1
|
|
fi
|
|
|
|
# Check if build() function exists in the build file
|
|
if [[ ! "$(grep '^build()' "$buildfile")" ]] ; then
|
|
echo "[ERROR] build() function does not exist in your build file."
|
|
exit 1
|
|
fi
|
|
|
|
# Display the package and its version we are building
|
|
echo "[INFO] Building package $app version $version ..."
|
|
sleep 0.5
|
|
|
|
# Only verify source checksums if skipchecksum is not set in the build file
|
|
if [ -z "$skipchecksum" ] ; then
|
|
if [ -z "$sha512sums" ] ; then
|
|
echo "[ERROR] SHA512 checksums don't exist in $buildfile !"
|
|
echo "[ERROR] Please run 'bldpkg -g' to add them"
|
|
exit 1
|
|
fi
|
|
|
|
eval sums=\"\$sha512sums\"
|
|
|
|
echo "[INFO] Verifying SHA512 checksums against source files..."
|
|
|
|
IFS=$'\n'
|
|
|
|
for src in $sums; do
|
|
echo "$src" | sha512sum -c
|
|
done
|
|
|
|
unset IFS
|
|
fi
|
|
|
|
# Function to output to the user which patch is about to be applied. Useful when
|
|
# there are many patches and you want to determine which patch failed.
|
|
applypatch() {
|
|
if [ -z "$1" ]; then
|
|
echo "[ERROR] Please provide valid patch file name"
|
|
exit 1
|
|
fi
|
|
relativepath="$(basename $1)"
|
|
echo "[INFO] Applying patch $relativepath.."
|
|
patch -p1 < "$1"
|
|
}
|
|
|
|
# Do a preliminary package dependency check if checkdependencies is set to 1 in bldpkg.conf
|
|
if [ "$checkdependencies" = "1" ] ; then
|
|
|
|
echo "[INFO] Parsing $app 's dependency list..."
|
|
for packagedep in "$requires"; do
|
|
depcount="$(find /share/doc -name $packagedep.SMBuild | wc -l)"
|
|
# If count is 1, we are ok
|
|
if [ "$depcount" = "1" ] ; then
|
|
echo "[INFO] Found dependency $packagedep"
|
|
# If count is 0, we exit, because we are in trouble
|
|
elif [ "$depcount" = "0" ] ; then
|
|
echo "[ERROR] Did not find dependency $packagedep ."
|
|
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
|
|
|
|
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
|
|
}
|
|
|
|
# Check if $parenttmp is set and is a directory
|
|
if [ -z "$parenttmp" ] ; then
|
|
echo "[ERROR] parenttmp variable not set in /etc/bldpkg.conf."
|
|
exit 1
|
|
elif [ ! -d "$parenttmp" ] ; then
|
|
echo "[ERROR] parenttmp variable set to '"$tmpfsdir"' in /etc/bldpkg.conf is not a directory."
|
|
exit 1
|
|
fi
|
|
|
|
# Attempt to write to the $parenttmp directory. This directory is used for everything related to the build process outside #the source directory $srcdir
|
|
if ! touch "$parenttmp"/.smlinuxwritetest ; then
|
|
echo "[ERROR] $parenttmp is not writable."
|
|
exit 1
|
|
fi
|
|
|
|
# Discard the test file
|
|
[ -e "$parenttmp"/.smlinuxwritetest ] && rm -f "$parenttmp"/.smlinuxwritetest
|
|
|
|
# Determine if $tmpfsdir is listed inside $protecteddirectories array
|
|
if inarray "${parenttmp}" "${protecteddirectories[@]}" ; then
|
|
echo "############ ATTENTION ############"
|
|
echo "[ERROR] parenttmp IS SET TO '"$tmpfsdir"' WHICH IS A PROTECTED DIRECTORY!! EXITING!!"
|
|
exit 1
|
|
fi
|
|
|
|
# If $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 [ "$htmloutput" = "1" ] ; then
|
|
|
|
if [ -n "$autobuild" ] ; then
|
|
cat << EOF >> $parenttmp/BUILDMONITOR
|
|
<b>$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 >> $parenttmp/BUILDMONITOR
|
|
<b>$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 $parenttmp/BUILDING
|
|
fi
|
|
|
|
# Validate compressor and set extension
|
|
validpkgextensions=( "tgz" "tbz" "tlz" "txz" )
|
|
if ! inarray "${pkgext}" "${validpkgextensions[@]}" ; then
|
|
echo "[ERROR] $pkgext is not a valid package extension for an SMLinux installer file."
|
|
exit 1
|
|
fi
|
|
|
|
# Figure out the compression tool to be used based on the $pkgext variable set in bldpkg.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="$gzipopts"
|
|
export compressopts ;;
|
|
tbz) compressor=bzip2
|
|
compressopts="$bzipopts"
|
|
export compressopts ;;
|
|
tlz) compressor=lzip
|
|
compressopts="$lzipopts"
|
|
export compressopts ;;
|
|
txz) compressor=xz
|
|
compressopts="$xzopts"
|
|
export compressopts ;;
|
|
esac
|
|
|
|
# Borrowed from slackware's installpkg utility
|
|
if ! $compressor --help > /dev/null 2>&1 ; then
|
|
echo "[ERROR] '"$compressor"' Compressor validation failed."
|
|
exit 1
|
|
fi
|
|
|
|
# Validate the TMPFS directory. If usetmpfs is set to 1 and tmpfsdir variable is set, then check for
|
|
# genuineness of the TMPFS directory. If it fails, declare a variable for the build summary.
|
|
if [ "$usetmpfs" = "1" ] && [ -n "$tmpfsdir" ]; then
|
|
if [ ! -d "$tmpfsdir" ] || ! touch "$tmpfsdir/.smlinuxtmpwritetest" \
|
|
|| [ "$(findmnt -no TARGET $tmpfsdir)" != "$tmpfsdir" ] \
|
|
|| [ "$(findmnt -no FSTYPE $tmpfsdir)" != "tmpfs" ]; then
|
|
tmpfscheckfailed=1
|
|
fi
|
|
|
|
[ -e "$tmpfsdir/.smlinuxtmpwritetest" ] && rm -f "$tmpfsdir/.smlinuxtmpwritetest"
|
|
fi
|
|
|
|
# Validate system swap if swapcheck is defined and set to 1
|
|
if [ "$swapcheck" = "1" ]; then
|
|
if inarray "${app}" "${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 packagesrequiringswap array in /etc/bldpkg.conf. Check whether swap
|
|
#is available on the system and if it is, determine its size. If its size is >= swapsize, we are all good.
|
|
#If it's less than swapsize, we exit with a status 1.
|
|
|
|
swapcheck="$(grep "SwapFree" /proc/meminfo | awk '{print $2}')"
|
|
if [ "$swapcheck" -lt "$swapsize" ]; then
|
|
echo "[ERROR] Insufficient swap to build '"$app"' which is listed"
|
|
echo "[ERROR] in $packagesrequiringswap. Kindly add/increase"
|
|
echo "[ERROR] swap size on this system and try again."
|
|
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 usetmpfs is set to 1, tmpfsdir is defined and tmpfscheckfailed variable is unset, determine if the
|
|
# $app is in the exception list and whether to build inside or outside the TMPFS directory.
|
|
if [ "$usetmpfs" = "1" ] && [ -n "$tmpfsdir" ] && [ -z "$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}" "${tmpfsexceptionlist[@]}" ; then
|
|
|
|
# We DO NOT compile inside tmpfsdir
|
|
tmpfsenabledforthispackage=0
|
|
|
|
# In the absence of tmpfs, we use the normal directory
|
|
tmp="$nontmpfsdir/$app.src"
|
|
pkg="${pkg:-$nontmpfsdir/package-$app}"
|
|
else
|
|
# We compile inside tmpfsdir. Set the tmpfsenabledforthispackage variable here to inform build summary function at the bottom
|
|
tmpfsenabledforthispackage=1
|
|
|
|
# Disable ccache
|
|
ccache=0
|
|
|
|
# Override preservebuilddir and preservepackagedir to remove both build and package directories
|
|
preservebuilddir=0
|
|
preservepackagedir=0
|
|
|
|
# Get the directory from the tmpfsdir variable for extracting the source and set it as our build and staging directory
|
|
tmp="$tmpfsdir/$app.src"
|
|
pkg="${pkg:-$tmpfsdir/package-$app}"
|
|
|
|
fi
|
|
else
|
|
# If usetmpfs is disabled, we compile in the non-TMPFS directory
|
|
tmp="$nontmpfsdir/$app.src"
|
|
pkg=${pkg:-$nontmpfsdir/package-$app}
|
|
fi
|
|
|
|
# Validate and export $cputhreads as MAKEFLAGS variable
|
|
if [ -n "$cputhreads" ]; then
|
|
# export the user-defined number
|
|
MAKEFLAGS="$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 globaldistcc is set
|
|
if [ "$globaldistcc" = "1" ] ; then
|
|
# Check if distcc exists and is an executable
|
|
if [ ! -x "$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 bldpkg.conf file."
|
|
exit 1
|
|
fi
|
|
|
|
# Check if the symlinks are right
|
|
if [ ! "$(echo "$PATH" | grep "$distccsympath")" ] ; then
|
|
echo "[ERROR] $distccsympath not found in "'$PATH'"! Fix it please."
|
|
exit 1
|
|
elif [ ! -d "$distccsympath" ] ; then
|
|
echo "[ERROR] $distccsympath directory containing symlinks to distcc"
|
|
echo "[ERROR] does not exist! Kindly create it and create symlinks"
|
|
echo "[ERROR] based on instructions in bldpkg.conf!"
|
|
exit 1
|
|
fi
|
|
|
|
# Trace symlinks to the binary
|
|
for f in gcc g++ cc c++ ; do
|
|
if [ -e "$distccsympath/$f" ] && [ -L "$distccsympath/$f" ]; then
|
|
# We use "realpath" to follow the $distccsympath/$f symlink and act on the exit code.
|
|
if [ "$(realpath -e "$distccsympath/$f")" != "$distccbinpath" ] ; then
|
|
echo "[ERROR] $distccsympath/$f does not point to $distccbinpath. "
|
|
echo "[ERROR] Kindly fix this!"
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "[ERROR] $f either does not exist or is not a symlink inside"
|
|
echo "[ERROR] $distccsympath. Kindly fix this! "
|
|
exit 1
|
|
fi
|
|
|
|
#echo -n "Validating distcc $f compiler... "
|
|
|
|
# This is a really small C program taken from autoconf tests
|
|
#cat << EOF > $parenttmp/distcccheck-"$f".c
|
|
#int
|
|
#main()
|
|
#{
|
|
# ;
|
|
# return 0;
|
|
#}
|
|
#EOF
|
|
|
|
#"$distccsympath/$f" -o $parenttmp/distcccheck-"$f" $parenttmp/distcccheck-"$f".c
|
|
#checkstatus="$?"
|
|
|
|
# Discard the files once the validation passes/fails
|
|
#if [ "$checkstatus" = "0" ] ; then
|
|
# echo "[OK]"
|
|
# rm $parenttmp/distcccheck-"$f"{,.c}
|
|
#else
|
|
# echo "Something's up with distcc $f"
|
|
# rm $parenttmp/distcccheck-"$f"{,.c}
|
|
# exit 1
|
|
#fi
|
|
|
|
done
|
|
|
|
# If distcc=0 is set in the package build file to disable distcc, remove the value of $distccsympath from
|
|
# $PATH otherwise export DISTCC_HOSTS and DISTCC_IO_TIMEOUT variables.
|
|
if [ "$distcc" = "0" ] ; then
|
|
PATH="$(echo "$PATH" | sed "s@:$distccsympath@@g")"
|
|
export PATH
|
|
else
|
|
export DISTCC_HOSTS DISTCC_IO_TIMEOUT
|
|
fi
|
|
else
|
|
# Remove $distccsympath
|
|
PATH="$(echo "$PATH" | sed "s@:$distccsympath@@g")"
|
|
export PATH
|
|
fi
|
|
|
|
# Validate everything related to ccache if globalccache is set
|
|
if [ "$globalccache" = "1" ]; then
|
|
if [ ! -x "$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 bldpkg.conf."
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! "$(echo $PATH | grep "$ccachesympath")" ] ; then
|
|
echo "[ERROR] $ccachesympath not found in "'$PATH!'" Fix it please."
|
|
exit 1
|
|
elif [ ! -d "$ccachesympath" ] ; then
|
|
echo "[ERROR] $ccachesympath directory containing symlinks to ccache"
|
|
echo "[ERROR] does not exist! Kindly create it and create symlinks"
|
|
echo "[ERROR] based on instructions in bldpkg.conf."
|
|
exit 1
|
|
fi
|
|
|
|
for f in gcc g++ cc c++ ; do
|
|
if [ -e "$ccachesympath/$f" ] && [ -L "$ccachesympath/$f" ]; then
|
|
# We use "realpath" to follow the $ccachesympath/$f symlink and act on the exit code
|
|
if [ "$(realpath -e "$ccachesympath/$f")" != "$ccachebinpath" ] ; then
|
|
echo "[ERROR] $ccachesympath/$f does not point to $ccachebinpath. "
|
|
echo "[ERROR] Kindly fix this!"
|
|
exit 1
|
|
fi
|
|
else
|
|
echo "[ERROR] $f either does not exist or is not a symlink inside $ccachesympath"
|
|
echo "[ERROR] Kindly fix this!"
|
|
exit 1
|
|
fi
|
|
|
|
#echo -n "Validating ccache $f compiler... "
|
|
|
|
# This is a really small C program taken from autoconf tests
|
|
#cat << EOF > $parenttmp/ccachecheck-"$f".c
|
|
#int
|
|
#main()
|
|
#{
|
|
# ;
|
|
# return 0;
|
|
#}
|
|
#EOF
|
|
|
|
#"$ccachesympath/$f" -o $parenttmp/ccachecheck-"$f" $parenttmp/ccachecheck-"$f".c
|
|
#checkstatus="$?"
|
|
|
|
# Discard the files once the validation passes/fails
|
|
#if [ "$checkstatus" = "0" ] ; then
|
|
# echo "[OK]"
|
|
# rm $parenttmp/ccachecheck-"$f"{,.c}
|
|
#else
|
|
# echo "Something's up with ccache $f"
|
|
# rm $parenttmp/ccachecheck-"$f"{,.c}
|
|
# exit 1
|
|
#fi
|
|
|
|
done
|
|
|
|
# If ccache=0 is set in the package build file to disable ccache, remove the value of ccachesympath
|
|
# from $PATH and export it again
|
|
if [ "$ccache" = "0" ]; then
|
|
PATH="$(echo "$PATH" | sed "s@$ccachesympath:@@g")"
|
|
export PATH
|
|
fi
|
|
else
|
|
# Remove $ccachesympath
|
|
PATH="$(echo "$PATH" | sed "s@$ccachesympath:@@g")"
|
|
export PATH
|
|
fi
|
|
|
|
# Validate everything related to sccache if globalccache is set
|
|
if [ "$globalsccache" = "1" ]; then
|
|
if [ ! -x "$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 bldpkg.conf."
|
|
exit 1
|
|
fi
|
|
|
|
if [ ! "$(echo "$PATH" | grep "$sccachepath")" ] ; then
|
|
echo "[ERROR] $sccachepath not found in "'$PATH!'" Fix it please."
|
|
exit 1
|
|
elif [ ! -d "$sccachepath" ] ; then
|
|
echo "[ERROR] $sccachepath directory containing symlinks to ccache"
|
|
echo "[ERROR] does not exist! Kindly create it and create symlinks"
|
|
echo "[ERROR] based on instructions in bldpkg.conf."
|
|
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
|
|
sccache_binary_inode_num="$(stat --printf '%i\n' $sccachebinpath)"
|
|
# Then get the inode number of the file inside the hard link path
|
|
sccache_hardlink_file_inode_num="$(stat --printf '%i\n' $sccachepath/$f)"
|
|
|
|
if [ ! -e "$sccachepath/$f" ] ; then
|
|
echo "[ERROR] $f either does not exist inside $sccachepath"
|
|
echo "[ERROR] Kindly fix this!"
|
|
exit 1
|
|
# If the hard link's inode number does not match the original binary's inode number, throw an error and exit
|
|
elif [ "$sccache_hardlink_file_inode_num" != "$sccache_binary_inode_num" ] ; then
|
|
echo "[ERROR] File '"$f"' inside $sccachepath is not a hard link!"
|
|
echo "[ERROR] Kindly fix this!"
|
|
exit 1
|
|
fi
|
|
|
|
#echo -n "Validating sccache $f compiler... "
|
|
|
|
# This is a really small C program taken from autoconf tests
|
|
#cat << EOF > $parenttmp/sccachecheck-"$f".c
|
|
#int
|
|
#main()
|
|
#{
|
|
# ;
|
|
# return 0;
|
|
#}
|
|
#EOF
|
|
|
|
#"$sccachepath/$f" -o $parenttmp/sccachecheck-"$f" $parenttmp/sccachecheck-"$f".c
|
|
#checkstatus="$?"
|
|
|
|
# Discard the files once the validation passes/fails
|
|
#if [ "$checkstatus" = "0" ] ; then
|
|
# echo "[OK]"
|
|
# rm $parenttmp/sccachecheck-"$f"{,.c}
|
|
#else
|
|
# echo "Something's up with sccache $f"
|
|
# rm $parenttmp/sccachecheck-"$f"{,.c}
|
|
# exit 1
|
|
#fi
|
|
|
|
# Useful for rust-specific builds.
|
|
RUSTC_WRAPPER="$sccachebinpath"
|
|
export RUSTC_WRAPPER
|
|
|
|
done
|
|
|
|
# If sccache=0 is set in the package build file to disable sccache, remove the value of sccachepath
|
|
# from $PATH and export it again
|
|
if [ "$sccache" = "0" ]; then
|
|
PATH="$(echo "$PATH" | sed "s@$sccachepath:@@g")"
|
|
export PATH
|
|
fi
|
|
else
|
|
# Remove $sccachepath
|
|
PATH="$(echo "$PATH" | sed "s@$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="$aarch64hostdist"
|
|
builddist="$aarch64builddist"
|
|
|
|
if [ -n "$debug" ]; then
|
|
CFLAGS="$(echo $gccdebug $aarch64cflags)"
|
|
else
|
|
CFLAGS="$aarch64cflags"
|
|
fi
|
|
|
|
CXXFLAGS="$CFLAGS"
|
|
export hostdist builddist CFLAGS CXXFLAGS
|
|
|
|
elif [ "$arch" = "x86_64" ]; then
|
|
builddist="$x8664builddist"
|
|
|
|
if [ -n "$debug" ]; then
|
|
CFLAGS="$(echo $gccdebug $x8664cflags)"
|
|
else
|
|
CFLAGS="$x8664cflags"
|
|
fi
|
|
|
|
CXXFLAGS="$CFLAGS"
|
|
export builddist CFLAGS CXXFLAGS
|
|
|
|
else
|
|
echo "[ERROR] Sorry! '$arch' CPU architecture not supported by SMLinux!"
|
|
exit 1
|
|
fi
|
|
|
|
|
|
# If $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 "$noautoconfsite" ] ; then
|
|
if [ -n "$configsite" ] && [ -e "$configsite" ]; then
|
|
CONFIG_SITE="$configsite"
|
|
export CONFIG_SITE
|
|
fi
|
|
fi
|
|
|
|
# Condition to reuse the autobuildtemp file if set from autobuild or make a new temporary file
|
|
if [ -n "$autobuildtemp" ]; then
|
|
tempfile="$autobuildtemp"
|
|
else
|
|
tempfile="$(mktemp $parenttmp/SMBUILD.XXXXXX)"
|
|
fi
|
|
|
|
# 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 bldpkg.conf.
|
|
pkgdocs="$pkg/share/doc/$app-$version"
|
|
# Remove any old $pkg staging directory left by any previous build.
|
|
rm -rf "$pkg"
|
|
|
|
# Now create all essential build-related directories
|
|
mkdir -p "$tmp" "$pkg" "$pkgdocs" "$pkgdest"
|
|
|
|
echo "[INFO] Leaving source directory $srcdir"
|
|
echo "[INFO] Entering build directory $tmp"
|
|
cd "$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."
|
|
}
|
|
|
|
# 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 "[ERROR] $1.run does not exist!"
|
|
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.
|
|
|
|
# compiletimea will store the exact seconds
|
|
compiletimea="$SECONDS"
|
|
|
|
# compiletimeb will run the runtime function against compiletimea and store the resulting output
|
|
compiletimeb="$( runtime $compiletimea )"
|
|
|
|
echo "[INFO] Leaving build directory $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 "[ERROR] $app has /lib64 directory. Musl does not support multilib."
|
|
echo "[ERROR] Please fix the build options and ensure the /lib64 is not created."
|
|
exit 1
|
|
fi
|
|
|
|
# Check if /usr and /sbin were created inside $pkg
|
|
for directory in usr sbin ; do
|
|
if [ -d "$pkg/$directory" ] ; then
|
|
echo "[ERROR] $app has $directory directory which is a symlink to /bin on SMLinux."
|
|
echo "[ERROR] Please fix the build options and ensure $directory is not created."
|
|
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"
|
|
find . -type f -name "*.[0-9]" -o -name "*.[0-9]" | xargs gzip -9
|
|
for eachpage in $( find . -type l -maxdepth 1) ; do
|
|
ln -s "$( readlink "$eachpage" ).gz" "$eachpage".gz
|
|
rm "$eachpage"
|
|
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 f -name "*.la" -delete
|
|
|
|
# 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/$buildfile" "$pkgdocs/$app.SMBuild"
|
|
|
|
# Normally we'd expect some debug symbols in the newly-produced binaries.
|
|
# But that isn't always the case with some packages whose build systems
|
|
# strip objects before hand
|
|
if [ "$debug" = "1" ] ; then
|
|
for file in \
|
|
$( find $pkg )
|
|
do
|
|
file -m /etc/file/magic/elf $file | \
|
|
grep -E "executable|shared object" | \
|
|
grep ", stripped" | cut -d: -f1 >> "$pkg/install/package.$app.debugfailedfilenames"
|
|
done
|
|
|
|
debugfilecount="$(wc -l < "$pkg/install/package.$app.debugfailedfilenames")"
|
|
if [ "$debugfilecount" -ge "1" ]; then
|
|
debugwarning=1
|
|
else
|
|
rm "$pkg/install/package.$app.debugfailedfilenames"
|
|
fi
|
|
fi
|
|
|
|
# Now strip the binaries and shared libraries. --strip-unneeded is unnecessary for binutils 2.34+
|
|
if [ -z "$debug" ] && [ "$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 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 2>/dev/null || true
|
|
|
|
# Calculate total files, directories, symlinks and uncompressed staging directory size
|
|
if [ "$showsummary" = "1" ] ; then
|
|
totalfilecount="$(find $pkg -type f | wc -l)"
|
|
totaldircount="$(find $pkg -type d | wc -l)"
|
|
totalsymcount="$(find $pkg -type l | wc -l)"
|
|
packusize1="$(du -s $pkg | awk '{print $1}')"
|
|
|
|
fi
|
|
# 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
|
|
|
|
# Store package location inside this variable:
|
|
packlocation="$pkgdest/$app-$version-$arch-$build.$pkgext"
|
|
|
|
# Finally create the package
|
|
/bin/makepkg -l y -c n "$packlocation"
|
|
pkgstatus=$?
|
|
|
|
echo "[INFO] Leaving staging directory $pkg"
|
|
|
|
# cd back to $srcdir when 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"
|
|
|
|
|
|
if [ "$showsummary" = "1" ] || [ "$htmloutput" = "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
|
|
packagetimea="$SECONDS"
|
|
packagetimeb="$( runtime $packagetimea )"
|
|
fi
|
|
|
|
|
|
if [ "$showsummary" = "1" ]; then
|
|
# Determine size of SRCDIR aka source directory
|
|
srcdirsize="$(du -s $srcdir | awk '{print $1}')"
|
|
# Determine size of tmp aka build directory size
|
|
builddirsize="$(du -s $tmp | awk '{print $1}')"
|
|
|
|
# Calculate SSD write savings if TMPFS has been used
|
|
if [ "$usetmpfs" = "1" ] && [ "$tmpfsenabledforthispackage" = "1" ] ; then
|
|
|
|
# Determine size of staging directory
|
|
pkgdirsize="$(du -s $pkg | awk '{print $1}')"
|
|
|
|
# Sum total of the above two variables is the amount of writes we saved
|
|
tmpfssavingssum0="$(( $builddirsize + $pkgdirsize ))"
|
|
|
|
# We'll get sum in kB. Convert that to MB.
|
|
tmpfssavingssum1="$(echo "scale=2 ; "$tmpfssavingssum0" / 1024" | bc)"
|
|
|
|
# Store the result for build summary to pickup.
|
|
tmpfssavingsize="$(echo and $tmpfssavingssum1"MB" writes to SSD saved)"
|
|
fi
|
|
fi
|
|
|
|
# Delete the build directory if preservebuilddir is set to 0
|
|
if [ "$preservebuilddir" = "0" ] ; then
|
|
if ! inarray "${tmp}" "${protecteddirectories[@]}" ; then
|
|
rm -rf "$tmp"
|
|
fi
|
|
fi
|
|
|
|
# Delete the package build directory if preservepackagedir is set to 0
|
|
if [ "$preservepackagedir" = "0" ] ; then
|
|
if ! inarray "${pkg}" "${protecteddirectories[@]}" ; then
|
|
rm -rf "$pkg"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
buildfilecleanup() {
|
|
# Discard all temporary files
|
|
rm -f "$parenttmp/BUILDING" "$tempfile"
|
|
}
|
|
|
|
|
|
prepbuildoutput() {
|
|
|
|
# Get the build completion time and store it in a variable
|
|
finishdate="$(date '+%a, %d %b %Y, %T')"
|
|
|
|
# If compiletimea is set, then do a sum total of compiletimea and packagetimea variables to get the
|
|
# total time in seconds and use that as an argument for the runtime function. If compiletimea is not set,
|
|
# invoke the runtime function alone on new reset $SECONDS
|
|
if [ -n "$compiletimea" ] && [ "$pkgstatus" = "0" ] ; then
|
|
finalcompiletime="$(( $compiletimea + $packagetimea ))"
|
|
totaltime="$( runtime $finalcompiletime )"
|
|
else
|
|
totaltime="$( runtime $SECONDS )"
|
|
fi
|
|
|
|
# Start of the showsummary if/else check
|
|
if [ "$showsummary" = "1" ]; then
|
|
|
|
# Stick to 8/16 colours, those are supported on most terminals
|
|
if [ "$colours" = "1" ]; then
|
|
colourscheck="$(tput colors 2>/dev/null)"
|
|
if [ "$?" = "0" ] && [ "$colourscheck" -gt "2" ] ; then
|
|
# Red when the build fails
|
|
colourr="\e[41m"
|
|
# Yellow when the build is interrupted
|
|
coloury="\e[93m"
|
|
# Green when the build succeeds
|
|
colourg="\e[92m"
|
|
# Cyan for the short questions
|
|
colourc="\e[96m"
|
|
# App name/version colours
|
|
colourv="\e[92m"
|
|
# Restore to default
|
|
colourd="\e[0m"
|
|
fi
|
|
fi
|
|
|
|
# Determine the build type
|
|
if [ -n "$autobuild" ]; then
|
|
# We are using Tadgy's autobuild system
|
|
buildsys="SSB Autobuild"
|
|
else
|
|
# We compiled the package manually
|
|
buildsys="Manual"
|
|
fi
|
|
|
|
|
|
# Determine if distcc was used. If globaldistcc is enabled and set to 1 and distcc is not declared in the
|
|
# package build file, then set dstats in the build summary
|
|
if [ "$globaldistcc" = "1" ] && [ -z "$distcc" ]; then
|
|
dstats="Yes"
|
|
# Else if globaldistcc is enabled and set to 1 and distcc is set to 0 in the package build file, then set
|
|
# dstats in the build summary
|
|
elif [ "$globaldistcc" = "1" ] && [ "$distcc" = "0" ]; then
|
|
dstats="Nope, disabled but global variable set"
|
|
# Else If globaldistcc is unset, set dstats in the build summary
|
|
elif [ -z "$globaldistcc" ] || [ "$globaldistcc" = "0" ]; then
|
|
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 cstats accordingly
|
|
# in the build summary
|
|
if [ "$globalccache" = "1" ] && [ "$usetmpfs" = "1" ] && [ "$tmpfsenabledforthispackage" = "1" ] ; then
|
|
cstats="Enabled globally but disabled due to tmpfs"
|
|
|
|
elif [ "$globalccache" = "1" ] && [ -n "$usetmpfs" ] && [ "$usetmpfs" = "0" ] ; then
|
|
cstats="Yes"
|
|
|
|
elif [ "$globalccache" = "1" ] && [ -z "$usetmpfs" ] ; then
|
|
cstats="Yes"
|
|
|
|
elif [ -z "$globalccache" ] || [ "$globalccache" = "0" ] ; then
|
|
cstats="No, disabled globally"
|
|
fi
|
|
|
|
|
|
# Determine the build type
|
|
if [ "$debug" = "1" ] && [ -z "$debugwarning" ] ; then
|
|
bldtype="*DEBUG* build"
|
|
elif [ "$debug" = "1" ] && [ "$debugwarning" = "1" ]; then
|
|
bldtype="*DEBUG* build[WARNING]"
|
|
else
|
|
bldtype="General build, no debug symbols"
|
|
fi
|
|
|
|
|
|
# Determine whether tmpfs was used
|
|
if [ "$usetmpfs" = "1" ] && [ "$tmpfsenabledforthispackage" = "1" ] ; then
|
|
tmpfsstate="Yes"
|
|
|
|
elif [ "$usetmpfs" = "1" ] && [ "$tmpfsenabledforthispackage" = "0" ]; then
|
|
tmpfsstate="*Not for this package* but enabled globally"
|
|
|
|
elif [ "$usetmpfs" = "1" ] && [ "$tmpfscheckfailed" = "1" ]; then
|
|
tmpfsstate="*NOPE, TMPFS DIRECTORY CHECK FAILED* but enabled globally"
|
|
|
|
else
|
|
tmpfsstate="No, disabled globally"
|
|
fi
|
|
|
|
|
|
if [ -n "$cputhreads" ]; then
|
|
makeflags="$MAKEFLAGS, manually set"
|
|
else
|
|
makeflags="$MAKEFLAGS, auto-detected"
|
|
fi
|
|
|
|
# Determine if the build was successful or not
|
|
if [ "$pkgstatus" = "0" ] ; then
|
|
bldstatus="$(echo -e "$colourg"'Successful! :-D' "$colourd")"
|
|
|
|
# Determine the compressed size
|
|
packsize="$(du -bk "$packlocation" | awk '{print $1}')"
|
|
|
|
# Determine the uncompressed size
|
|
packusize="$(echo $packusize1)"
|
|
|
|
elif [ "$wasinterrupted" = "1" ]; then
|
|
bldstatus="$(echo -e "$coloury"'** INTERRUPTED ** :-/'"$colourd")"
|
|
|
|
else
|
|
bldstatus="$(echo -e "$colourr"'!! FAILED !! :-('"$colourd")"
|
|
|
|
fi
|
|
|
|
# Finally prepare the summary
|
|
echo "" >> "$tempfile"
|
|
|
|
echo -e ""$colourc"-------------------------------------------------------------------------------" >> "$tempfile"
|
|
|
|
echo -e " BUILD SUMMARY FOR PACKAGE "$colourd"'"$colourv"\
|
|
"$app""$colourd"'"$colourc" VERSION "$colourd"'"$colourv""$version"'" "$colourc"TAG"$colourv" "'$build'"$colourd"" >> "$tempfile"
|
|
|
|
echo -e ""$colourc"-------------------------------------------------------------------------------"$colourd"" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" Build Status:"$colourd" $bldstatus" >> "$tempfile"
|
|
|
|
|
|
# Output the section name if autobuildtemp is set. This means we are running an autobuild.
|
|
if [ -n "$autobuildtemp" ]; then
|
|
echo -e ""$colourc" Build Section:"$colourd" $SECTION" >> "$tempfile"
|
|
fi
|
|
|
|
|
|
# If we have $compiletimeb set, then assume the compile went well and output compile and packaging times into tempfile.
|
|
if [ -n "$totaltime" ] && [ -z "$packagetimeb" ]; then
|
|
echo -e ""$colourc" Total Time: "$colourd" $totaltime" >> "$tempfile"
|
|
elif [ -n "$totaltime" ] && [ -n "$packagetimeb" ]; then
|
|
echo -e ""$colourc" Total Time: "$colourd" $totaltime ( $compiletimeb Compile ) + ( $packagetimeb Packaging )" >> "$tempfile"
|
|
fi
|
|
|
|
|
|
echo -e ""$colourc" Started:"$colourd" $commencedate" >> "$tempfile"
|
|
echo -e ""$colourc" Stopped:"$colourd" $finishdate" >> "$tempfile"
|
|
|
|
# If the package was built successfully, output the installer sizes
|
|
if [ "$pkgstatus" = "0" ]; then
|
|
|
|
#compressedsize="$(echo $(($packsize * 100 / $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
|
|
compressedsize="$(echo $(echo "scale=2 ; 1 - "$packsize" / "$packusize"" | bc ) | sed 's@.@@')"
|
|
|
|
echo -e ""$colourc" Source Size: "$colourd" Compressed: $srcdirsize"K", Uncompressed: $builddirsize"K"" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" Package Size: "$colourd" Uncompressed: $packusize"K", Compressed: $packsize"K" ("$compressedsize'%'")" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" Package Has: "$colourd" $totalfilecount files and $totalsymcount symlinks in $totaldircount directories" >> "$tempfile"
|
|
|
|
fi
|
|
|
|
|
|
# If ccache was used, output the current cache used size and max allocated size
|
|
if [ "$globalccache" = "1" ] && [ "$ccache" != "0" ] && [ "$cstats" = "Yes" ]; then
|
|
ccacheusedsize="$(ccache -s | grep "cache size" | head -n 1 | \
|
|
awk '{ $1=$2="" ; print $0}')"
|
|
ccachetotalsize="$(ccache -s | grep "max cache size" | \
|
|
awk '{ $1=$2=$3="" ; print $0}')"
|
|
|
|
echo -e ""$colourc" Ccache Used?"$colourd" "$cstats","$ccacheusedsize" /"$ccachetotalsize" Allocated" >> "$tempfile"
|
|
|
|
else
|
|
echo -e ""$colourc" Ccache Used?"$colourd" "$cstats"" >> "$tempfile"
|
|
|
|
fi
|
|
|
|
echo -e ""$colourc" Distcc Used?"$colourd" $dstats" >> "$tempfile"
|
|
|
|
|
|
# If distcc was used, cut out --randomize and output rest of the DISTCC_HOSTS variable
|
|
if [ "$globaldistcc" = "1" ] && [ "$distcc" != "0" ]; then
|
|
echo -e ""$colourc" Distcc Args: "$colourd" $(echo "$DISTCC_HOSTS" | sed 's@--randomize@@')" >> "$tempfile"
|
|
fi
|
|
|
|
|
|
echo -e ""$colourc" TMPFS Used? "$colourd" "$tmpfsstate" $tmpfssavingsize" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" CPU Threads: "$colourd" $(echo $makeflags | sed 's@-j@@')" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" CFLAGS Used: "$colourd" $CFLAGS" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" Compressor: "$colourd" $compressor ($compressopts)" >> "$tempfile"
|
|
|
|
echo -e ""$colourc" Build Type:" $colourd" $buildsys & $bldtype" >> "$tempfile"
|
|
|
|
echo -e ""$colourc"-------------------------------------------------------------------------------"$colourd"" >> "$tempfile"
|
|
|
|
|
|
# Output the build summary to the user on every build
|
|
cat "$tempfile"
|
|
|
|
fi
|
|
# Completion of the showsummary if/else check
|
|
|
|
# Discard temporary files
|
|
buildfilecleanup
|
|
|
|
# Show HTML output if enabled
|
|
prephtmloutput
|
|
|
|
# Prompt user for extracting/installing the package if the build has succeeded
|
|
promptuser
|
|
|
|
}
|
|
|
|
prephtmloutput() {
|
|
if [ "$htmloutput" = "1" ] ; then
|
|
if [ "$pkgstatus" = "0" ] ; then
|
|
cat << EOF >> $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>$commencedate</td><td>$finishdate</td><td>$totaltime</td><td><b style="color:#00cc00;">SUCCEEDED</b></td></tr>
|
|
EOF
|
|
elif [ "$wasinterrupted" = "1" ]; then
|
|
cat << EOF >> $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>$commencedate</td><td>$finishdate</td><td>$totaltime</td><td><b>INTERRUPTED</b></td></tr>
|
|
EOF
|
|
else
|
|
cat << EOF >> $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>$commencedate</td><td>$finishdate</td><td>$totaltime</td><td><b style="color:#ff1a1a;">FAILED</b></td></tr>
|
|
EOF
|
|
fi
|
|
fi
|
|
}
|
|
|
|
promptuser() {
|
|
|
|
# Extract package at the end of a build if autoextract is set to 1
|
|
if [ "$autoextract" = "1" ] && [ -z "$autobuild" ] && [ -n "$packlocation" ] ; then
|
|
echo "[INFO] Extracting package installer inside $srcdir/test..."
|
|
mkdir -p "$srcdir/test"
|
|
tar xvf "$packlocation" -C "$srcdir/test"
|
|
echo ""
|
|
echo "[INFO] '"$app"' package installer file successfully extracted"
|
|
fi
|
|
|
|
# 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 [ "$extractprompt" = "1" ] && [ -z "$autobuild" ] && [ -n "$packlocation" ] ; then
|
|
while true ; do
|
|
echo
|
|
echo "[NOTIFY] '"$app"' has been built and extractprompt is enabled in"
|
|
echo "[NOTIFY] bldpkg.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 "$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 [ "$installprompt" = "1" ] && [ -z "$autobuild" ] && [ -n "$packlocation" ] ; then
|
|
while true ; do
|
|
echo
|
|
echo "[NOTIFY] '"$app"' successfully built and installprompt is enabled in the bldpkg.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 "$packlocation"
|
|
break;;
|
|
*) echo "[INFO] Nope? Alright." ; exit 0 ;;
|
|
esac
|
|
done
|
|
fi
|
|
|
|
if [ "$pkgstatus" = "0" ]; then
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
# This function will set the interrupt variable so prepbuildoutput can output the right build status on receiving
|
|
# ctrl-c from the user during a manual build.
|
|
interruptoutput() {
|
|
echo ""
|
|
echo "[INFO] Caught Keyboard Interrupt"
|
|
wasinterrupted="1"
|
|
# Restore terminal colours
|
|
echo -e "$colourd"
|
|
# If installprompt and extractprompt are set and the prompt is invoked after a successful build, hitting
|
|
# ctrl-C will only set the above sm 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
|
|
|
|
exit 0
|
|
}
|
|
|
|
# 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 'prepbuildoutput' function on any exit
|
|
# status >= 0. The script fail status is determined by the above 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 "prepbuildoutput" EXIT
|
|
trap "interruptoutput" INT
|
|
|
|
build
|
|
|
|
)
|
|
# End subshell and script
|