PktSurf
17c70a05c1
-> Added version number to the script -> Added double quotes next to variable values in few places -> Discarded buggy code that validated the download variable for a sane URL -> Removed double quotes inside [[ ]] since it is safe to do so in bash -> Optimised code responsible for extracting hosts in DISTCC_HOSTS variable -> netcat binary now checks for a running sccache server on localhost -> Added code to check if CC and CXX variables are populated -> Added back ignoreusr variable -> Discarded code that checked and moved the documentation directory in its proper place in the staging directory -> Discarded code that moved pkgconfig directory from share to lib -> Discarded code that checked for ELF objects in the build directory before any action was performed using mkfinalpkg in the staging directory
1440 lines
52 KiB
Bash
1440 lines
52 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
|
|
}
|
|
|
|
# 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"
|
|
|
|
# Find all required files. If either of them don't exist, abort.
|
|
rqfiles=( installpkg upgradepkg sha512sum patch find findmnt patch tput bc tar )
|
|
|
|
# Run a for loop to find the 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
|
|
|
|
validatecompiler() {
|
|
|
|
# Function called as: validatecompiler distcc $distccsympath $f
|
|
if [[ $validatecompilers = 1 ]] ; then
|
|
compiler="$1"
|
|
compilerpath="$2"
|
|
maincompiler="$3"
|
|
randomnum=$(shuf -i 100-999 -n1)
|
|
|
|
echo "Validating $compiler compiler... "
|
|
|
|
cat << EOF > "$parenttmp/$compiler-$maincompiler.c"
|
|
#include <stdio.h>
|
|
int main() {
|
|
printf("$randomnum\n");
|
|
return 0;
|
|
}
|
|
EOF
|
|
|
|
"$compilerpath/$maincompiler" -o "$parenttmp/$compiler-$maincompiler" "$parenttmp/$compiler-$maincompiler.c"
|
|
|
|
binaryoutput=$($parenttmp/$compiler-$maincompiler)
|
|
|
|
if [[ $binaryoutput != $randomnum ]] ; then
|
|
err "FAILED!"
|
|
fi
|
|
|
|
rm "$parenttmp/$compiler-$maincompiler.c" "$parenttmp/$compiler-$maincompiler"
|
|
fi
|
|
|
|
}
|
|
|
|
# Validate all compilers starting with distcc
|
|
# 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 building with it was requested!
|
|
Either ensure distcc is in your $PATH or disable its option in bldpkg.conf file."
|
|
|
|
# Check if the symlinks are right
|
|
elif [[ ! $(echo "$PATH" | grep "$distccsympath") ]] ; then
|
|
err "'$distccsympath' directory not found in your env PATH"
|
|
elif [[ ! -d $distccsympath ]] ; then
|
|
err "'$distccsympath' directory containing symlinks to distcc does not exist!
|
|
Kindly create it and create symlinks based on instructions in bldpkg.conf!"
|
|
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
|
|
err "'$distccsympath/$f' does not point to '$distccbinpath'. Kindly fix this!"
|
|
fi
|
|
else
|
|
err "Symlink '$f' either does not exist or is not a symlink inside '$distccsympath'. Kindly fix this! "
|
|
exit 1
|
|
fi
|
|
|
|
validatecompiler distcc $distccsympath $f
|
|
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="${PATH//$distccsympath:/}"
|
|
else
|
|
# 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
|
|
|
|
export DISTCC_HOSTS DISTCC_IO_TIMEOUT
|
|
fi
|
|
else
|
|
# Remove $distccsympath
|
|
PATH="${PATH//$distccsympath:/}"
|
|
fi
|
|
|
|
# Validate everything related to ccache if globalccache is set
|
|
if [[ $globalccache = 1 ]]; then
|
|
if [[ ! -x $ccachebinpath ]] ; then
|
|
err "Ccache binary was not found but building with it was requested!
|
|
Either ensure ccache is in your $PATH or disable this option in bldpkg.conf."
|
|
fi
|
|
|
|
if [[ ! $(echo $PATH | grep $ccachesympath) ]] ; then
|
|
err "'"$ccachesympath"' directory not found in your env PATH"
|
|
elif [[ ! -d $ccachesympath ]] ; then
|
|
err "'$ccachesympath' directory containing symlinks to ccache does not exist!
|
|
Kindly create it and create symlinks based on instructions in bldpkg.conf."
|
|
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
|
|
err "'$ccachesympath/$f' does not point to '$ccachebinpath'. Kindly fix this!"
|
|
fi
|
|
else
|
|
err "Symlink '$f' either does not exist or is not a symlink inside '$ccachesympath'! Kindly fix this!"
|
|
fi
|
|
|
|
validatecompiler ccache $ccachesympath $f
|
|
|
|
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="${PATH//$ccachesympath:/}"
|
|
fi
|
|
else
|
|
# Remove $ccachesympath
|
|
PATH="${PATH//$ccachesympath:/}"
|
|
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
|
|
|
|
# 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
|
|
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
# Only put $app-$version.extraction.complete file if $extractioncomplete is unset.
|
|
# This ensures that the file is only set once.
|
|
if [[ -z $extractioncomplete ]] ; then
|
|
touch ".$app-$version.extraction.complete"
|
|
extractioncomplete=1
|
|
fi
|
|
}
|
|
|
|
# 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
|
|
info "Terminating sccache"
|
|
/bin/sccache --stop-server
|
|
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
|
|
info "Terminating sccache"
|
|
/bin/sccache --stop-server
|
|
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
|