PktSurf
258fdc4b56
* Removed unnecessary code related to creation and use of temporary summary file in bldpkg * Moved totaltime code inside showsummary if/else check * Fixed comments
1308 lines
48 KiB
Bash
Executable file
1308 lines
48 KiB
Bash
Executable file
#!/bin/bash
|
|
|
|
# Part of the SMLinux distribution
|
|
# http://git.pktsurf.in/smlinux
|
|
#
|
|
# /bin/bldpkg version 0.101
|
|
# 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.
|
|
############
|
|
|
|
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, insert them into the package build file and exit
|
|
|
|
-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
|
|
|
|
-t Build inside tmpfs directory
|
|
|
|
-v Enable verbose compile
|
|
|
|
-x Invoke bash shell command trace mode. This one isn't akin to running
|
|
bash -x <script> but close enough, because the mode is inserted half-way
|
|
while bldpkg is running
|
|
EOF
|
|
exit 0
|
|
}
|
|
|
|
# Function to validate the build file.
|
|
validatebldfile() {
|
|
local buildfile="$1"
|
|
|
|
if [[ ! -f $buildfile ]] ; then
|
|
err "No build file to validate from!"
|
|
else
|
|
source $buildfile
|
|
fi
|
|
|
|
for reqvars in app version build homepage desc requires ; do
|
|
[[ ! ${!reqvars} ]] && err "Required variable '$reqvars' is not set in $buildfile!"
|
|
done
|
|
|
|
# Check if 'Maintainer' comment exists
|
|
if ! grep -q "^# Maintainer" "$buildfile" ; then
|
|
err "Please provide a Maintainer name and email as a comment at the top of the build file"
|
|
|
|
# Validate $app
|
|
elif ! echo "$app" | grep -E -q '[a-z0-9-]+'; then
|
|
err "Only lower case, numeric characters and dash allowed in the 'app' variable in the build file."
|
|
|
|
# Validate $version
|
|
elif ! echo "$version" | grep -E -q '[a-z0-9.]+'; then
|
|
err "Only lower case, numeric characters and a period allowed in the 'version' variable in the build file."
|
|
|
|
# Validate $homepage
|
|
elif ! echo "$homepage" | grep -E -q '(https|http|ftp)://[^"]+' ; 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
|
|
|
|
# Validate the download variable separately because it's optional
|
|
if [[ -n $download ]] ; then
|
|
if ! echo "$download" | grep -E -q '(https|http|ftp)://[^"]+' ; then
|
|
err "Invalid URL in the 'download' variable in the build file."
|
|
fi
|
|
fi
|
|
}
|
|
|
|
# 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)"
|
|
}
|
|
|
|
validatemakeflags() {
|
|
local makeflags="$1"
|
|
local makeflags0="${makeflags/-j/}"
|
|
if ! echo "$makeflags0" | grep -E -q '^[0-9]+$' ; then
|
|
err "Invalid MAKEFLAGS '$makeflags0'!"
|
|
fi
|
|
}
|
|
|
|
# Function for applying patches to the build in a more efficient manner
|
|
applypatch() {
|
|
# Take patch file name as the first argument
|
|
local 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
|
|
local 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
|
|
}
|
|
|
|
# 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
|
|
}
|
|
|
|
# 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>
|
|
local archname="$(uname -m)"
|
|
local archargument="$1"
|
|
|
|
if [[ $archname != $archargument ]]; then
|
|
info "'$app' not supported on '$archname' and hence not not being built. Exiting."
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
# Function to validate compilers.
|
|
# Usage: compilertestfile "$CC" "$CFLAGS" cc-test.c cc-test
|
|
compilertestfile() {
|
|
local compileraddonflags="-O0 -Werror -static"
|
|
local compiler="$1"
|
|
local compilerflags="$2"
|
|
local compilerfile="$3"
|
|
local compileroutput="$4"
|
|
|
|
printf "[INFO] Validating compiler '$compiler'... "
|
|
|
|
# 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.
|
|
local randomnum="$(shuf -i 100-9999 -n1)"
|
|
|
|
cat << EOF > "$parenttmp/$compilerfile"
|
|
#include <stdio.h>
|
|
int main() { printf("$randomnum\n"); }
|
|
EOF
|
|
|
|
$compiler $compilerflags -o "$parenttmp/$compileroutput" $compileraddonflags "$parenttmp/$compilerfile"
|
|
local finaloutput="$($parenttmp/$compileroutput)"
|
|
|
|
# Error out if the outputs don't match
|
|
if [[ $finaloutput != $randomnum ]] ;then
|
|
err " failed!"
|
|
else
|
|
rm "$parenttmp/$compileroutput"*
|
|
printf " done\n"
|
|
fi
|
|
}
|
|
|
|
# Function to start/stop sccache.
|
|
# Usage: sccache start/stop
|
|
sccacheprocess() {
|
|
local sccacheopt="$1"
|
|
if [[ $sccache = 1 ]]; then
|
|
if [[ $sccacheopt = "start" ]] ; then
|
|
# Check whether sccache is running on TCP port 4226 via nc
|
|
if ! nc -z -w 1 localhost 4226 > /dev/null 2>&1 ; then
|
|
info "Starting sccache"
|
|
$sccachebinpath --start-server
|
|
fi
|
|
elif [[ $sccacheopt = "stop" ]] ; then
|
|
if nc -z -w 1 localhost 4226 > /dev/null 2>&1 ; then
|
|
info "Stopping sccache"
|
|
$sccachebinpath --stop-server
|
|
fi
|
|
fi
|
|
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"
|
|
|
|
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
|
|
}
|
|
|
|
# Generate and insert sha512sums into the build file
|
|
genchecksum() {
|
|
# 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
|
|
info "Adding $file"
|
|
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
|
|
}
|
|
|
|
preprunitservice() {
|
|
# Usage: preprunitservice -s chrony -d -f
|
|
while getopts ':dfs:' option; do
|
|
case "$option" in
|
|
d) downfile=1 ;; # Add a 'down' file
|
|
f) finishfile=1 ;; # Add a 'finish' file
|
|
s) servicefile="$OPTARG" ;; # Add main runit service file
|
|
esac
|
|
done
|
|
|
|
mkdir -p $pkg/var/service
|
|
install -Dm 755 "$srcdir/$servicefile.run" "$pkg/etc/service/$servicefile/run"
|
|
(
|
|
cd $pkg
|
|
ln -sf "../../etc/service/$servicefile" "var/service/$service"
|
|
)
|
|
|
|
[[ -n $downfile ]] && touch "$pkg/etc/service/$servicefile/down"
|
|
[[ -n $finishfile ]] && touch "$pkg/etc/service/$servicefile/finish"
|
|
|
|
# Unset OPTIND and OPTARG to avoid problems if getopts is used again in the future
|
|
unset OPTIND OPTARG
|
|
}
|
|
|
|
# Function to validate symlinks.
|
|
# Usage: checkcompilersymlink symlink symlink_target
|
|
checkcompilersymlink() {
|
|
local symlinkdir="$1"
|
|
local 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
|
|
}
|
|
|
|
# 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
|
|
}
|
|
|
|
extractinfo() {
|
|
info "Extracting package installer inside $srcdir/test..."
|
|
mkdir -p "$srcdir/test"
|
|
tar xvf "$newpkglocation" -C "$srcdir/test"
|
|
info "'$app' package installer file successfully extracted"
|
|
}
|
|
|
|
promptuser() {
|
|
# Extract package at the end of a build if autoextract is set to 1
|
|
if [[ $autoextract = 1 ]] && [[ -z $autobuild ]] && [[ -n $newpkglocation ]] ; then
|
|
extractinfo
|
|
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 :-)"
|
|
extractinfo ;;
|
|
*) 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
|
|
sccacheprocess stop
|
|
|
|
# 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
|
|
}
|
|
|
|
# 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
|
|
[[ -d lib64 ]] && err "Multilib directory '/lib64' created inside '$pkg' not supported by musl C library."
|
|
|
|
# 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
|
|
[[ -d $directory ]] && err "$pkg/$directory is a symlink to '/bin'. Fix your build options and ensure such a directory is not created"
|
|
done
|
|
fi
|
|
|
|
info "Copying post-install files..."
|
|
|
|
[[ -e $srcdir/doinst.sh ]] && cp "$srcdir/doinst.sh" "install/"
|
|
|
|
# If /share/applications directory exists but there is no doinst.sh in the source directory, create one using cat
|
|
if [[ -d 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 >> "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 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 >> "install/doinst.sh"
|
|
[[ -x /etc/rc.d/rc.gtk ]] && /etc/rc.d/rc.gtk
|
|
EOF
|
|
fi
|
|
|
|
# Compress and link manpages
|
|
if [[ -d share/man ]]; then
|
|
info "Compressing and linking man pages..."
|
|
( cd "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
|
|
|
|
# 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
|
|
|
|
# Remove libtool archive files
|
|
if [[ -d lib ]] && [[ "$(findlibtoolfiles | wc -l)" -ge 1 ]] ; then
|
|
info "Discarding libtool archive (.la) files..."
|
|
findlibtoolfiles -exec rm -v {} \;
|
|
fi
|
|
|
|
# If $preservestaticlibs is not set in the package build file, delete all static libraries
|
|
if [[ -d lib ]] && [[ -z $preservestaticlibs ]] ; then
|
|
if [[ "$(findarchivefiles | wc -l)" -ge 1 ]] ; then
|
|
info "Discarding static libraries..."
|
|
findarchivefiles | xargs rm -v
|
|
fi
|
|
fi
|
|
|
|
# Now strip the binaries and libraries.
|
|
if [[ -z $debug ]] ; then
|
|
if [[ "$(findelffiles | wc -l)" -ge 1 ]] ; then
|
|
info "Stripping ELF files..."
|
|
# scanelf will, if a static archive is found, return object files inside that archive, so play safe
|
|
findelffiles | cut -d: -f1 | uniq | xargs strip --strip-unneeded
|
|
fi
|
|
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}')
|
|
|
|
# Here we ascertain the packaging time taken to actually prepare the final package. For this, we
|
|
# must reset the SECONDS variable to ensure accuracy
|
|
SECONDS=0
|
|
fi
|
|
|
|
# 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
|
|
[[ -f install/doinst.sh ]] && printf '\n' | cat - install/doinst.sh >> install/symlinks
|
|
mv install/symlinks install/doinst.sh
|
|
fi
|
|
fi
|
|
|
|
# Discard charset.alias
|
|
[[ -f lib/charset.alias ]] && rm lib/charset.alias
|
|
|
|
# Also discard the lib and install directory if it's empty but don't error out
|
|
rmdir lib &> /dev/null || true
|
|
rmdir install &> /dev/null || true
|
|
|
|
tar cvf - . --format gnu \
|
|
--xform 'sx^\./\(.\)x\1x' \
|
|
--show-stored-names | "$compressor" "$compressoropts" > "$newpkglocation"
|
|
pkgstatus=$?
|
|
|
|
echo
|
|
info "SMLinux package '$app-$version-$arch-$build.$pkgext' successfully generated in $pkgdest."
|
|
|
|
# Terminate sccache
|
|
sccacheprocess stop
|
|
|
|
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 [[ $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
|
|
[[ $preservebuilddir = 0 ]] && rm -rf "$tmp"
|
|
|
|
# Delete the package staging directory if preservepackagedir is set to 0
|
|
[[ $preservepackagedir = 0 ]] && rm -rf "$pkg"
|
|
}
|
|
|
|
findarchivefiles() {
|
|
find "lib" -type f -name "*.a"
|
|
}
|
|
|
|
findlibtoolfiles() {
|
|
find "lib" -type f -name "*.la" "$@"
|
|
}
|
|
|
|
findelffiles() {
|
|
# Only scan for static archives if preservestaticlibs is set to 1
|
|
[[ $preservestaticlibs = "1" ]] && staticelfflag=",ET_REL"
|
|
scanelf --archives --nobanner --recursive --symlink --format "%F" --etype "ET_EXEC,ET_DYN$staticelfflag" .
|
|
}
|
|
|
|
buildfilecleanup() {
|
|
# Discard all temporary files
|
|
rm "$parenttmp/BUILDING"
|
|
}
|
|
|
|
prepbuildoutput() {
|
|
# Start of the showsummary if/else check
|
|
if [[ $showsummary = 1 ]]; then
|
|
|
|
# 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
|
|
|
|
# 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 the autobuild system
|
|
buildsys="Autobuild"
|
|
else
|
|
# We compiled the package manually
|
|
buildsys="Manual"
|
|
fi
|
|
|
|
# Determine if distcc was used. If $distcc set to 1, set distccstats in the build summary
|
|
if [[ $distcc = 1 ]] ; then
|
|
# If distcc was used, cut out --randomize and output rest of the DISTCC_HOSTS variable
|
|
distccvar=$(echo "$DISTCC_HOSTS" | sed 's@--randomize@@')
|
|
distccstats="Yes, $distccvar"
|
|
# Else if distcc is unset, set distccstats in the build summary
|
|
elif [[ -z $distcc ]] || [[ $distcc = 0 ]]; then
|
|
distccstats="No, disabled"
|
|
fi
|
|
|
|
|
|
# Determine if ccache was used. If we are compiling inside tmpfs, we are not using ccache at all, so set
|
|
# ccachestats accordingly in the build summary
|
|
if [[ $ccache = 1 ]] && [[ $tmpfsenabledforthispackage = 1 ]] ; then
|
|
ccachestats="Set to 1 but disabled due to tmpfs"
|
|
|
|
elif [[ $ccache = 1 ]] && [[ $tmpfs = 0 ]] ; 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')
|
|
ccachestats="Yes, $ccacheusedsize / $ccachetotalsize Allocated"
|
|
|
|
elif [[ $ccache = 1 ]] && [[ -z $tmpfs ]] ; then
|
|
ccachestats="Yes"
|
|
|
|
elif [[ -z $ccache ]] || [[ $ccache = 0 ]] ; then
|
|
ccachestats="No, disabled in bldpkg.conf"
|
|
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 [[ $tmpfsenabledforthispackage = 1 ]] ; then
|
|
tmpfsstate="Yes"
|
|
|
|
elif [[ $tmpfs = 1 ]] && [[ $tmpfsenabledforthispackage = 0 ]]; then
|
|
tmpfsstate="*Not for this package* but enabled in bldpkg.conf"
|
|
|
|
elif [[ $tmpfs = 1 ]] && [[ $tmpfscheckfailed = 1 ]]; then
|
|
tmpfsstate="*NOPE, TMPFS DIRECTORY CHECK FAILED* but enabled in bldpkg.conf"
|
|
|
|
else
|
|
tmpfsstate="No, disabled in bldpkg.conf"
|
|
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 inside a variable
|
|
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
|
|
|
|
# Output the build summary to the user on every build
|
|
cat << EOF
|
|
$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 $ccachestats
|
|
$colourc Distcc Used? $colourd $distccstats
|
|
$colourc TMPFS Used? $colourd $tmpfsstate $tmpfssavingsize
|
|
$colourc MAKEFLAGS: $colourd $MAKEFLAGS
|
|
$colourc CFLAGS Used: $colourd $CFLAGS
|
|
$colourc Compressor: $colourd $compressor ($compressoropts)
|
|
$colourc Build Type: $colourd $buildsys & $bldtype
|
|
$colourc ------------------------------------------------------------------------------- $colourd
|
|
EOF
|
|
|
|
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
|
|
}
|
|
|
|
# Source the main configuration file holding all necessary 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 ccache and sccache are set in the /etc/bldpkg.conf
|
|
if [[ $ccache = 1 ]] && [[ $sccache = 1 ]] ; then
|
|
err "Please only enable either ccache or sccache in bldpkg.conf at the same time, not both."
|
|
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"
|
|
|
|
# While loop for providing handy arguments to users. Some will override bldpkg.conf.
|
|
while getopts ':def:ghj:o:rstvx' 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 ;;
|
|
h) help ;;
|
|
j) custommakeflags="$OPTARG" ;;
|
|
o) origbuildfile="$OPTARG" ;;
|
|
r) resumepkgbuild=1 ;;
|
|
s) showsummary=1 ;; # Show build summary at the end of the build irrespective of the build status
|
|
t) tmpfs=1 ;;
|
|
v) getoptsverbosebuild=1 ;;
|
|
x) set -xv ;; # Invoke bash's -x option for command tracing
|
|
*) help ;;
|
|
esac
|
|
done
|
|
|
|
# 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 then be validated and 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
|
|
|
|
# If MAKEFLAGS and custommakeflags is set, let custommakeflags take precedence
|
|
if [[ -n $custommakeflags ]] ; then
|
|
validatemakeflags $custommakeflags
|
|
MAKEFLAGS="-j$custommakeflags"
|
|
|
|
elif [[ -n $MAKEFLAGS ]] ; then
|
|
validatemakeflags $MAKEFLAGS
|
|
|
|
elif [[ -z $MAKEFLAGS ]] ; then
|
|
# Or fetch the number from nproc
|
|
MAKEFLAGS="-j$(nproc --all)"
|
|
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
|
|
|
|
# Display the package and its version we are building or resuming
|
|
if [[ -z $resumepkgbuild ]] ; then
|
|
info "Building package '$app' version '$version' ..."
|
|
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 "Please run 'bldpkg -g' to add sha512sums into '$buildfile'!"
|
|
else
|
|
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
|
|
fi
|
|
|
|
# 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/.parenttmpwritetest" ; then
|
|
err "Parent temp directory '$parenttmp' is not writable!"
|
|
else
|
|
# Discard the test file
|
|
rm "$parenttmp/.parenttmpwritetest"
|
|
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
|
|
|
|
printf "[INFO] Validating compressor '$compressor'..."
|
|
mkdir -p "$parenttmp/.tar.testdir"
|
|
touch "$parenttmp/.tar.testdir/.tar.testfile"
|
|
|
|
if ! tar -cf - -C "$parenttmp/.tar.testdir" . | "$compressor" "$compressoropts" > "$parenttmp/.tar.testdir.$pkgext" ; then
|
|
err "Failed to validate '$compressor' options! Please check your bldpkg.conf"
|
|
fi
|
|
|
|
printf " done\n"
|
|
rm -r "$parenttmp/.tar.testdir"*
|
|
|
|
# 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 [[ $tmpfs = 1 ]] && [[ -n $tmpfsdir ]]; then
|
|
if [[ ! -d $tmpfsdir ]] || ! touch "$tmpfsdir/.tmpfswritetest" \
|
|
|| [[ $(findmnt -no TARGET $tmpfsdir) != $tmpfsdir ]] \
|
|
|| [[ $(findmnt -no FSTYPE $tmpfsdir) != tmpfs ]]; then
|
|
tmpfscheckfailed=1
|
|
fi
|
|
|
|
# Discard the file used to test the tmp directory
|
|
rm "$tmpfsdir/.tmpfswritetest"
|
|
|
|
# Check the tmpfsdir for stale directories from previous pkg 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}')
|
|
[[ $swapcheck -lt $swapsize ]] && err "Insufficient swap size to build packages, advise increasing it."
|
|
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 tmpfs is set to 1 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 [[ $tmpfs = 1 ]] && [[ -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
|
|
|
|
info "'$app' is in tmpfs exception list. Falling back to non-tmpfs directory"
|
|
|
|
# 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 tmpfs 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
|
|
|
|
# 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.
|
|
trap "prepbuildoutput" EXIT
|
|
trap "interruptoutput" INT
|
|
|
|
# If $tmp exists, get the path to the $.app-$version.extraction.complete file
|
|
[[ -d $tmp ]] && buildresumepath="$(find $tmp -type f -name .$app-$version.extraction.complete)"
|
|
|
|
# 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
|
|
[[ -z $resumepkgbuild ]] && prepbuilddir
|
|
|
|
# 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". Only resume the build if that file exists
|
|
if [[ ! -f $buildresumepath ]] ; then
|
|
err "Can't resume build of '"$app"'! Are you certain the source was extracted completely?"
|
|
else
|
|
cd ${buildresumepath%/*}
|
|
fi
|
|
fi
|
|
|
|
# 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
|
|
|
|
# Apply CPU-specific compiler variables defined inside bldpkg.conf
|
|
# noarch is set inside initfs, pkgtools, GTK themes and some other stuff.
|
|
|
|
# Only set $arch if it's not set in the build file. We take the help of $HOSTTYPE variable set by the bash shell.
|
|
[[ -z $arch ]] && arch="$HOSTTYPE"
|
|
|
|
for compilervariable in CC CXX CFLAGS ; do
|
|
[[ -z $compilervariable ]] && err "$compilervariable not set in bldpkg.conf!"
|
|
done
|
|
|
|
# Clean out CFLAGS if $arch is set to noarch
|
|
if [[ $arch = noarch ]]; then
|
|
CFLAGS=""
|
|
elif [[ -n $debug ]]; then
|
|
CFLAGS="$gccdebug $CFLAGS"
|
|
fi
|
|
|
|
CXXFLAGS="$CFLAGS"
|
|
export hostdist builddist CC CXX CFLAGS CXXFLAGS MAKEFLAGS
|
|
|
|
# Validate available compilers. Quotes are important while passing C/CXXFLAGS
|
|
compilertestfile "$CC" "$CFLAGS" cc-test.c cc-test
|
|
compilertestfile "$CXX" "$CXXFLAGS" cxx-test.cpp cxx-test
|
|
|
|
# Validate everything related to ccache if ccache is set
|
|
if [[ $ccache = 1 ]]; then
|
|
[[ ! -x $ccachebinpath ]] && err "Ccache binary does not exist/is not an executable!"
|
|
|
|
checkcompilersymlink $ccachesymdirpath $ccachebinpath
|
|
|
|
# Prepare $PATH and export it only if ccache is unset in the pkg build file
|
|
PATH="$ccachesymdirpath:$PATH"
|
|
export PATH
|
|
fi
|
|
|
|
# Validate everything related to sccache if ccache is set
|
|
if [[ $sccache = 1 ]]; then
|
|
[[ ! -x $sccachebinpath ]] && err "$sccachebinpath was either not found or is not an executable!"
|
|
|
|
# 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
|
|
|
|
sccacheprocess start
|
|
fi
|
|
|
|
# Validate everything related to distcc if distcc is set
|
|
if [[ $distcc = 1 ]] ; then
|
|
# Check if distcc exists and is an executable
|
|
[[ ! -x $distccbinpath ]] && err "Distcc binary was either not found or is not an executable"
|
|
|
|
checkcompilersymlink $distccsymdirpath $distccbinpath
|
|
|
|
# Prepare $PATH and export DISTCC_HOSTS and DISTCC_IO_TIMEOUT only if distcc is unset in the pkg build file
|
|
# 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
|
|
|
|
# If verbosebuild 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 [[ $verbosebuild = 1 ]] || [[ $getoptsverbosebuild = 1 ]] ; then
|
|
V=1
|
|
VERBOSE=1
|
|
else
|
|
V=0
|
|
VERBOSE=0
|
|
fi
|
|
export V VERBOSE
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
build
|
|
|
|
# End script
|