819 lines
32 KiB
Bash
Executable File
819 lines
32 KiB
Bash
Executable File
#!/bin/bash
|
|
# autoport -- batch cross-build tool based on autodist
|
|
# Copyright (C) 2011-2024 by Silvan Calarco <silvan.calarco@mambasoft.it>
|
|
#
|
|
# Released under the terms of the GNU GPL release 3 license
|
|
#
|
|
VERSION=1.5.3
|
|
|
|
BASE_REPOSITORY=base
|
|
PORT_REPOSITORY=base
|
|
|
|
. /etc/autodist/config
|
|
|
|
me=(${0##*/} $VERSION "Sat Mar 20 2011")
|
|
|
|
function usage() {
|
|
echo "\
|
|
${me[0]} ${me[1]}
|
|
"$"Copyright (C) 2011-2023 Silvan Calarco <silvan.calarco@mambasoft.it>""
|
|
"$"Released under the terms of the GNU GPL v3 license"
|
|
echo "
|
|
"$"Batch port and cross-build tool based on autodist.""
|
|
|
|
"$"Usage"":
|
|
$me [-a][-f][-x arch1[,arch2],..][-r repository][-d release_repository][-s \"script_args\"]{--fix|job ...}
|
|
|
|
-a "$"Automatic mode (use cache)
|
|
-b "$"Batch port all packages in port repository to sync with base repository
|
|
-f "$"Force operations
|
|
-np "$"Don't prepare jobs passed to command line unless specfile is not found
|
|
-npa "$"Don't prepare any jobs unless specfile is not found
|
|
-nr "$"Don't recurse build
|
|
--fix "$"Fix .la files for cross linking and exit
|
|
-r "$"Work on given repository (default: $PORT_REPOSITORY)
|
|
-d "$"Release packages to given repository (default: work repository)
|
|
-h "$"Show this help and exit
|
|
-s \"script_args\" "$"Send script_args as arguments for autodist update-specfile script
|
|
-u changelog "$"Rebuild packages with given changelog
|
|
-ud "$"Rebuild dependent packages that need rebuild
|
|
-v "$"More verbose output
|
|
-x "$"Operate in cross build mode
|
|
--user user "$"Pass calling user name for Webbuild social messages
|
|
|
|
arch "$"Target architecture
|
|
job "$"Job specification for autodist""
|
|
"
|
|
|
|
}
|
|
|
|
function autoport_log() {
|
|
local pkg=$1
|
|
local operation=$2
|
|
local result=$3
|
|
local loggrep=`grep "?= See" $4 | sed "s|?= See ||"`
|
|
local logfiles=""
|
|
|
|
for f in $loggrep; do
|
|
logfiles="$logfiles $f"
|
|
done
|
|
[ "$pkg" -a "$operation" -a "$result" -a "$BATCH_MODE" ] || return
|
|
echo "$pkg $operation $result $logfiles" >> $DATADIR/autoport-$PORT_REPOSITORY-current
|
|
}
|
|
|
|
# for webbuild message
|
|
function cgi_encodevar() {
|
|
local string="${1}"
|
|
local strlen=${#string}
|
|
local encoded=""
|
|
|
|
for (( pos=0 ; pos<strlen ; pos++ )); do
|
|
c=${string:$pos:1}
|
|
case "$c" in
|
|
[-_.~a-zA-Z0-9] ) o="${c}" ;;
|
|
* ) printf -v o '%%%02x' "'$c"
|
|
esac
|
|
encoded+="${o}"
|
|
done
|
|
echo "${encoded}" # You can either set a return variable (FASTER)
|
|
# REPLY="${encoded}" #+or echo the result (EASIER)... or both... :p
|
|
}
|
|
|
|
function get_pkg_srcinfo() {
|
|
|
|
local pkg local_distromatic pkg_line
|
|
|
|
unset src_name src_version src_buildtime src_repository src_epoch src_release
|
|
|
|
[ $1 ] && local_distromatic=$1 || exit 1
|
|
[ $2 ] && pkg=$2 || return 1
|
|
|
|
[ -e $local_distromatic/srcpkglist ] || return 2
|
|
|
|
pkg_line=`grep "^$pkg " $local_distromatic/srcpkglist`
|
|
[ "$pkg_line" ] || return 3
|
|
|
|
set -- $pkg_line
|
|
|
|
src_name=$1
|
|
src_version=$2
|
|
src_buildtime=$3
|
|
src_repository=$4
|
|
src_epoch=$5
|
|
src_release=$6
|
|
src_milestone=`echo $src_release | sed "s|[0-9.]*\(.*\)|\1|"`
|
|
}
|
|
|
|
# get_pkg_buildinfo - uses distromatic generated build file for
|
|
# getting information on the repository
|
|
#
|
|
# $1: distromatic files base url for repository
|
|
# $2: architecture
|
|
# $3: pkg name
|
|
function get_pkg_buildinfo() {
|
|
|
|
local pkg i a local_arch local_distromatic
|
|
|
|
[ $1 ] && local_distromatic=$1 || exit 1
|
|
[ $2 ] && local_arch=$2 || exit 1
|
|
[ $3 ] && pkg=$3
|
|
|
|
if [ ! "$pkg" ]; then
|
|
[ -e $local_distromatic/builds-${local_arch}.sh ] && . $local_distromatic/builds-${local_arch}.sh
|
|
return 0
|
|
fi
|
|
|
|
pkg_archs=();
|
|
for a in ${AUTODIST_ARCHS[*]}; do
|
|
[ "$a" = "${local_arch}" ] && continue
|
|
pkg_header=();
|
|
DISTROMATIC_BUILD_FILE=$local_distromatic/builds-$a.sh
|
|
[ -e $DISTROMATIC_BUILD_FILE ] && . $DISTROMATIC_BUILD_FILE
|
|
[ ${pkg_header[0]} ] && pkg_archs=(${pkg_archs[*]} $a)
|
|
done
|
|
|
|
pkg_header=();
|
|
pkg_builds=();
|
|
pkg_obsoletes=();
|
|
pkg_list=();
|
|
|
|
DISTROMATIC_BUILD_FILE=$local_distromatic/builds-${local_arch}.sh
|
|
[ -e $DISTROMATIC_BUILD_FILE ] && . $DISTROMATIC_BUILD_FILE
|
|
[ ${pkg_header[0]} ] && pkg_archs=(${pkg_archs[*]} ${local_arch})
|
|
|
|
# {
|
|
# echo "Error: missing distromatic generated file $DISTROMATIC_BUILD_FILE; aborting."
|
|
# return;
|
|
# }
|
|
# . $DISTROMATIC_BUILD_FILE
|
|
|
|
if [ "${pkg_header[0]}" ]; then
|
|
pkg_name=${pkg_header[0]};
|
|
# Note: pkg_arch reported in builds file is just last arch source was
|
|
# built for, so we use repository arch instead
|
|
pkg_arch=${pkg_header[1]};
|
|
[ "$pkg_arch" = "noarch" ] || pkg_arch=${local_arch}
|
|
pkg_version=${pkg_header[2]};
|
|
pkg_release=${pkg_header[3]};
|
|
pkg_group=${pkg_header[4]};
|
|
pkg_license=${pkg_header[5]};
|
|
pkg_size=${pkg_header[6]};
|
|
pkg_buildtime=${pkg_header[7]};
|
|
pkg_altrep=${pkg_header[8]};
|
|
pkg_repository=${pkg_header[9]};
|
|
pkg_epoch=${pkg_header[10]};
|
|
return 0
|
|
fi
|
|
unset pkg_name pkg_arch pkg_version pkg_release \
|
|
pkg_group pkg_license pkg_size pkg_buildtime pkg_altrep pkg_repository
|
|
|
|
return 1
|
|
}
|
|
|
|
function write_last_file() {
|
|
[ "$AUTO_MODE" == "1" ] && LASTFILE=$DATADIR/last || LASTFILE=$DATADIR/lastmanual
|
|
cat > $LASTFILE << _EOF
|
|
JOB_CANTPREPARE=(${JOB_CANTPREPARE[*]})
|
|
JOB_MISSINGREQ=(${JOB_MISSINGREQ[*]})
|
|
JOB_SENT=(${JOB_SENT[*]})
|
|
JOB_CANTINSTAL=(${JOB_CANTINSTALL[*]})
|
|
JOB_COMPLETED=(${JOB_COMPLETED[*]})
|
|
JOB_FAILED=(${JOB_FAILED[*]})
|
|
_EOF
|
|
}
|
|
|
|
function find_source_by_provide() {
|
|
local pkg=`echo $2 | sed "s|(|\\\\\[|g;s|)|\\\\\]|g;s|:|_|g"`
|
|
grep "^$pkg:" $DATADIR/$1/sources-* | \
|
|
awk '{ $1=""; print $0 }' | \
|
|
sed "s|[[:space:]]_| |g"
|
|
}
|
|
|
|
function find_requirements() {
|
|
[ "$1" ] || return 1
|
|
local tf=`mktemp` || {
|
|
echo "Error: cannot create tempfile"
|
|
return 1
|
|
}
|
|
local tf1=`mktemp`
|
|
local OUTFILE=$1
|
|
|
|
if [ "`grep " is needed by " $OUTFILE`" ]; then
|
|
grep " is needed by " $OUTFILE | awk '{ print $1 }' | tr -d \' > $tf1
|
|
elif [ "`grep " matches no packages" $OUTFILE`" ]; then
|
|
grep " matches no packages" $OUTFILE | awk '{ print $2 }' | tr -d \' | sed "s|@.*||" > $tf1
|
|
elif [ "`grep " no package provides " $OUTFILE`" ]; then
|
|
grep " no package provides " $OUTFILE | sed "s|.* no package provides ||" > $tf1
|
|
fi
|
|
|
|
[ `stat -c %s $tf1` -gt 0 ] && {
|
|
echo -n " | missing requirements: "
|
|
> $tf
|
|
sort -u $tf1 | while read line; do
|
|
REQ=`find_source_by_provide $PORT_REPOSITORY ${line}`
|
|
if [ "$REQ" ]; then
|
|
get_pkg_buildinfo $DATADIR/$PORT_REPOSITORY $TARGET_ARCH $REQ
|
|
if [ "$pkg_name" ]; then
|
|
echo -n "$line(notrebuilding) "
|
|
else
|
|
echo "${REQ}" >> $tf
|
|
fi
|
|
else
|
|
echo -n "$line(unresolved) "
|
|
fi
|
|
done
|
|
> $tf1
|
|
cat $tf | sort -u 2>/dev/null | while read line; do
|
|
if [ "`echo " ${JOB[*]} ${JOB_MISSINGREQ[*]} ${JOB_CANTINSTALL[*]} " | grep " $line "`" ]; then
|
|
echo -n "($line) "
|
|
else
|
|
echo -n "$line "
|
|
echo -n "$line " >> $tf1
|
|
fi
|
|
done
|
|
JOB_MISSINGREQ=(${JOB_MISSINGREQ[*]} `cat $tf1`)
|
|
echo
|
|
}
|
|
rm -f $tf $tf1
|
|
return 0
|
|
}
|
|
|
|
fetch_repfiles() {
|
|
local u
|
|
|
|
f=${DATADIR}/${PORT_REPOSITORY}/srcpkglist
|
|
if [ ! -e ${f} -o "`find ${f} -mmin +60 2>/dev/null`" ]; then
|
|
[ "$VERBOSE_MODE" = "1" ] && echo "Fetching ${REPS_BASE_URL}/$PORT_REPOSITORY/srcpkglist"
|
|
curl -f -L -s ${REPS_BASE_URL}/$PORT_REPOSITORY/srcpkglist -o ${f} ||
|
|
echo "Warning: unable to fetch ${REPS_BASE_URL}/$PORT_REPOSITORY/srcpkglist"
|
|
fi
|
|
for a in ${AUTODIST_ARCHS[*]}; do
|
|
f=${DATADIR}/${PORT_REPOSITORY}/sources-${a}
|
|
if [ ! -e ${f} -o "`find ${f} -mmin +60 2>/dev/null`" ]; then
|
|
[ "$VERBOSE_MODE" = "1" ] && echo "Fetching $PORT_REPOSITORY_DISTROMATIC_URL/sources-${a}"
|
|
curl -f -L -s $PORT_REPOSITORY_DISTROMATIC_URL/sources-${a} -o ${f} ||
|
|
echo "Warning: unable to fetch $PORT_REPOSITORY_DISTROMATIC_URL/sources-${a}"
|
|
fi
|
|
f=${DATADIR}/${PORT_REPOSITORY}/builds-${a}.sh
|
|
if [ ! -e ${f} -o "`find ${f} -mmin +60 2>/dev/null`" ]; then
|
|
[ "$VERBOSE_MODE" = "1" ] && echo "Fetching $PORT_REPOSITORY_DISTROMATIC_URL/builds-${a}.sh"
|
|
curl -f -L -s $PORT_REPOSITORY_DISTROMATIC_URL/builds-${a}.sh -o ${f} ||
|
|
echo "Warning: unable to fetch $PORT_REPOSITORY_DISTROMATIC_URL/builds-${a}.sh"
|
|
fi
|
|
done
|
|
for u in ${AUTOPORT_UNSTAGE_ARCHS}; do
|
|
[ "$u" = "$TARGET_ARCH" ] && {
|
|
rm -f $DATADIR/$PORT_REPOSITORY/unstage.$TARGET_ARCH
|
|
return
|
|
}
|
|
done
|
|
[ "$VERBOSE_MODE" = "1" ] && echo "Fetching ${REPS_BASE_URL}/${PORT_REPOSITORY/-*}/unstage.$TARGET_ARCH"
|
|
curl -f -L -s ${REPS_BASE_URL}/${PORT_REPOSITORY/-*}/unstage.$TARGET_ARCH -o $DATADIR/$PORT_REPOSITORY/unstage.$TARGET_ARCH ||
|
|
echo "Warning: unable to fetch ${REPS_BASE_URL}/${PORT_REPOSITORY/-*}/unstage.$TARGET_ARCH"
|
|
}
|
|
|
|
[ $# -gt 0 ] || { usage ; exit 1; }
|
|
|
|
[ "$BUILD_ARCH" ] || BUILD_ARCH=`uname -m`
|
|
|
|
case $BUILD_ARCH in
|
|
i386|i486|i686) BUILD_ARCH=i586 ;;
|
|
arm*) BUILD_ARCH=arm ;;
|
|
esac
|
|
|
|
TARGET_ARCHS=$BUILD_ARCH
|
|
JOB_CMDLINE=()
|
|
CROSS_MODE=
|
|
|
|
for ((i=1; i<=$#; i++)); do
|
|
case ${!i} in
|
|
-a) AUTO_MODE=1 ;;
|
|
-b) BATCH_MODE=1 ;;
|
|
-f) FORCE_MODE=1 ;;
|
|
-v) VERBOSE_MODE=1 ;;
|
|
-u) REBUILD_MODE=1
|
|
shift
|
|
REBUILD_CHANGELOG="${!i}"
|
|
[ "$REBUILD_CHANGELOG" ] || {
|
|
echo "ERROR: changelog not given as -u option parameter; aborting."
|
|
exit 1
|
|
}
|
|
;;
|
|
-ud) REBUILD_DEPENDANT_MODE=1
|
|
DONT_RECURSE=1
|
|
;;
|
|
-npa) DONT_PREPARE_ANY=1
|
|
DONT_PREPARE=1 ;;
|
|
-np) DONT_PREPARE=1 ;;
|
|
-nr) DONT_RECURSE=1 ;;
|
|
--fix) FIX_MODE=1 ;;
|
|
-r) shift
|
|
PORT_REPOSITORY="${!i}"
|
|
;;
|
|
-s) shift
|
|
SCRIPT_ARGS="${!i}"
|
|
;;
|
|
-d) shift
|
|
DEST_REPOSITORY="${!i}"
|
|
;;
|
|
-x) shift
|
|
TARGET_ARCHS="`echo ${!i} | tr , ' '`"
|
|
CROSS_MODE=1
|
|
;;
|
|
--user) let i+=1
|
|
[ "${!i}" ] || {
|
|
echo "Error: --user parameter not given, aborting."
|
|
exit 1
|
|
}
|
|
WEBBUILD_USER_CMDLINE="${!i}"
|
|
;;
|
|
-h|--help)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*) JOB_CMDLINE=(${JOB_CMDLINE[*]} ${!i})
|
|
;;
|
|
esac
|
|
done
|
|
|
|
[ "$DEST_REPOSITORY" ] || DEST_REPOSITORY=$PORT_REPOSITORY
|
|
|
|
if [ "$BATCH_MODE" ]; then
|
|
PIDFILE="/run/autodist/autoport-${BUILD_ARCH}-${PORT_REPOSITORY}.pid"
|
|
[ -e $PIDFILE ] && {
|
|
PIDCHECK=`cat $PIDFILE`
|
|
[ "$PIDCHECK" -a -e /proc/$PIDCHECK -a ! "$DISABLE_PID_CHECK" ] && {
|
|
echo "Error: autoport -b already running with PID=$PIDCHECK.Aborting."
|
|
exit 1
|
|
}
|
|
}
|
|
echo $$ > $PIDFILE
|
|
trap "rm -f $PIDFILE; exit 1" SIGQUIT SIGINT SIGKILL SIGTERM
|
|
fi
|
|
|
|
for TARGET_ARCH in ${TARGET_ARCHS}; do
|
|
|
|
JOBS_SKIPPED=()
|
|
JOBS_CANTPREPARE=()
|
|
JOBS_CANTINSTALL=()
|
|
JOB_MISSINGREQ=()
|
|
JOB_COMPLETED=()
|
|
JOB_FAILED=()
|
|
|
|
DATADIR=$HOME/.autoport
|
|
DATAARCHDIR=$DATADIR/$TARGET_ARCH
|
|
DISTROMATIC_BASE_URL=${REPS_BASE_URL}/distromatic/
|
|
BASE_REPOSITORY_DISTROMATIC_URL=${DISTROMATIC_BASE_URL}$BASE_REPOSITORY
|
|
PORT_REPOSITORY_DISTROMATIC_URL=${DISTROMATIC_BASE_URL}$PORT_REPOSITORY
|
|
|
|
[ -d $DATAARCHDIR ] || mkdir -p $DATAARCHDIR
|
|
[ -d $DATADIR/$BASE_REPOSITORY ] || mkdir -p $DATADIR/$BASE_REPOSITORY
|
|
[ -d $DATADIR/$PORT_REPOSITORY ] || mkdir -p $DATADIR/$PORT_REPOSITORY
|
|
|
|
logdate=`date +"%F@%T"`
|
|
logfile=$DATAARCHDIR/$logdate.log
|
|
[ -e $DATAARCHDIR/$PORT_REPOSITORY-current.log ] && mv $DATAARCHDIR/$PORT_REPOSITORY-current.log $DATAARCHDIR/$PORT_REPOSITORY-last.log
|
|
> $logfile
|
|
ln -sf $logdate.log $DATAARCHDIR/$PORT_REPOSITORY-current.log
|
|
|
|
BUILD_PLATFORM=`rpm --target $TARGET_ARCH --eval %{_build}`
|
|
BUILD_CPU=`echo $BUILD_PLATFORM | cut -d- -f1`
|
|
TARGET_PLATFORM=`rpm --target $TARGET_ARCH --eval %{_target_platform}`
|
|
TARGET_CPU=`echo $TARGET_PLATFORM | cut -d- -f1`
|
|
eval `autospec --eval spec_dir | tail -n1`
|
|
if [ "$spec_dir" ]; then
|
|
SPECDIR=$spec_dir
|
|
else
|
|
SPECDIR=`rpm --eval %{_specdir}`
|
|
fi
|
|
|
|
echo "Build platform is $BUILD_PLATFORM"
|
|
echo "Target platform is $TARGET_PLATFORM"
|
|
echo "Port repository is $PORT_REPOSITORY"
|
|
echo "Release repository is $DEST_REPOSITORY"
|
|
|
|
fetch_repfiles
|
|
|
|
[ "$AUTO_MODE" -a -e $DATAARCHDIR/last ] && . $DATAARCHDIR/last
|
|
if [ "$REBUILD_DEPENDANT_MODE" ]; then
|
|
for j in ${JOB_CMDLINE[*]}; do
|
|
get_pkg_buildinfo $DATADIR/$PORT_REPOSITORY $TARGET_ARCH $j
|
|
port_pkg_list=${pkg_needrebuild[*]}
|
|
port_pkg_builds=" ${pkg_builds[*]} "
|
|
port_pkg_epoch=$pkg_epoch
|
|
port_pkg_version=$pkg_version
|
|
port_pkg_release=$pkg_release
|
|
currrebuild=
|
|
currjobscriptargs=
|
|
JOBNUM=0
|
|
for p in ${port_pkg_list}; do
|
|
if [ "${p/@*}" != "$currrebuild" ]; then
|
|
[ $JOBNUM -gt 0 ] && JOB_SCRIPTARGS[$JOBNUM-1]="$currjobscriptargs"
|
|
currjobscriptargs=
|
|
currrebuild=${p/@*}
|
|
get_pkg_buildinfo $DATADIR/$PORT_REPOSITORY $TARGET_ARCH $currrebuild
|
|
for ignore_pkg in ${AUTOPORT_IGNORE_LIST}; do
|
|
[ "${currrebuild}" == "${ignore_pkg}" ] && continue
|
|
done
|
|
JOB=(${JOB[*]} $currrebuild)
|
|
let JOBNUM+=1
|
|
fi
|
|
currprovider=${p/*@}
|
|
if [ "${currprovider/-devel}" == "$currprovider" ]; then
|
|
currprovider=${currprovider}-devel
|
|
fi
|
|
add_epoch=""
|
|
[ "${port_pkg_epoch}" ] && add_epoch="${port_pkg_epoch}:"
|
|
currjobscriptargs="$currjobscriptargs --buildreq ${currprovider} >= ${add_epoch}${port_pkg_version}-${port_pkg_release} "
|
|
done
|
|
[ "$currjobscriptargs" ] && JOB_SCRIPTARGS[$JOBNUM-1]="$currjobscriptargs"
|
|
echo "Package dependant from $j to rebuild: ${JOB[*]}"
|
|
done
|
|
else
|
|
JOB=(${JOB_CMDLINE[*]} ${JOB_MISSINGREQ[*]} ${JOB_FAILED[*]})
|
|
fi
|
|
[ "$FIX_MODE" -o "$BATCH_MODE" -o "${JOB[*]}" ] || { echo "Nothing to do."; exit 0; }
|
|
|
|
if [ "$BATCH_MODE" ]; then
|
|
|
|
[ "${JOB[*]}" ] && {
|
|
echo "Error: no jobs allowed in batch mode; aborting."
|
|
exit 1
|
|
}
|
|
# old files cleanup
|
|
rm -f $DATADIR/$BASE_REPOSITORY/builds-*.sh
|
|
|
|
get_pkg_buildinfo $DATADIR/$PORT_REPOSITORY $TARGET_ARCH
|
|
port_pkg_list=${pkg_list[*]}
|
|
|
|
if [ "$REBUILD_MILESTONE" ]; then
|
|
for p in ${port_pkg_list}; do
|
|
get_pkg_buildinfo $DATADIR/$PORT_REPOSITORY $TARGET_ARCH $p
|
|
target_pkg_name=$pkg_name
|
|
target_pkg_ver=$pkg_version
|
|
target_pkg_rel=$pkg_release
|
|
target_pkg_milestone=`echo $target_pkg_rel | sed "s|[0-9.]*\(.*\)|\1|"`
|
|
if [ "$target_pkg_milestone" != "$REBUILD_MILESTONE" ]; then
|
|
JOB=(${JOB[*]} $p)
|
|
fi
|
|
done
|
|
echo "Packages to rebuild: ${JOB[*]}"
|
|
fi
|
|
echo "Packages to port: ${needport_list[*]}"
|
|
for p in ${needport_list[*]}; do
|
|
JOB=(${JOB[*]} $p)
|
|
done
|
|
|
|
[ -e $DATADIR/autoport-$PORT_REPOSITORY-current ] && \
|
|
mv $DATADIR/autoport-$PORT_REPOSITORY-current $DATADIR/autoport-$PORT_REPOSITORY-last
|
|
fi
|
|
|
|
step=0
|
|
tmpfile=`mktemp`
|
|
tmpfile1=`mktemp`
|
|
|
|
[ -e $DATAARCHDIR/sentjobs ] || > $DATAARCHDIR/sentjobs
|
|
find $DATAARCHDIR/sentjobs -cmin 120 >/dev/null && {
|
|
> $DATAARCHDIR/sentjobs
|
|
}
|
|
|
|
[ -e $DATAARCHDIR/preparedjobs ] || > $DATAARCHDIR/preparedjobs
|
|
find $DATAARCHDIR/preparedjobs -ctime 1 >/dev/null && {
|
|
> $DATAARCHDIR/preparedjobs
|
|
}
|
|
|
|
[ -e $DATAARCHDIR/updatedjobs ] || > $DATAARCHDIR/updatedjobs
|
|
find $DATAARCHDIR/updatedjobs -ctime 1 >/dev/null && {
|
|
> $DATAARCHDIR/updatedjobs
|
|
}
|
|
|
|
sudo autoport-fix-environment $TARGET_ARCH
|
|
|
|
[ "$FIX_MODE" ] && exit 0
|
|
|
|
[ "$FORCE_MODE" ] && FORCE_FLAG="--force"
|
|
|
|
while [ "${JOB[*]}" ]; do
|
|
step=`expr $step + 1`
|
|
[ $step -gt 1 ] && fetch_repfiles
|
|
[ "$BATCH_MODE" -a $step -gt $AUTOPORT_MAX_STEPS ] && {
|
|
echo "Maximum steps count reached for batch mode; exiting. See $logfile for details."
|
|
break
|
|
}
|
|
echo "=========="
|
|
echo "# Step $step"
|
|
echo "> Scheduled jobs: ${JOB[*]}"
|
|
echo
|
|
JOB_MISSINGREQ_OLD=(${JOB_MISSINGREQ[*]})
|
|
JOB_MISSINGREQ=()
|
|
JOB_MAYBEINSTALLED_NEW=()
|
|
JOB_FAILED_OLD=(${JOB_FAILED[*]})
|
|
JOB_FAILED=()
|
|
JOB_CANTINSTALL_OLD=(${JOB_CANTINSTALL[*]})
|
|
for JOB_NUM in `seq 1 ${#JOB[*]}`; do
|
|
JOB_CURRENT=${JOB[$JOB_NUM-1]/\#*}
|
|
if [ "${JOB_CURRENT}" != "${JOB[$JOB_NUM-1]}" ]; then
|
|
JOB_CURRENT_VERSION=${JOB[$JOB_NUM-1]/*\#}
|
|
else
|
|
JOB_CURRENT_VERSION=
|
|
fi
|
|
if [ ! -s $DATADIR/$PORT_REPOSITORY/unstage.${TARGET_ARCH} -o \
|
|
"`grep "^${JOB_CURRENT}$" /etc/autodist/unstage.${TARGET_ARCH} 2>/dev/null`" -o \
|
|
"`grep "^${JOB_CURRENT}$" $DATADIR/$PORT_REPOSITORY/unstage.${TARGET_ARCH} 2>/dev/null`" ]; then
|
|
echo -n "^ $JOB_CURRENT: "
|
|
STAGEOPTS=
|
|
else
|
|
echo -n "^ $JOB_CURRENT(staging): "
|
|
STAGEOPTS="$AUTOPORT_STAGEVARS"
|
|
fi
|
|
if [ "$CROSS_MODE" -a "${JOB_CURRENT:0:5}" == "perl-" ]; then
|
|
echo "< (SKIPPED) [unable to cross-build perl modules]"
|
|
JOB_SKIPPED=(${JOB_SKIPPED[*]} $JOB_CURRENT)
|
|
continue
|
|
fi
|
|
[ "`grep ^$JOB_CURRENT\$ $DATAARCHDIR/sentjobs`" -a ! "$FORCE_MODE" ] && {
|
|
echo "< (SKIPPED) [already sent]"
|
|
JOB_SKIPPED=(${JOB_SKIPPED[*]} $JOB_CURRENT)
|
|
continue
|
|
}
|
|
if [ "${JOB_MAYBEINSTALLED_NEW[*]}" = "" -a \
|
|
"${JOB_MISSINGREQ_OLD[*]}" != "" -a \
|
|
"`echo "( ${JOB_FAILED_OLD[*]} )"| grep " $JOB_CURRENT "`" ]; then
|
|
echo "< (FAILED) [nothing new since previous attempt]"
|
|
JOB_FAILED=(${JOB_FAILED[*]} $JOB_CURRENT)
|
|
continue
|
|
fi
|
|
get_pkg_srcinfo $DATADIR/$PORT_REPOSITORY ${JOB_CURRENT} || {
|
|
echo "< (FAILED) [error $? in get_pkg_srcinfo]"
|
|
JOB_FAILED=(${JOB_FAILED[*]} $JOB_CURRENT)
|
|
continue
|
|
}
|
|
if [ "$JOB_CURRENT_VERSION" -a \
|
|
"$JOB_CURRENT_VERSION" != "$src_version" -a \
|
|
"$JOB_CURRENT_VERSION" != "$src_version-$src_release" ]; then
|
|
echo "< (FAILED) [wrong version $src_version-$src_release != $JOB_CURRENT_VERSION]"
|
|
JOB_FAILED=(${JOB_FAILED[*]} $JOB_CURRENT)
|
|
continue
|
|
fi
|
|
|
|
DONT_PREPARE_THIS=
|
|
RELEASE_UPDATED=
|
|
grep -q ^$JOB_CURRENT\$ $DATAARCHDIR/preparedjobs && RELEASE_UPDATED=1
|
|
for p in ${JOB_CMDLINE[*]}; do
|
|
[ "$p" = "${JOB_CURRENT}" -o "$DONT_PREPARE_ANY" ] || continue
|
|
[ -e ${SPECDIR}/${JOB_CURRENT}.spec ] && DONT_PREPARE_THIS="$DONT_PREPARE"
|
|
done
|
|
[ ! "$DONT_PREPARE_THIS" -a ! "`grep ^$JOB_CURRENT\$ $DATAARCHDIR/preparedjobs`" ] && {
|
|
echo -n "prepare"
|
|
if [ ! "$REBUILD_DEPENDANT_MODE" -a "$step" = "1" ]; then
|
|
REPOSITORY_STRICT_ADD="--repository-strict"
|
|
else
|
|
REPOSITORY_STRICT_ADD=""
|
|
fi
|
|
# [ "$VERBOSE_MODE" ] && echo "
|
|
#%% COMMAND: LANG=C LC_ALL=C autodist -p ${JOB_CURRENT} --server $PORT_REPOSITORY --repository $PORT_REPOSITORY $REPOSITORY_STRICT_ADD --severity 2 -- $STAGEOPTS"
|
|
LANG=C LC_ALL=C autodist -p ${JOB_CURRENT} --server $PORT_REPOSITORY --repository $PORT_REPOSITORY $REPOSITORY_STRICT_ADD --severity 2 -- $STAGEOPTS &>$tmpfile
|
|
[ $? -gt 0 ] && {
|
|
echo "(FAILED) "
|
|
JOB_CANTPREPARE=(${JOB_CANTPREPARE[*]} $JOB_CURRENT)
|
|
autoport_log ${JOB_CURRENT} prepare failed $tmpfile
|
|
continue
|
|
} || {
|
|
spec_version=`grep -m1 "^Version:" ${SPECDIR}/${JOB_CURRENT}.spec | awk '{ print $2}'`
|
|
spec_release=`grep -m1 "^Release:" ${SPECDIR}/${JOB_CURRENT}.spec | awk '{ print $2}'`
|
|
if [ "${spec_version}-${spec_release}" != "$src_version-$src_release" ]; then
|
|
echo "< (FAILED) [wrong version ${src_version}-${src_release} != ${spec_version}-${spec_release}]"
|
|
JOB_CANTPREPARE=(${JOB_CANTPREPARE[*]} $JOB_CURRENT)
|
|
autoport_log ${JOB_CURRENT} prepare failed $tmpfile
|
|
continue
|
|
fi
|
|
echo $JOB_CURRENT >> $DATAARCHDIR/preparedjobs
|
|
echo -n "(OK) "
|
|
autoport_log ${JOB_CURRENT} prepare ok $tmpfile
|
|
}
|
|
if [ "$REBUILD_MODE" = "1" -o "$REBUILD_DEPENDANT_MODE" = "1" ]; then
|
|
echo -n "update"
|
|
if [ "$REBUILD_DEPENDANT_MODE" ]; then
|
|
SCRIPT_ARGS="${JOB_SCRIPTARGS[$JOB_NUM-1]}"
|
|
changelogadd="`echo ${SCRIPT_ARGS} | sed "s|--buildreq|,|g;s| ||g;s|^,||g"`"
|
|
REBUILD_CHANGELOG="rebuilt by autoport with build requirements: '${changelogadd}'"
|
|
fi
|
|
# [ "$VERBOSE_MODE" ] && echo "
|
|
#%% COMMAND: LANG=C LC_ALL=C autodist -u --rebuild -r ${JOB_CURRENT} --severity 2 -- $STAGEOPTS --changelog \"$REBUILD_CHANGELOG\" --- \"$SCRIPT_ARGS\""
|
|
LANG=C LC_ALL=C autodist -u --rebuild -r ${JOB_CURRENT} --severity 2 -- $STAGEOPTS --changelog \"$REBUILD_CHANGELOG\" --- $SCRIPT_ARGS &>$tmpfile
|
|
[ $? -gt 0 ] && {
|
|
echo "(FAILED) "
|
|
autoport_log ${JOB_CURRENT} update failed $tmpfile
|
|
continue
|
|
} || {
|
|
autoport_log ${JOB_CURRENT} update ok $tmpfile
|
|
echo -n "(OK) "
|
|
RELEASE_UPDATED=1
|
|
echo $JOB_CURRENT >> $DATAARCHDIR/updatedjobs
|
|
}
|
|
elif [ "$PORT_REPOSITORY" != "$DEST_REPOSITORY" ]; then
|
|
echo -n "update"
|
|
# [ "$VERBOSE_MODE" ] && echo "
|
|
#%% COMMAND: LANG=C LC_ALL=C autodist -u -r ${JOB_CURRENT} --severity 2 -- $STAGEOPTS --changelog \"automatic port from $PORT_REPOSITORY\""
|
|
LANG=C LC_ALL=C autodist -u -r ${JOB_CURRENT} --severity 2 -- $STAGEOPTS --changelog \"automatic port from $PORT_REPOSITORY\" --- $SCRIPT_ARGS &>$tmpfile
|
|
cat $tmpfile >> $logfile
|
|
[ $? -gt 0 ] && {
|
|
echo "(FAILED) "
|
|
autoport_log ${JOB_CURRENT} update failed $tmpfile
|
|
continue
|
|
} || {
|
|
autoport_log ${JOB_CURRENT} update ok $tmpfile
|
|
echo -n "(OK) "
|
|
RELEASE_UPDATED=1
|
|
}
|
|
elif [ "$REBUILD_MILESTONE" -a "$src_milestone" != "$REBUILD_MILESTONE" ]; then
|
|
echo -n "update"
|
|
[ "$src_repository" -a "$src_version" -a "$src_release" ] || {
|
|
echo "(FAILED) [can't get repository information for this package]"
|
|
continue
|
|
}
|
|
src_release_num=`echo $src_release | sed "s|\([0-9.]*\).*|\1|"`
|
|
# [ "$VERBOSE_MODE" ] && echo "
|
|
#%% COMMAND: LANG=C LC_ALL=C autospec -u ${JOB_CURRENT} -a4 --changelog \"$REBUILD_MILESTONE milestone rebuild\" $src_version $src_release_num${REBUILD_MILESTONE}"
|
|
# FIXME: should be implemented in autodist
|
|
LANG=C LC_ALL=C autospec -u ${JOB_CURRENT} -a4 --changelog "$REBUILD_MILESTONE milestone rebuild" $src_version $src_release_num${REBUILD_MILESTONE} &>$tmpfile
|
|
[ $? -gt 0 ] && {
|
|
if [ "$VERBOSE_MODE" ]; then
|
|
echo
|
|
echo "= Failed output:"
|
|
echo "================"
|
|
cat $tmpfile
|
|
echo "================"
|
|
echo
|
|
fi
|
|
cat $tmpfile >> $logfile
|
|
JOB_FAILED=(${JOB_FAILED[*]} $JOB_CURRENT)
|
|
echo "(FAILED)"
|
|
JOB_LOG=`grep "^?= See " $tmpfile | awk '{ print $3 }'`
|
|
[ "$JOB_LOG" ] || JOB_LOG=$tmpfile
|
|
autoport_log ${JOB_CURRENT} update failed $tmpfile
|
|
continue
|
|
} || {
|
|
cat $tmpfile >> $logfile
|
|
echo -n "(OK) "
|
|
autoport_log ${JOB_CURRENT} update ok $tmpfile
|
|
RELEASE_UPDATED=1
|
|
}
|
|
fi
|
|
}
|
|
echo -n "port"
|
|
if [ ! "$src_repository" -a "$DONT_PREPARE_THIS" != "1" ]; then
|
|
echo "(FAILED) [can't get repository information for this package]"
|
|
autoport_log ${JOB_CURRENT} port failed
|
|
continue
|
|
fi
|
|
SEND_REPOSITORY=$DEST_REPOSITORY
|
|
if [ ! "$RELEASE_UPDATED" -a ! "$DONT_PREPARE_THIS" ]; then
|
|
SEND_REPOSITORY=$src_repository
|
|
fi
|
|
[ ! "$DONT_PREPARE_THIS" -a ! "$RELEASE_UPDATED" ] && NOSRPM_OPTS="--nosrpm" || NOSRPM_OPTS="--force"
|
|
# [ "$VERBOSE_MODE" ] && echo "
|
|
#%% COMMAND: LANG=C LC_ALL=C autodist -b -s ${JOB_CURRENT} --arch $TARGET_ARCH --server $SEND_REPOSITORY --repository $PORT_REPOSITORY --severity 2 $FORCE_FLAG -- $STAGEOPTS $NOSRPM_OPTS"
|
|
LANG=C LC_ALL=C autodist -b -s ${JOB_CURRENT} --arch $TARGET_ARCH --server $SEND_REPOSITORY --repository $PORT_REPOSITORY --severity 2 $FORCE_FLAG -- $STAGEOPTS $NOSRPM_OPTS &>$tmpfile
|
|
[ $? -gt 0 ] && {
|
|
if [ "$VERBOSE_MODE" ]; then
|
|
echo
|
|
echo "= Failed output:"
|
|
echo "================"
|
|
cat $tmpfile
|
|
echo "================"
|
|
echo
|
|
fi
|
|
cat $tmpfile >> $logfile
|
|
JOB_FAILED=(${JOB_FAILED[*]} $JOB_CURRENT)
|
|
echo "(FAILED)"
|
|
JOB_LOG=`grep "^?= See " $tmpfile | awk '{ print $3 }'`
|
|
[ "$JOB_LOG" ] || JOB_LOG=$tmpfile
|
|
[ ! "$REBUILD_MILESTONE" ] && find_requirements $JOB_LOG
|
|
autoport_log ${JOB_CURRENT} port failed $tmpfile
|
|
continue
|
|
} || {
|
|
cat $tmpfile >> $logfile
|
|
JOB_SENT=(${JOB_SENT[*]} $JOB_CURRENT)
|
|
echo $JOB_CURRENT >> $DATAARCHDIR/sentjobs
|
|
echo -n "(OK) "
|
|
autoport_log ${JOB_CURRENT} port ok $tmpfile
|
|
if [ "$WEBBUILD_URL" -a "$WEBBUILD_USER" ]; then
|
|
if [ "$WEBBUILD_USER_CMDLINE" ]; then
|
|
curl -s "$WEBBUILD_URL?REQUEST=message&USER=$WEBBUILD_USER&\
|
|
SECRET=`cgi_encodevar ${WEBBUILD_SECRET}`&USER_EMAIL=$WEBBUILD_EMAIL&\
|
|
MESSAGE=`cgi_encodevar \"(invoked by $WEBBUILD_USER_CMDLINE) ported <b>$JOB_CURRENT</b> to <b>$TARGET_ARCH</b> and sent it to <b>$SEND_REPOSITORY</b>\"`" >/dev/null
|
|
else
|
|
curl -s "$WEBBUILD_URL?REQUEST=message&USER=$WEBBUILD_USER&\
|
|
SECRET=`cgi_encodevar ${WEBBUILD_SECRET}`&USER_EMAIL=$WEBBUILD_EMAIL&\
|
|
MESSAGE=`cgi_encodevar \"ported <b>$JOB_CURRENT</b> to <b>$TARGET_ARCH</b> and sent it to <b>$SEND_REPOSITORY</b>\"`" >/dev/null
|
|
fi
|
|
fi
|
|
}
|
|
echo -n "install"
|
|
LANG=C LC_ALL=C autodist -i ${JOB_CURRENT} --arch $TARGET_ARCH --force --severity 2 -- $STAGEOPTS &>$tmpfile
|
|
# --server $DEST_REPOSITORY --repository $PORT_REPOSITORY
|
|
[ $? -gt 0 ] && {
|
|
if [ "$VERBOSE_MODE" ]; then
|
|
echo
|
|
echo "= Failed output:"
|
|
echo "================"
|
|
cat $tmpfile
|
|
echo "================"
|
|
echo
|
|
fi
|
|
cat $tmpfile >> $logfile
|
|
JOB_CANTINSTALL=(${JOB_CANTINSTALL[*]} $JOB_CURRENT)
|
|
echo $JOB_CURRENT >> $DATAARCHDIR/checkinstalljobs
|
|
echo "(FAILED)"
|
|
# sometimes script fails but package is installed; run fix_la_files anyway
|
|
sudo autoport-fix-environment $TARGET_ARCH
|
|
|
|
JOB_MAYBEINSTALLED_NEW=(${JOB_MAYBEINSTALLED_NEW[*]} $JOB_CURRENT)
|
|
JOB_LOG=`grep "^?= See " $tmpfile | awk '{ print $3 }'`
|
|
[ "$JOB_LOG" ] || JOB_LOG=$tmpfile
|
|
[ ! "$REBUILD_MILESTONE" ] && find_requirements $JOB_LOG
|
|
autoport_log ${JOB_CURRENT} install failed $tmpfile
|
|
continue
|
|
} || {
|
|
cat $tmpfile >> $logfile
|
|
sudo autoport-fix-environment $TARGET_ARCH
|
|
JOB_MAYBEINSTALLED_NEW=(${JOB_MAYBEINSTALLED_NEW[*]} $JOB_CURRENT)
|
|
JOB_COMPLETED=(${JOB_COMPLETED[*]} $JOB_CURRENT)
|
|
echo -n "(OK)"
|
|
autoport_log ${JOB_CURRENT} install ok $tmpfile
|
|
}
|
|
echo
|
|
done
|
|
if [ "${JOB[*]}" == "${JOB_FAILED[*]}" -a "${JOB_MISSINGREQ[*]}" == "" ]; then
|
|
# some new build, retry cantinstall jobs
|
|
JOB_CANTINSTALL=()
|
|
for JOB_NUM in `seq 1 ${#JOB_CANTINSTALL_OLD[*]}`; do
|
|
JOB_CURRENT=${JOB_CANTINSTALL_OLD[$JOB_NUM-1]}
|
|
if [ "`grep "^${JOB_CURRENT}$" /etc/autodist/unstage.${TARGET_ARCH} 2>/dev/null`" -o \
|
|
"`grep "^${JOB_CURRENT}$" $DATADIR/$PORT_REPOSITORY/unstage.$TARGET_ARCH 2>/dev/null`" ]; then
|
|
echo -n "$JOB_CURRENT: "
|
|
STAGEOPTS=
|
|
else
|
|
echo -n "$JOB_CURRENT(staging): "
|
|
STAGEOPTS="$AUTOPORT_STAGEVARS"
|
|
fi
|
|
echo -n "retryinstall"
|
|
LANG=C LC_ALL=C autodist -i ${JOB_CURRENT} --arch $TARGET_ARCH --force --severity 2 -- $STAGEOPTS &>>$tmpfile
|
|
# --server $DEST_REPOSITORY --repository $PORT_REPOSITORY
|
|
[ $? -gt 0 ] && {
|
|
if [ "$VERBOSE_MODE" ]; then
|
|
echo
|
|
echo "= Failed output:"
|
|
echo "================"
|
|
cat $tmpfile
|
|
echo "================"
|
|
echo
|
|
fi
|
|
cat $tmpfile >> $logfile
|
|
JOB_CANTINSTALL=(${JOB_CANTINSTALL[*]} $JOB_CURRENT)
|
|
echo $JOB_CURRENT >> $DATAARCHDIR/checkinstalljobs
|
|
echo "(FAILED)"
|
|
# sometimes script fails but package is installed; run fix_la_files anyway
|
|
sudo autoport-fix-environment $TARGET_ARCH
|
|
|
|
JOB_MAYBEINSTALLED_NEW=(${JOB_MAYBEINSTALLED_NEW[*]} $JOB_CURRENT)
|
|
JOB_LOG=`grep "^?= See " $tmpfile | awk '{ print $3 }'`
|
|
[ "$JOB_LOG" ] || JOB_LOG=$tmpfile
|
|
find_requirements $JOB_LOG
|
|
continue
|
|
} || {
|
|
cat $tmpfile >> $logfile
|
|
sudo autoport-fix-environment $TARGET_ARCH
|
|
JOB_MAYBEINSTALLED_NEW=(${JOB_MAYBEINSTALLED_NEW[*]} $JOB_CURRENT)
|
|
JOB_COMPLETED=(${JOB_COMPLETED[*]} $JOB_CURRENT)
|
|
echo -n "(OK)"
|
|
autoport_log ${JOB_CURRENT} retryinstall ok $tmpfile
|
|
}
|
|
echo
|
|
done
|
|
fi
|
|
echo "| Skipped jobs: ${JOB_SKIPPED[*]}"
|
|
echo "| Unpreparable jobs: ${JOB_CANTPREPARE[*]}"
|
|
echo "| Missing requirements: ${JOB_MISSINGREQ[*]}"
|
|
echo "| Completed jobs: ${JOB_COMPLETED[*]}"
|
|
echo "| Installation error for: ${JOB_CANTINSTALL[*]}"
|
|
echo "| Failed jobs: ${JOB_FAILED[*]}"
|
|
write_last_file
|
|
|
|
[ "${JOB[*]}" == "${JOB_FAILED[*]}" -a \
|
|
"${JOB_MISSINGREQ[*]}" == "" -a \
|
|
"${JOB_CANTINSTALL_OLD[*]}" == "${JOB_CANTINSTALL[*]}" ] && {
|
|
echo "! Loop detected. Finishing. See $logfile for details."
|
|
rm -f $tmpfile $tmpfile1
|
|
exit 1
|
|
}
|
|
[ "$DONT_RECURSE" ] && break
|
|
JOB=(${JOB_MISSINGREQ[*]} ${JOB_FAILED[*]})
|
|
done
|
|
rm -f $tmpfile $tmpfile1
|
|
done
|
|
echo "* All jobs completed. See $logfile for details."
|
|
[ "$BATCH_MODE" ] && rm -f $PIDFILE
|
|
exit ${#JOB_FAILED[*]}
|