PktSurf
1cf767e805
-> Moved rqfiles out of bldpkg and into bldpkg.conf in previous commit -> Moved code related to CPU architecture detection near export MAKEFLAGS -> Reintroduced and optimised code to validate a compiler defined as CC and CXX -> Discarded unnecessary if/else condition inside fixbuilddirpermissions function
1416 lines
51 KiB
Bash
1416 lines
51 KiB
Bash
#!/bin/bash
|
|
|
|
# Part of the SMLinux distribution
|
|
# http://git.pktsurf.in/smlinux
|
|
#
|
|
# /bin/bldpkg version 0.1
|
|
# Bash script to build SMLinux-specific packages
|
|
#
|
|
# Copyright (c) 2022-2023 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
|
|
# -> Write code to log build output to a log file inside a particular directory
|
|
# -> Email the user about the outcome of the build?
|
|
# -> Increment warnings as they are issued during the build and show final warning total in the build summary
|
|
|
|
set -e
|
|
|
|
err() {
|
|
printf "**ERROR**\n$@\n"
|
|
exit 1
|
|
}
|
|
|
|
info() {
|
|
printf "[INFO] $@\n"
|
|
}
|
|
|
|
warn() {
|
|
printf "[WARNING]\n$@\n"
|
|
}
|
|
|
|
# Determine whether we are using bash version 4 and later. If not, exit.
|
|
if [[ -z $BASH_VERSINFO ]] ; then
|
|
err "Is this really a GNU bash shell?"
|
|
elif ((BASH_VERSINFO[0] < 4)) ; then
|
|
err "Bldpkg requires a minimum of GNU bash shell version 4 to run"
|
|
fi
|
|
|
|
# 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')
|
|
|
|
# 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 or '$HOME/.bldpkg.conf'
|
|
|
|
If no arguments are provided, this script attempts to first look for
|
|
a build file with a .SMBuild extension that matches the name of
|
|
the parent directory, sources that .SMBuild file and starts the build.
|
|
|
|
For example, if the package source directory is $HOME/smlinux/alsa-lib, this script will
|
|
look and source from alsa-lib.SMBuild and build alsa-lib package
|
|
|
|
# pwd
|
|
/home/user/smlinux/alsa-lib
|
|
|
|
# ls
|
|
alsa-lib.SMBuild
|
|
|
|
# bldpkg
|
|
Building package 'alsa-lib' version '1.x'...
|
|
...build output...
|
|
|
|
Usage:
|
|
|
|
-d Produce a package with debug symbols preserved, i.e., don't strip
|
|
resulting ELF objects. Uses -g3 by default
|
|
|
|
-e Extract the package installer file in the user's PWD if the build
|
|
completes successfully
|
|
|
|
-f <file> Name of an alternate build file to source build variables. Should
|
|
be compatible with standard SMLinux package build file format
|
|
|
|
-g Generate SHA512 checksums of all tarballs and patches in the current
|
|
directory and insert them into the package build file
|
|
|
|
-h Show this help message
|
|
|
|
-j <N> Provide a number of jobs to be run simultaneously
|
|
|
|
-o <file> Copy this file into the package installer rather than the default one
|
|
the build was initiated from. Usually the default one is either
|
|
<app>.SMBuild or the one supplied using -f <file> but in certain
|
|
exceptional cases a different file is required to be copied into the
|
|
package installer. Do note that this file will also undergo validation
|
|
|
|
-r Resume the build by skipping all commands in prepbuilddir and execute
|
|
build() function. Presumes that the package was completely extracted
|
|
in the build directory, and patches, if any, were applied and executes
|
|
stuff inside build().
|
|
|
|
-s Display build summary. A summary is produced whenever a build is either
|
|
interrupted, exits cleanly or aborts due to a build error
|
|
|
|
-v Increase compiler verbosity
|
|
|
|
-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
|
|
}
|
|
|
|
# Then source the configuration file holding all values
|
|
if [[ -f $HOME/.bldpkg.conf ]] ; then
|
|
source "$HOME/.bldpkg.conf"
|
|
elif [[ -f /etc/bldpkg.conf ]] ; then
|
|
source /etc/bldpkg.conf
|
|
else
|
|
err "Bldpkg configuration file '/etc/bldpkg.conf' not found!"
|
|
fi
|
|
|
|
# Error out if globalccache and globalsccache are set in the /etc/bldpkg.conf
|
|
if [[ $globalccache = 1 ]] && [[ $globalsccache = 1 ]] ; then
|
|
err "Please only enable either ccache or sccache in bldpkg.conf at the same time, not both."
|
|
fi
|
|
|
|
# Function to validate the build file.
|
|
validatebldfile() {
|
|
local buildfile
|
|
buildfile="$1"
|
|
|
|
if [[ ! -f $buildfile ]] ; then
|
|
err "No build file to validate from!"
|
|
fi
|
|
|
|
# Validate $app
|
|
if ! grep -E -q '^app=[a-z0-9-]' "$buildfile" ; then
|
|
err "Only lower case, numeric characters and dash allowed in the 'app' variable in the build file."
|
|
|
|
# Validate $version
|
|
elif ! grep -E -q '^version=[a-z0-9.]' "$buildfile" ; then
|
|
err "Only lower case, numeric characters and a period allowed in the 'version' variable in the build file."
|
|
|
|
# Validate $homepage
|
|
elif ! grep -E -q '^homepage="\(https|http||ftp)://' "$buildfile" ; then
|
|
err "Invalid URL in the 'homepage' variable in the build file."
|
|
|
|
# Validate $desc using bash shell's ability to count variable length
|
|
elif [[ ${#desc} -gt 100 ]] ; then
|
|
err "Package description should not exceed 100 characters in the build file."
|
|
|
|
# Check if prepbuilddir() function exists in the build file
|
|
elif ! grep -q '^prepbuilddir() {' "$buildfile" ; then
|
|
err "'prepbuilddir()' function does not exist in your build file."
|
|
|
|
# Check if build() function exists in the build file
|
|
elif ! grep -q '^build() {' "$buildfile" ; then
|
|
err "'build()' function does not exist in your build file."
|
|
fi
|
|
|
|
if grep -q '^download=' "$buildfile" ; then
|
|
if ! grep -q '^download=[*p*://]*' "$buildfile" ; then
|
|
err "Invalid URL in the 'download' variable in the build file."
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# Store the source directory path the build was initiated from
|
|
srcdir="$PWD"
|
|
|
|
# Presume that the build file name will match the name of the parent directory
|
|
# unless otherwise overridden using -f <buildfile>
|
|
buildfile="${srcdir##*/}.SMBuild"
|
|
|
|
# Run a for loop to find compile and build-related files
|
|
for requiredfile in "${rqfiles[@]}"; do
|
|
if [[ ! -x $(type -p "$requiredfile") ]] ; then
|
|
err "Could not find required program '$requiredfile'!"
|
|
fi
|
|
done
|
|
|
|
# While loop for providing handy arguments to users. Some will override bldpkg.conf.
|
|
while getopts ':def:ghj:o:rsvx' option; do
|
|
case "$option" in
|
|
d) debug=1 ;; # Produce a debug build with -g3
|
|
e) extractprompt=0;
|
|
autoextract=1 ;; # Automatically extract the final pkg installer inside user's PWD
|
|
f) setbuildfile="$OPTARG" ;;
|
|
g) genchecksum=1 ;;
|
|
h) help ;;
|
|
j) customcputhreads="$OPTARG" ;;
|
|
o) origbuildfile="$OPTARG" ;;
|
|
r) resumepkgbuild=1 ;;
|
|
s) showsummary=1 ;; # Show build summary at the end of the build irrespective of the build status
|
|
v) getoptscompilerverbosity=1 ;;
|
|
x) set -xv ;; # Invoke bash's -x option for command tracing
|
|
*) help ;;
|
|
esac
|
|
done
|
|
|
|
# Function to error out the build in absence of a build file
|
|
nopackagebuildfileerror() {
|
|
err "No package build file to source from!
|
|
Was expecting '$buildfile' to be present inside this directory '$PWD'.
|
|
Try -f <build_file> if your build file has a different name (Not recommended)"
|
|
}
|
|
|
|
# The getopts builtin sets the OPTIND environment variable whose value is set to 1 if no argument
|
|
# is given. For every argument passed, the number is incremented by 1. In our case, if OPTIND equals
|
|
# 1, no argument was passed. We therefore expect a package build file to be present which will be then sourced.
|
|
if [[ $OPTIND = 1 ]] ; then
|
|
if [[ ! -f $buildfile ]] ; then
|
|
nopackagebuildfileerror
|
|
elif ! validatebldfile "$buildfile" ; then
|
|
err "'$buildfile' build file validation failed!"
|
|
else
|
|
source "$buildfile"
|
|
fi
|
|
|
|
# If OPTIND is greater than 1, perform various checks and actions
|
|
elif [[ $OPTIND -gt 1 ]] ; then
|
|
|
|
# Override cputhreads sourced from bldpkg.conf if customcputhreads is set. Need to append '-j' so that it gets
|
|
# passed on to MAKEFLAGS
|
|
if [[ -n $customcputhreads ]] ; then
|
|
# And validate whether the value is a number
|
|
if ! echo "$customcputhreads" | grep -E -q '^[0-9]+$' ; then
|
|
err "Invalid CPU job number '$customcputhreads'. Please provide a valid number."
|
|
fi
|
|
|
|
# Reset $customcputhreads as $cputhreads
|
|
cputhreads="-j$customcputhreads"
|
|
fi
|
|
|
|
# If $origbuildfile is set and is a file, check if $setbuildfile and $origbuildfile are the same
|
|
if [[ -n $origbuildfile ]] ; then
|
|
if [[ ! -f $origbuildfile ]] ; then
|
|
err "Original build file '$origbuildfile' does not exist!"
|
|
|
|
elif [[ -n $setbuildfile ]] && [[ -f $setbuildfile ]] ; then
|
|
if [[ $origbuildfile = $setbuildfile ]] ; then
|
|
err "Original build file and alternate build file are the same!"
|
|
fi
|
|
|
|
elif ! validatebldfile "$origbuildfile" ; then
|
|
err "Alternative build file validation failed!"
|
|
fi
|
|
fi
|
|
|
|
# If $setbuildfile is set and is a file, set buildfile to its value, source it and initialise the build
|
|
if [[ -n $setbuildfile ]] && [[ -f $setbuildfile ]] ; then
|
|
buildfile="$setbuildfile"
|
|
if ! validatebldfile "$buildfile" ; then
|
|
err "'$buildfile' validation failed!"
|
|
else
|
|
source "$buildfile"
|
|
fi
|
|
|
|
# If $setbuildfile is set but a file passed as an argument is not found, give an error
|
|
elif [[ -n $setbuildfile ]] && [[ ! -f $setbuildfile ]] ; then
|
|
err "Build file '$setbuildfile' not found!"
|
|
|
|
# If the above two conditions don't meet, get the presumed $buildfile value as a file and source it
|
|
elif [[ -f $buildfile ]] ; then
|
|
if ! validatebldfile "$buildfile" ; then
|
|
err "'$buildfile' validation failed!"
|
|
else
|
|
source "$buildfile"
|
|
fi
|
|
|
|
# If even that file is not found, throw an error and exit
|
|
else
|
|
nopackagebuildfileerror
|
|
fi
|
|
fi
|
|
|
|
# Unset OPTIND and OPTARG to avoid problems if getopts is used again in the future
|
|
unset OPTIND OPTARG
|
|
|
|
# Generate and insert sha512sums into the build file
|
|
if [[ $genchecksum = 1 ]] ; then
|
|
|
|
# File types whose checksums will go into the new build file
|
|
info "Discarding any old sha512sums from '$buildfile'"
|
|
sed -E -i \
|
|
-e '/^sha512sums=".*"$/d' \
|
|
-e '/^sha512sums="/,/"$/d' \
|
|
-e "/^sha512sums='.*'\$/d" \
|
|
"$buildfile"
|
|
|
|
info "Adding new sha512sums in '$buildfile'"
|
|
printf 'sha512sums="\n' >> "$buildfile"
|
|
|
|
files=( *.tar.* *.zip *.t?z *.patch *.diff *.c *.h )
|
|
|
|
# For loop that searches for files matching the above extension and prints them to the bottom of the build file
|
|
for file in "${files[@]}" ; do
|
|
if [[ -f $file ]] ; then
|
|
sha512sum "$file" >> "$buildfile"
|
|
fi
|
|
done
|
|
|
|
printf '"' >> "$buildfile"
|
|
|
|
if [[ $(find . -type d -maxdepth 1 -print0 | wc -l) -ge 1 ]]; then
|
|
warn "SHA512 checksums not generated for files inside directories!"
|
|
fi
|
|
|
|
info "You may now run 'bldpkg' again"
|
|
exit 0
|
|
fi
|
|
|
|
# Display the package and its version we are building or resuming
|
|
if [[ -z $resumepkgbuild ]] ; then
|
|
info "Building package '$app' version '$version' ..."
|
|
sleep 0.5
|
|
else
|
|
info "Resuming build of package '$app' version '$version' ..."
|
|
fi
|
|
|
|
# Check integrity of files defined in sha512sums variable which is expected
|
|
# in nearly every single package build file
|
|
if [[ -z $sha512sums ]] ; then
|
|
err "SHA512 checksums don't exist in '$buildfile'! Please run 'bldpkg -g' to add them"
|
|
fi
|
|
|
|
eval sums=\"\$sha512sums\"
|
|
|
|
info "Verifying SHA512 checksums against source files..."
|
|
|
|
IFS=$'\n'
|
|
|
|
for src in $sums; do
|
|
if ! echo $src | sha512sum -c ; then
|
|
err "Checksums failed to match!"
|
|
fi
|
|
done
|
|
|
|
unset IFS
|
|
|
|
# Function for applying patches to the build in a more efficient manner
|
|
applypatch() {
|
|
# Take patch file name as the first argument
|
|
patchfile="$1"
|
|
|
|
# Perform a simple check
|
|
if [[ -z $patchfile ]] ; then
|
|
err "Please provide valid patch file name"
|
|
elif [[ ! -f $patchfile ]] ; then
|
|
err "Patch file '$patchfile' not found inside $srcdir!"
|
|
fi
|
|
|
|
# Get relative path of the patch file
|
|
relativepath=${patchfile##*/}
|
|
info "Applying patch '$relativepath'.."
|
|
# We use if/else to determine if the patch applied successfully
|
|
if ! patch -p1 < "$patchfile" ; then
|
|
err "Failed to apply patch file '$patchfile'"
|
|
fi
|
|
}
|
|
|
|
# Do a preliminary package dependency check if $checkdependencies is set to 1 in bldpkg.conf
|
|
if [[ $checkdependencies = 1 ]] ; then
|
|
|
|
info "Parsing $app 's dependency list..."
|
|
for packagedep in $requires; do
|
|
depcount=$(find /share/doc -type f -name "$packagedep.SMBuild" | wc -l)
|
|
# If count is 1, we are ok
|
|
if [[ $depcount = 1 ]] ; then
|
|
info "Found dependency '$packagedep'"
|
|
# If count is 0, we exit, because we are in trouble
|
|
elif [[ $depcount = 0 ]] ; then
|
|
err "Did not find dependency '$packagedep'"
|
|
# If count is greater than or equal to 2, we are in slightly less trouble
|
|
elif [[ $depcount -ge 2 ]] ; then
|
|
warn "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
|
|
err "parenttmp variable not set in bldpkg.conf."
|
|
elif [[ ! -d $parenttmp ]] ; then
|
|
err "parenttmp variable set to '$parenttmp' in bldpkg.conf is not a directory."
|
|
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
|
|
err "Parent temp directory '$parenttmp' is not writable!"
|
|
else
|
|
# Discard the test file
|
|
rm "$parenttmp/.smlinuxwritetest"
|
|
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
|
|
err "'$pkgext' is not a valid pkg extension for an SMLinux installer file"
|
|
fi
|
|
|
|
# Figure out the compression tool to be used based on the $pkgext variable set in bldpkg.conf.
|
|
case "$pkgext" in
|
|
tgz) if [[ -x /bin/pigz ]] ; then
|
|
compressor=pigz
|
|
else
|
|
compressor=gzip
|
|
fi
|
|
compressopts="$gzipopts" ;;
|
|
|
|
tbz) compressor=bzip2
|
|
compressopts="$bzipopts" ;;
|
|
|
|
tlz) if [[ -x /bin/plzip ]] ; then
|
|
compressor=plzip
|
|
else
|
|
compressor=lzip
|
|
fi
|
|
compressopts="$lzipopts" ;;
|
|
|
|
txz) compressor=xz
|
|
compressopts="$xzopts" ;;
|
|
esac
|
|
|
|
# Borrowed from slackware's installpkg utility
|
|
if ! "$compressor" --help > /dev/null 2>&1 ; then
|
|
err "'$compressor' Compressor validation failed."
|
|
fi
|
|
|
|
# Validate the TMPFS directory if usetmpfs is set to 1 and tmpfsdir variable is set. 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
|
|
|
|
# Discard the file used to test the tmp directory
|
|
[[ -e "$tmpfsdir/.smlinuxtmpwritetest" ]] && rm "$tmpfsdir/.smlinuxtmpwritetest"
|
|
|
|
# Check the tmpfsdir for stale directories from previous builds. If found, issue a warning.
|
|
if [[ $(find "$tmpfsdir" -type d -maxdepth 1 -name "*.src" -o -name "package-*" | wc -l) -gt 0 ]]; then
|
|
if [[ ! -d $tmpfsdir/package-$app ]] || [[ ! -d $tmpfsdir/$app.src ]] ; then
|
|
warn "TMPFS directory '$tmpfsdir' has stale directories from previous builds!"
|
|
fi
|
|
fi
|
|
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 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
|
|
err "Insufficient swap to build '$app' which is listed in '$packagesrequiringswap'.
|
|
Kindly add/increase swap size on this system and try again."
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
# Set the build and package staging directories. 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 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="$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 staging 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="$tmpfsdir/package-$app"
|
|
|
|
fi
|
|
else
|
|
# If usetmpfs is disabled, we compile in the non-TMPFS directory
|
|
tmp="$nontmpfsdir/$app.src"
|
|
pkg="$nontmpfsdir/package-$app"
|
|
fi
|
|
|
|
if inarray "${pkg}" "${protecteddirectories[@]}" ; then
|
|
echo "############ ATTENTION ############"
|
|
err "'pkg' VARIABLE IS SET TO '$pkg' WHICH IS A PROTECTED DIRECTORY! EXITING!"
|
|
fi
|
|
|
|
# Also check tmp directory in advance
|
|
if inarray "${tmp}" "${protecteddirectories[@]}" ; then
|
|
echo "############ ATTENTION ############"
|
|
err "'tmp' VARIABLE IS SET TO '$tmp' WHICH IS A PROTECTED DIRECTORY! EXITING!"
|
|
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
|
|
|
|
# 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"
|
|
|
|
# Validate declared compiler variables
|
|
if [[ -z $CC ]] || [[ -z $CXX ]] ; then
|
|
err "CC / CXX variables not set in bldpkg.conf!"
|
|
else
|
|
export CC CXX
|
|
fi
|
|
|
|
if [[ $arch = noarch ]]; then
|
|
CFLAGS=""
|
|
export CFLAGS
|
|
|
|
elif [[ $arch = aarch64 ]]; then
|
|
hostdist="$aarch64hostdist"
|
|
builddist="$aarch64builddist"
|
|
|
|
if [[ -n $debug ]]; then
|
|
CFLAGS="$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="$gccdebug $x8664cflags"
|
|
else
|
|
CFLAGS="$x8664cflags"
|
|
fi
|
|
|
|
CXXFLAGS="$CFLAGS"
|
|
export builddist CFLAGS CXXFLAGS
|
|
|
|
else
|
|
err "Sorry! '$arch' CPU architecture not supported by SMLinux!"
|
|
fi
|
|
|
|
# Inside a function, validate the compilers that have been set as CC and CXX in bldpkg.conf
|
|
# A small C/CXX program is being used to print a random number
|
|
|
|
# Generate a random number using shuf. We'll output this same number inside the C/CXX program.
|
|
# If the numbers match, the compiler looks sane, else error out.
|
|
randomnum="$(shuf -i 100-9999 -n1)"
|
|
|
|
# Function to validate compilers.
|
|
# Usage: compilertestfile "$CC" "$CFLAGS" cc-test.c cc-test
|
|
compilertestfile() {
|
|
compileraddonflags="-O0 -Werror -static"
|
|
compiler="$1"
|
|
compilerflags="$2"
|
|
compilerfile="$3"
|
|
compileroutput="$4"
|
|
|
|
printf "[INFO] Validating '$compiler'... "
|
|
|
|
cat << EOF > "$parenttmp/$compilerfile"
|
|
#include <stdio.h>
|
|
int main() { printf("$randomnum\n"); }
|
|
EOF
|
|
|
|
$compiler $compilerflags -o "$parenttmp/$compileroutput" $compileraddonflags "$parenttmp/$compilerfile"
|
|
finaloutput="$($parenttmp/$compileroutput)"
|
|
|
|
# Error out if the outputs don't match
|
|
if [[ $finaloutput != $randomnum ]] ;then
|
|
err "Compiler validation failed!"
|
|
else
|
|
rm "$parenttmp/$compileroutput"*
|
|
printf " done\n"
|
|
fi
|
|
}
|
|
|
|
# Quotes are important while passing C/CXXFLAGS
|
|
compilertestfile "$CC" "$CFLAGS" cc-test.c cc-test
|
|
compilertestfile "$CXX" "$CXXFLAGS" cxx-test.cpp cxx-test
|
|
|
|
# Function to validate symlinks.
|
|
# Usage: checkcompilersymlink symlink symlink_target
|
|
checkcompilersymlink() {
|
|
symlinkdir="$1"
|
|
symlinktgt="$2"
|
|
|
|
for compiler in gcc g++ cc c++ ; do
|
|
if [[ -e $symlinkdir/$compiler ]] && [[ -L $symlinkdir/$compiler ]]; then
|
|
# We use "realpath" to follow the $ccachesympath/$f symlink and act on the exit code
|
|
if [[ $(realpath -e $symlinkdir/$compiler) != $symlinktgt ]] ; then
|
|
err "'$symlinkdir/$compiler' does not point to '$symlinktgt'. Kindly fix this!"
|
|
fi
|
|
else
|
|
err "Symlink '$compiler' either does not exist or is not a symlink inside '$symlinkdir'! Kindly fix this!"
|
|
fi
|
|
done
|
|
}
|
|
|
|
# Validate everything related to ccache if globalccache is set
|
|
if [[ $globalccache = 1 ]]; then
|
|
if [[ ! -x $ccachebinpath ]] ; then
|
|
err "Ccache binary was not found globalccache is enabled in bldpkg.conf!"
|
|
fi
|
|
|
|
checkcompilersymlink $ccachesymdirpath $ccachebinpath
|
|
|
|
# Prepare $PATH and export it only if ccache is unset in the pkg build file
|
|
if [[ -z $ccache ]] ; then
|
|
PATH="$ccachesymdirpath:$PATH"
|
|
export PATH
|
|
fi
|
|
fi
|
|
|
|
# Validate everything related to sccache if globalccache is set
|
|
if [[ $globalsccache = 1 ]]; then
|
|
|
|
if [[ ! -x $sccachebinpath ]] ; then
|
|
err "Oops! sccache binary was not found but building with it was requested!
|
|
Either ensure sccache is in your '$PATH' or disable this option in bldpkg.conf."
|
|
fi
|
|
|
|
# We expect the rustc wrapper to be defined in $HOME/.cargo/config.toml
|
|
if ! grep -q 'rustc-wrapper\ \= "\/bin\/sccache"' $HOME/.cargo/config.toml ; then
|
|
err 'sccache is not defined as a rustc wrapper!
|
|
Please add the following to your '"$HOME/"'.cargo/config.toml:
|
|
[build]
|
|
rustc-wrapper = "/bin/sccache"'
|
|
fi
|
|
|
|
# Useful for rust-specific builds.
|
|
RUSTC_WRAPPER="$sccachebinpath"
|
|
export RUSTC_WRAPPER
|
|
|
|
# Check whether sccache is running on TCP port 4226 via nc
|
|
if ! nc -z -w 1 localhost 4226 > /dev/null 2>&1 ; then
|
|
/bin/sccache --start-server
|
|
fi
|
|
fi
|
|
|
|
# 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
|
|
err "Distcc binary was not found but globaldistcc is enabled in bldpkg.conf"
|
|
fi
|
|
|
|
checkcompilersymlink $distccsymdirpath $distccbinpath
|
|
|
|
# Prepare $PATH and export DISTCC_HOSTS and DISTCC_IO_TIMEOUT only if distcc is unset in the pkg build file
|
|
if [[ -z $distcc ]] ; then
|
|
# netcat hosts inside $DISTCC_HOSTS by checking for an open port
|
|
info "Validating distcc hosts..."
|
|
# Check if we have nc
|
|
if [[ ! -x /bin/nc ]] ; then
|
|
warn "nc does not exist! Ignoring this..."
|
|
else
|
|
# Remove the common options along with the slash and the numbers after it
|
|
hosts=$(echo "$DISTCC_HOSTS" | sed -e 's@/[a-z0-9,]*@@g' -e 's@--randomize@@' -e 's@localhost@@')
|
|
for host in ${hosts[@]} ; do
|
|
# We only run distccd on TCP port 3632
|
|
if ! /bin/nc -z -w 1 "$host" 3632 > /dev/null 2>&1 ; then
|
|
warn "Distcc host '$host' is OFFLINE! Rewriting DISTCC_HOSTS"
|
|
DISTCC_HOSTS=$(echo "$DISTCC_HOSTS" | sed "s@$host/[a-z0-9,]*@@")
|
|
fi
|
|
done
|
|
fi
|
|
|
|
PATH="$distccsymdirpath:$PATH"
|
|
export DISTCC_HOSTS DISTCC_IO_TIMEOUT PATH
|
|
fi
|
|
fi
|
|
|
|
# If compilerverbosity is set in bldpkg.conf or if verbosity is set to 1 from getopts, set V and
|
|
# VERBOSE environment variables for make and cmake build systems to pick up.
|
|
if [[ $compilerverbosity = 1 ]] || [[ $getoptscompilerverbosity = 1 ]] ; then
|
|
V=1
|
|
VERBOSE=1
|
|
export V VERBOSE
|
|
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 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() {
|
|
|
|
# Define $pkgdocs. Rest is defined in bldpkg.conf.
|
|
pkgdocs="$pkg/share/doc/$app-$version"
|
|
|
|
# Remove any old pkg staging directory left by any previous build having same application name
|
|
rm -rf "$pkg"
|
|
|
|
# Now create all essential build-related directories
|
|
mkdir -p "$tmp" "$pkg/install" "$pkgdocs" "$pkgdest"
|
|
|
|
info "Leaving source directory $srcdir"
|
|
info "Entering build directory $tmp"
|
|
cd "$tmp"
|
|
}
|
|
|
|
# Function to fix permissions inside the build directory
|
|
# To be invoked inside a package build file.
|
|
fixbuilddirpermissions() {
|
|
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
|
|
|
|
# Place an extraction.complete file so that we know at which point to resume our build
|
|
touch ".$app-$version.extraction.complete"
|
|
}
|
|
|
|
# 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() {
|
|
timer="$1"
|
|
[[ -z $timer ]] && return 1
|
|
|
|
local day=$(( timer / 86400 ))
|
|
local hour=$(( (timer - (day * 86400)) / 3600 ))
|
|
local mins=$(( (timer - (day * 86400) - (hour * 3600)) / 60 ))
|
|
local secs=$(( timer - (day * 86400) - (hour * 3600) - (mins * 60) ))
|
|
|
|
if [[ $day -gt 0 ]]; then
|
|
echo -n "${day}d, ${hour}h ${mins}m ${secs}s"
|
|
else
|
|
echo -n "${hour}h, ${mins}m ${secs}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
|
|
err "Runit service file '$1.run' does not exist!"
|
|
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 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 mkfinalpkg 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)
|
|
|
|
info "Leaving build directory $tmp"
|
|
info "Entering staging directory $pkg"
|
|
cd "$pkg"
|
|
info "Performing packaging tasks..."
|
|
|
|
# Check if /lib64 was created inside $pkg
|
|
if [[ -d $pkg/lib64 ]] ; then
|
|
err "'$app' has /lib64 directory within the staging directory. Musl does not support multilib.
|
|
Please fix the build options and ensure the /lib64 is not created."
|
|
fi
|
|
|
|
# Check if /usr and /sbin were created inside staging directory $pkg
|
|
# of its build file. Ignore their existence if $ignoreusr is set to 1 in the pkg build file
|
|
if [[ -z $ignoreusr ]] ; then
|
|
for directory in usr sbin ; do
|
|
if [[ -d $pkg/$directory ]] ; then
|
|
err "'$app' has '$directory' directory within the staging directory which is a symlink to /bin on SMLinux.
|
|
Please fix the build options and ensure '$directory' is not created"
|
|
fi
|
|
done
|
|
fi
|
|
|
|
info "Copying post-install files..."
|
|
|
|
[[ -e $srcdir/doinst.sh ]] && cp "$srcdir/doinst.sh" "$pkg/install/"
|
|
|
|
# If /share/applications directory exists but there is no doinst.sh in the source directory, create one using cat
|
|
if [[ -d $pkg/share/applications ]] && [[ ! -e $srcdir/doinst.sh ]] ; then
|
|
info "Found /share/applications but couldn't find any doinst.sh in the source directory.
|
|
Creating one automatically that refreshes GTK cache."
|
|
cat << EOF >> "$pkg/install/doinst.sh"
|
|
[[ -x /etc/rc.d/rc.gtk ]] && /etc/rc.d/rc.gtk
|
|
EOF
|
|
|
|
# Or if /share/applications directory exists, and there is a doinst.sh file in the source directory, but there is no mention of rc.gtk, then too create one using cat
|
|
elif [[ -d $pkg/share/applications ]] && [[ -e $srcdir/doinst.sh ]] && ! grep -q 'rc.gtk' "$srcdir/doinst.sh" ; then
|
|
info "Found /share/applications but couldn't find any rc.gtk lines inside doinst.sh in the source directory.
|
|
Creating one automatically that refreshes GTK cache."
|
|
cat << EOF >> "$pkg/install/doinst.sh"
|
|
[[ -x /etc/rc.d/rc.gtk ]] && /etc/rc.d/rc.gtk
|
|
EOF
|
|
fi
|
|
|
|
# Compress and link manpages
|
|
if [[ -d $pkg/share/man ]]; then
|
|
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 libtool archive files
|
|
info "Discarding any libtool archive (.la) files..."
|
|
find "$pkg" -type f -name "*.la" -exec rm -v {} \;
|
|
|
|
# Provide a copy of the package build file as a source of reference for users
|
|
if [[ -n $origbuildfile ]] && [[ -f $srcdir/$origbuildfile ]] ; then
|
|
install -Dm 644 "$srcdir/$origbuildfile" "$pkgdocs/$app.SMBuild"
|
|
else
|
|
install -Dm 644 "$srcdir/$buildfile" "$pkgdocs/$app.SMBuild"
|
|
fi
|
|
|
|
# Now strip the binaries and shared libraries. --strip-unneeded is unnecessary for binutils 2.34+
|
|
if [[ -z $debug ]] && [[ $debug != 1 ]]; then
|
|
find "$pkg" -type f -print0 | xargs -0 file -m /etc/file/magic/elf | \
|
|
grep -E "ELF.*(executable|shared object|statically linked)" |\
|
|
cut -d: -f1 | xargs strip 2>/dev/null || true
|
|
fi
|
|
|
|
# If $preservestaticlibs is not set in the package build file, delete all static libraries
|
|
if [[ -z $preservestaticlibs ]] ; then
|
|
info "Discarding any static libraries..."
|
|
find "$pkg" -type f -print0 | xargs -0 file -m /etc/file/magic/archive | \
|
|
grep -E "current ar archive" | awk '{print $1}' | cut -d: -f1 | \
|
|
xargs rm -v 2>/dev/null || true
|
|
fi
|
|
|
|
# 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:
|
|
newpkglocation="$pkgdest/$app-$version-$arch-$build.$pkgext"
|
|
|
|
# https://gist.github.com/ruario/9672717
|
|
# Create the SMLinux package
|
|
info "Generating SMLinux package..."
|
|
|
|
# If $disablepkgsymlinks is not set in the package build file, change any symlinks into shell script code. An example is base/initfs wherein
|
|
# we only want the doinst.sh file in the source directory to be copied, not manipulated.
|
|
|
|
if [[ -z $disablepkgsymlinks ]] ; then
|
|
if find . -type l | grep -qm1 .; then
|
|
info "Found symlinks, preparing install/doinst.sh..."
|
|
find . -type l -printf '( cd %h ; rm -rf %f )\n( cd %h ; ln -sf %l %f )\n' -delete > install/symlinks
|
|
if [[ -f install/doinst.sh ]]; then
|
|
printf '\n' | cat - install/doinst.sh >> install/symlinks
|
|
fi
|
|
mv install/symlinks install/doinst.sh
|
|
fi
|
|
fi
|
|
|
|
tar cvf - . --format gnu \
|
|
--xform 'sx^\./\(.\)x\1x' \
|
|
--show-stored-names | "$compressor" "$compressopts" > "$newpkglocation"
|
|
pkgstatus=$?
|
|
|
|
echo
|
|
info "SMLinux package '$app-$version-$arch-$build.$pkgext' successfully generated in $pkgdest."
|
|
|
|
# Terminate sccache
|
|
if [[ $globalsccache = 1 ]] ; then
|
|
if nc -z -w 1 localhost 4226 > /dev/null 2>&1 ; then
|
|
info "Terminating sccache"
|
|
$sccachebinpath --stop-server
|
|
fi
|
|
fi
|
|
|
|
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
|
|
info "Re-entering source directory $srcdir"
|
|
cd "$srcdir"
|
|
|
|
|
|
# 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
|
|
if [[ $showsummary = 1 ]] || [[ $htmloutput = 1 ]] ; then
|
|
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="and $tmpfssavingssum1"MB" writes to SSD saved"
|
|
fi
|
|
fi
|
|
|
|
# Delete the build directory if preservebuilddir is set to 0
|
|
if [[ $preservebuilddir = 0 ]] ; then
|
|
rm -rf "$tmp"
|
|
fi
|
|
|
|
# Delete the package staging directory if preservepackagedir is set to 0
|
|
if [[ $preservepackagedir = 0 ]] ; then
|
|
rm -rf "$pkg"
|
|
fi
|
|
}
|
|
|
|
buildfilecleanup() {
|
|
# Discard all temporary files
|
|
rm "$parenttmp/BUILDING"
|
|
|
|
# Autobuild discards $tempfile automatically, so only discard $tempfile if $autobuildtemp is unset
|
|
if [[ -z $autobuildtemp ]] ; then
|
|
rm "$tempfile"
|
|
fi
|
|
}
|
|
|
|
|
|
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=$(printf '\e[41m')
|
|
# Yellow when the build is interrupted
|
|
coloury=$(printf '\e[93m')
|
|
# Green when the build succeeds
|
|
colourg=$(printf '\e[92m')
|
|
# Cyan for the short questions
|
|
colourc=$(printf '\e[96m')
|
|
# App name/version colours
|
|
colourv=$(printf '\e[92m')
|
|
# Restore to default
|
|
colourd=$(printf '\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
|
|
# If distcc was used, cut out --randomize and output rest of the DISTCC_HOSTS variable
|
|
distccvar=$(echo "$DISTCC_HOSTS" | sed 's@--randomize@@')
|
|
dstats="Yes,$distccvar"
|
|
# 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 ]] && [[ $usetmpfs = 0 ]] && [[ -z $ccache ]] ; then
|
|
ccacheusedsize=$(ccache -s | grep "cache size" | head -n 1 | awk '{ $1=$2="" ; print $0}' | sed 's@ @@g')
|
|
ccachetotalsize=$(ccache -s | grep "max cache size" | awk '{ $1=$2=$3="" ; print $0}' | sed 's@ @@g')
|
|
cstats="Yes, $ccacheusedsize / $ccachetotalsize Allocated"
|
|
|
|
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 ]] ; then
|
|
bldtype="*DEBUG* build"
|
|
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
|
|
# Determine the compressed size
|
|
packsize=$(du -bk "$newpkglocation" | awk '{print $1}')
|
|
|
|
# Determine the uncompressed size
|
|
packusize="$packusize1"
|
|
|
|
# If the package was built successfully, output the installer sizes
|
|
# 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@.@@')
|
|
|
|
bldstatus="$colourg Successful! :-D $colourd
|
|
Srce Size: $colourd Compressed: $srcdirsize"K", Uncompressed: $builddirsize"K"
|
|
Pkg Size: $colourd Uncompressed: $packusize"K", Compressed: $packsize"K" ("$compressedsize'%'")
|
|
Pkg Has: $colourd $totalfilecount files and $totalsymcount symlinks in $totaldircount dirs"
|
|
|
|
elif [[ $wasinterrupted = 1 ]]; then
|
|
bldstatus="$coloury ** INTERRUPTED ** :-/ $colourd"
|
|
|
|
else
|
|
bldstatus="$colourr !! FAILED !! :-( $colourd"
|
|
|
|
fi
|
|
|
|
# Finally prepare the summary
|
|
|
|
# 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
|
|
ttime="$totaltime"
|
|
elif [[ -n $totaltime ]] && [[ -n $packagetimeb ]]; then
|
|
ttime="$totaltime ( $compiletimeb Compile ) + ( $packagetimeb Packaging )"
|
|
fi
|
|
|
|
# Output the section name if autobuildtemp is set. This means we are running an autobuild.
|
|
if [[ -n $autobuildtemp ]]; then
|
|
bsection="$section"
|
|
else
|
|
bsection="None"
|
|
fi
|
|
|
|
cat << EOF > "$tempfile"
|
|
$colourc ------------------------------------------------------------------------------- $colourd
|
|
$colourc BUILD SUMMARY FOR PACKAGE $colourv'$app'$colourc VERSION $colourv'$version'$colourc TAG $colourv'$build'
|
|
$colourc ------------------------------------------------------------------------------- $colourd
|
|
$colourc Build Status: $colourd $bldstatus
|
|
$colourc Build Section: $colourd $bsection
|
|
$colourc Total Time: $colourd $ttime
|
|
$colourc Started: $colourd $commencedate
|
|
$colourc Stopped: $colourd $finishdate
|
|
$colourc Ccache Used? $colourd $cstats
|
|
$colourc Distcc Used? $colourd $dstats
|
|
$colourc TMPFS Used? $colourd $tmpfsstate $tmpfssavingsize
|
|
$colourc CPU Threads: $colourd ${makeflags/-j/}
|
|
$colourc CFLAGS Used: $colourd $CFLAGS
|
|
$colourc Compressor: $colourd $compressor ($compressopts)
|
|
$colourc Build Type: $colourd $buildsys & $bldtype
|
|
$colourc ------------------------------------------------------------------------------- $colourd
|
|
EOF
|
|
|
|
# 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
|
|
|
|
}
|
|
|
|
# Prepare a nice HTML file that can be used to view status of the build process from a web browser
|
|
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 $newpkglocation ]] ; then
|
|
info "Extracting package installer inside $srcdir/test..."
|
|
mkdir -p "$srcdir/test"
|
|
tar xvf "$newpkglocation" -C "$srcdir/test"
|
|
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 $newpkglocation ]] ; then
|
|
read -r -p "[NOTIFY] Would you like the package installer of '$app-$version' to be extracted in your current directory '$srcdir' for examination? (y/N) " yn
|
|
case "$yn" in
|
|
Y|y) info "Wise Choice :-)" ;
|
|
mkdir -p "$srcdir/test"
|
|
tar xvf "$newpkglocation" -C "$srcdir/test" ;
|
|
info "'"$app"' package installer file successfully extracted" ;;
|
|
*) info "Nope? Alright " ;;
|
|
esac
|
|
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 $newpkglocation ]] ; then
|
|
read -r -p "[NOTIFY] Would you like the package installer of '$app-$version' to be installed/upgraded onto your system? (y/N) " yn
|
|
case "$yn" in
|
|
Y|y) info "Wise choice :-) " ;
|
|
upgradepkg --install-new "$newpkglocation" ;;
|
|
*) info "Nope? Alright." ;;
|
|
esac
|
|
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
|
|
info "Caught Keyboard Interrupt"
|
|
wasinterrupted="1"
|
|
|
|
# Restore terminal colours
|
|
echo -e "$colourd"
|
|
|
|
# Terminate sccache
|
|
if [[ $globalsccache = 1 ]] ; then
|
|
if nc -z -w 1 localhost 4226 > /dev/null 2>&1 ; then
|
|
info "Terminating sccache"
|
|
$sccachebinpath --stop-server
|
|
fi
|
|
fi
|
|
|
|
# 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 'interruptoutput' 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
|
|
|
|
# If $tmp exists, get the path to the $.app-$version.extraction.complete file
|
|
if [[ -d $tmp ]] ; then
|
|
buildresumepath="$(find $tmp -type f -name .$app-$version.extraction.complete)"
|
|
fi
|
|
|
|
# If the above file exists, $resumepkgbuild and $autobuild are unset
|
|
# and $autoresumepkgbuild is set to 1 in bldpkg.conf, prompt the user
|
|
if [[ -f $buildresumepath ]] && [[ -z $resumepkgbuild ]] && [[ $autoresumepkgbuild = 1 ]] && [[ -z $autobuild ]]; then
|
|
read -r -p "[NOTIFY] Would you like to resume building? " yn
|
|
case "$yn" in
|
|
N|n|No|no) info "Nope? Alright." ;
|
|
unset resumepkgbuild ;;
|
|
*) info "Wise choice :-) "
|
|
resumepkgbuild=1 ;;
|
|
esac
|
|
fi
|
|
|
|
# If $resumepkgbuild variable is not set in getopts, only then execute prepbuilddir variable
|
|
if [[ -z $resumepkgbuild ]] ; then
|
|
prepbuilddir
|
|
fi
|
|
|
|
# If $resumepkgbuild is set either in getopts or from the user prompt above, execute mkandenterbuilddir
|
|
# function to enter the build directory. This is being done because mkandenterbuilddir is part of prepbuilddir
|
|
# function in the build file and ignoring prepbuilddir will not cause mkandenterbuilddir to be invoked
|
|
# separately unless the build system is told to.
|
|
if [[ -n $resumepkgbuild ]] ; then
|
|
mkandenterbuilddir
|
|
|
|
# fixbuilddirpermissions places a file ".$app-$version.extraction.complete". Get the directory name that houses that file
|
|
# and cd into it
|
|
if [[ ! -f $buildresumepath ]] ; then
|
|
err "Can't resume build of '"$app"'! Are you certain the source was extracted completely?"
|
|
else
|
|
cd ${buildresumepath%/*}
|
|
fi
|
|
fi
|
|
build
|
|
|
|
# End script
|