autodist/autodist

1396 lines
51 KiB
Bash
Executable File

#!/bin/bash
#
# Autodist -- batch build tool for RPM based distributions
# Copyright (C) 2006-2016 by Silvan Calarco <silvan.calarco@mambasoft.it>
#
# Released under the terms of the GNU GPL release 3 license
#
VERSION=1.5.3
me=(${0##*/} $VERSION "Tue Jan 26 2016")
exec 3>`readlink /proc/self/fd/0`
function usage() {
echo "\
${me[0]} ${me[1]}
"$"Copyright (C) 2006-2016 Silvan Calarco <silvan.calarco@mambasoft.it>""
"$"Released under the terms of the GNU GPL v3 license"
echo "
"$"Batch build tool for bulding a whole distribution and much more.""
"$"Usage"":
$me [operations ...] [options ...] [job ...] [-- autospec_args] [--- script_args]
"$"Operations"":
-a,--autobuild "$"Start batch build operations (implies -p -u -b -s --severity 1)""
-p,--prepare "$"Prepare packages (download and prepare for update)""
-u,--update "$"Update packages""
-b,--build "$"Build packages""
-i,--install "$"Install packages on local system""
-s,--send "$"Send packages to repository""
--list-jobs "$"List configured jobs""
--list-pkgs job "$"List packages for specified job""
"$"Options"":
-c,--cleanlogs "$"Clean all logs before starting""
-d,--debug "$"Enable print of debugging information""
-h,--help "$"Print this help, then exit""
-t,--test "$"Just simulate the execution of programs""
-q,--quiet "$"Be quiet (don't display tail of error logs)""
-r,--rebuild "$"Rebuild packages""
-v,--verbose "$"Be verbose""
--force "$"Pass force parameter to autospec""
--repository "$"Pass given repository as base for operations""
--repository-strict "$"Only prepare packages from base repository specified with --repository""
--server num "$"Pass given server number to autospec for send operation""
--severity num "$"Error handling level:
0: don't stop
1: skip current job on error (default)
2: abort on error""
--arch "$"Build packages for specified target architecture""
--user user "$"Pass calling user name for Webbuild social messages""
--rebuild-srpms "$"Rebuild SRPMs when sending""
job "$"Job specification in the form pkg#version, job#version, job/pkg#version, examples:
glibc#2.11.1
kernel-extra
kernel-packages/lirc""
autospec_args "$"Send specified arguments to autospec""
script_args "$"Send specified arguments to update-specfile script""
"
}
function fetch_repository_file() {
local REPOFILE=$1
if [ -r ${LOCAL_REPS_BASE_DIR}/$REPOFILE ]; then
echo ${LOCAL_REPS_BASE_DIR}/$REPOFILE
return 0
else
if [ ! -r $USERCONFDIR/$REPOFILE -o "`find $USERCONFDIR/$REPOFILE -mmin +60 2>/dev/null`" ]; then
mkdir -p `dirname $USERCONFDIR/$REPOFILE`
curl -f -L -s $REPS_BASE_URL/$REPOFILE -o $USERCONFDIR/$REPOFILE || return 1
fi
echo $USERCONFDIR/$REPOFILE
return 0
fi
}
[ $# -gt 0 ] || { usage ; exit 1; }
DATE_NOW=`LANG=C date +%s`
BUILDTIME=`date -Iseconds`
SYSCONFDIR=/etc/autodist
LOCALSTATEDIR=/var/autodist
[ "$USER" = "autodist" ] && USERCONFDIR=$LOCALSTATEDIR || USERCONFDIR=$HOME/.autodist
LOGBASEDIR=$USERCONFDIR/log
RPMTMPPATH=/var/tmp/autodist
SCRIPTDIR=$SYSCONFDIR/scripts
DISTDB=$SYSCONFDIR/distdb
DISTDBDIR=$SYSCONFDIR/distdb.d/
BLACKLIST=$SYSCONFDIR/blacklist
LEGACYLIST=$SYSCONFDIR/legacy
BUILDARCH=`rpm --eval %{_build_cpu}`
TARGETARCH=$BUILDARCH
CONFIGFILE=$SYSCONFDIR/config
SCRIPT_UPDATE_SPECFILE=$SCRIPTDIR/update-specfile
SCRIPT_UPDATE_SPECFILE_CUSTOM=$SCRIPTDIR/update-specfile-custom
AUTOSPEC_CMD="/usr/bin/autospec"
PIDFILE="/run/autodist/autodist.pid"
# Configuration defaults normally overriden in configuration file
AUTOBUILD_MAXNUM=50
AUTOBUILD_DATEFROM=20070101
AUTODIST_REPOSITORY=
SEND_SERVER=
[ -r $CONFIGFILE ] && . $CONFIGFILE
# init environment especially to have a full PATH when executed by crond with
# system init PATH
. /etc/profile
. /etc/profile.d/*.sh
export PATH
# error handling severity: 0=don't stop; 1=skip; 2=stop
SEVERITY=1
for ((i=1; i<=$#; i++)); do
case ${!i} in
-a|--autobuild) do_autobuild=1;
do_prepare=1;
do_update=1;
do_build=1;
do_send=1;
SEVERITY=1
;;
-c|--cleanlogs) do_cleanlogs=1 ;;
-h|--help) usage
exit 0
;;
-p|--prepare) do_prepare=1 ;;
-u|--update) do_update=1 ;;
-r|--rebuild) rebuild_packages=1 ;;
-b|--build) do_build=1 ;;
-d|--debug) debug=1 ;;
-i|--install) do_install=1 ;;
-s|--send) do_send=1 ;;
-t|--test) simulate=1 ;;
-q|--quiet) quiet=1 ;;
-v|--verbose) verbose=1 ;;
--list-jobs) do_listjobs=1 ;;
--list-pkgs) do_listpkgs=1
let i+=1
[ "${!i}" ] || {
echo "Error: job parameter not given, aborting."
exit 1
}
LISTPKGSJOB="${!i}"
;;
--force) SEND_FORCE="--force"
SEND_FORCE_BUILD="--force-build"
;;
--server) let i+=1
[ "${!i}" ] || {
echo "Error: --server parameter not given, aborting."
exit 1
}
SEND_SERVER="${!i}"
;;
--repository) let i+=1
[ "${!i}" ] || {
echo "Error: --repository parameter not given, aborting."
exit 1
}
AUTODIST_REPOSITORY="${!i}"
;;
--repository-strict)
REPOSITORY_STRICT=1
;;
--severity) let i+=1
[ "${!i}" ] || {
echo "Error: --severity parameter not given, aborting."
exit 1
}
SEVERITY=${!i}
;;
--arch) let i+=1
[ "${!i}" ] || {
echo "Error: --arch parameter not given, aborting."
exit 1
}
TARGETARCH=${!i}
;;
--user) let i+=1
[ "${!i}" ] || {
echo "Error: --user parameter not given, aborting."
exit 1
}
WEBBUILD_USER_CMDLINE="${!i}"
;;
--rebuild-srpms)
REBUILD_SRPMS=1
;;
-*) if [ "${!i}" = "--" ]; then
AUTOSPEC_ARGS_MODE=1
SCRIPT_ARGS_MODE=
elif [ "${!i}" = "---" ]; then
SCRIPT_ARGS_MODE=1
AUTOSPEC_ARGS_MODE=
elif [ "$AUTOSPEC_ARGS_MODE" ]; then
AUTOSPEC_ARGS="$AUTOSPEC_ARGS ${!i}"
elif [ "$SCRIPT_ARGS_MODE" ]; then
SCRIPT_ARGS="$SCRIPT_ARGS ${!i}"
else
echo "ERROR: invalid option \`${!i}'; aborting."
exit 1
fi
;;
*) if [ "$AUTOSPEC_ARGS_MODE" ]; then
if [ "${!i/ }" != "${!i}" ]; then
# pass multiple word arguments inside quotation marks
AUTOSPEC_ARGS="$AUTOSPEC_ARGS \"${!i}\""
else
AUTOSPEC_ARGS="$AUTOSPEC_ARGS ${!i}"
fi
elif [ "$SCRIPT_ARGS_MODE" ]; then
if [ "${!i/ }" != "${!i}" ]; then
# pass multiple word arguments inside quotation marks
SCRIPT_ARGS="$SCRIPT_ARGS \"${!i}\""
else
SCRIPT_ARGS="$SCRIPT_ARGS ${!i}"
fi
else
JOBIDX=${#JOBNAME[@]}
JOBNAME[$JOBIDX]="${!i/\#*}"
[ "${!i/*\#}" != "${!i}" ] && JOBVER[$JOBIDX]="+${!i/*\#}"
fi
;;
esac
done
if [ "$do_autobuild" ]; then
if [ -e $PIDFILE ]; then
PIDCHECK=`cat $PIDFILE`
if [ "$PIDCHECK" -a -e /proc/$PIDCHECK -a ! "$DISABLE_PID_CHECK" ]; then
echo "Error: autodist -a already running with PID=$PIDCHECK.Aborting."
exit 0
fi
fi
fi
[ "$AUTODIST_REPOSITORY" ] || AUTODIST_REPOSITORY=devel-autodist
[ "$SEND_SERVER" ] || SEND_SERVER=$AUTODIST_REPOSITORY
SEND_SERVER_CMD="--server $SEND_SERVER"
# perform arch names conversions
case $BUILDARCH in
i386|i486|i686) BUILDARCH=i586 ;;
esac
case $TARGETARCH in
i386|i486|i686) TARGETARCH=i586 ;;
esac
# 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 tempfile() {
local tmpfile
tmpfile=`mktemp -q -t $me.XXXXXXXX` || {
echo "ERROR: cannot create temporary files." >&2
exit 1
}
trap "rm -f $tmpfile" 0 1 2 5 15
> $tmpfile || {
echo "ERROR: cannot write to temporary files." >&2
exit 1
}
echo $tmpfile
}
function version_compare()
{
local A B
A=$1
B=$2
if [ ${A/[a-zA-Z_]*} -gt ${B/[a-zA-Z_]*} ]; then
return 1
elif [ ${A/[a-zA-Z_]*} -lt ${B/[a-zA-Z_]*} ]; then
return 2
else
if [[ "$A" > "$B" ]]; then
return 1
elif [[ "$A" < "$B" ]]; then
return 2
fi
fi
return 0
}
function version_find_bigger()
{
local VER1 VER2 FPOS CUTVER1 CUTVER2
VER1=$1
VER2=$2
FPOS=1
while true; do
CUTVER1=`echo $VER1. | cut -d. -f $FPOS`
CUTVER2=`echo $VER2. | cut -d. -f $FPOS`
if [ "$CUTVER1" -a ! "$CUTVER2" ]; then
return 1
elif [ "$CUTVER2" -a ! "$CUTVER1" ]; then
return 2
elif [ ! "$CUTVER1" -a "$CUTVER2" ]; then
return 0
else
version_compare $CUTVER1 $CUTVER2
case $? in
1) return 1 ;;
2) return 2 ;;
esac
fi
FPOS=`expr $FPOS + 1`
done
return 0
}
function tail_file() {
local elapsedtime elapsedstring elapsedcount phase lastprinttime newtime begintime lines c difftimestep
c=0
lines=0
begintime=`LANG=C date +%s`
lastlinetime=$begintime
lastprinttime=0
if [ "$do_autobuild" ]; then
difftimestep=1800
else
difftimestep=1
fi
while read line; do
echo "$line" >> $1
let lines+=1
newtime=`LANG=C date +%s`
let difftime=$newtime-$lastprinttime
case $verbose in
1) echo "$line"
;;
*) if [ $difftime -gt $difftimestep ]; then
let c+=1
lastprinttime=$newtime
let elapsedtime=$newtime-$begintime
[ $elapsedtime -gt 0 ] && let speed=$lines/$elapsedtime
case $c in
1) phase="|" ;;
2) phase="/" ;;
3) phase="-" ;;
4) phase="\\"
let c=0 ;;
esac
elapsedstring="`expr $elapsedtime % 60`s"
elapsedcount=`expr $elapsedtime / 60`
[ $elapsedcount -gt 0 ] && elapsedstring="`expr $elapsedcount % 60`m $elapsedstring"
elapsedcount=`expr $elapsedcount / 60`
[ $elapsedcount -gt 0 ] && elapsedstring="${elapsedcount}h $elapsedstring"
[ ! "$do_autobuild" ] && echo -n -e "\r"
echo -n "$2 $phase ($lines lines, $elapsedstring, $speed l/s)"
fi
;;
esac
done
}
get_job_vector() {
# note: if JOB_NAME contains a "-" or "." translate it to "_"
local JTARGET=${1/\/*}
local JPKG=
[ "$JTARGET" != "$1" ] && JPKG="${1/*\/}"
local JNAME=`echo $JTARGET | tr - _ | tr . _ | tr @ _`
if [[ ${JNAME:0:1} =~ [0-9] ]]; then
# prepend a underscore to job names starting with a number (e.g. 54321)
JNAME="_$JNAME"
fi
# resolve JOB_NAME from distdb
local jobtmpfile=`tempfile`
# hack to get an array variable named as $j assigned to the JOB array
echo "echo \${$JNAME[*]}" > $jobtmpfile
JOB=(`. $jobtmpfile`)
rm -f $jobtmpfile
if [ ${#JOB[*]} -eq 0 ]; then
# create a default job with given JOB_NAME
JOB=($JTARGET "" "")
elif [ ${#JOB[*]} -eq 1 ]; then
# no variables defined, add an empty job
JOB=(${JOB[*]} "" "")
elif [ "${JPKG}" ]; then
TMPJOB=($JPKG)
for i in `seq 1 ${#JOB[*]}`; do
TMPJOB=(${TMPJOB[*]} "${JOB[$i]}")
done
JOB=(${TMPJOB[*]})
fi
JOB_PKGS=(${JOB[0]//,/ })
JOB_VARNAMES=(${JOB[1]//,/ })
}
function autobuild_log() {
local pkg=$1
local operation=$2
local result=$3
local job=$4
local logfile=$5
[ "$pkg" -a "$operation" -a "$result" ] || return
if [ "$job" -a "$job" != "$pkg" ]; then
echo "$job/$pkg $operation $result $logfile" >> $LOGBASEDIR/autoupdate-current
else
echo "$pkg $operation $result $logfile" >> $LOGBASEDIR/autoupdate-current
fi
}
function launch_pkgs_loop() {
# This function iterates the passed operation for each package (column) in job
#
# $1: operation (prepare, update, build, send, install)
# $2: options
# $3: job variables (e.g. i386,std)
local JOB_VALUES JOB_ARGS JOB_IDX DEFINES_STRING i a PKGLINE
local cross_target_cpu autodist_crossonly operation
# evaluate job variables
JOB_VALUES=(${3//,/ })
JOB_IDX=$4
[ "$debug" = "1" ] && JOB_ARGS="--debug " || JOB_ARGS=""
[ $JOB_IDX ] || JOB_IDX=0
operation="$1"
passed_arguments="$2"
ret=0
DEFINES_STRING=""
if [ "$TARGETARCH" != "$BUILDARCH" ]; then
TARGET_PLATFORM=`rpm --target ${TARGETARCH} --eval %{_target_platform}`
JOB_ARGS="$JOB_ARGS-A \"${TARGETARCH}\" --root /usr/${TARGET_PLATFORM} "
DEFINES_STRING="--define _host_cpu=\"${TARGETARCH}\",_target_cpu=\"${TARGETARCH}\""
fi
cross_target_cpu=""
autodist_crossonly=""
patch_operation=$operation
continue_on_error=
for i in `seq 1 ${#JOB_VALUES[*]}`; do
[ "${JOB_VALUES[$i-1]}" = "-" ] || \
case ${JOB_VARNAMES[$i-1]} in
%build_and_install)
[ "$operation" = "build" ] && operation=buildinstall
;;
%continue_on_error)
continue_on_error=1
;;
%*)
echo "!! Warning: skipping unknown internal variable: ${JOB_VARNAMES[$i-1]}"
;;
autodist_crossonly)
autodist_crossonly=1
;;
cross_target_cpu)
cross_target_cpu="${JOB_VALUES[$i-1]}"
# don't specify cross_target_cpu for non-cross-target builds
if [ "$cross_target_cpu" = "$TARGETARCH" ]; then
# set cross_target_cpu as don't use
JOB_VALUES[$i-1]="-"
else
[ "$DEFINES_STRING" ] &&
DEFINES_STRING="${DEFINES_STRING}," ||
DEFINES_STRING="--define "
DEFINES_STRING="${DEFINES_STRING}${JOB_VARNAMES[$i-1]}=$cross_target_cpu"
fi
;;
target)
# specific target build was specified, don't build packages containing explicit different target
[ "$BUILDARCH" != "$TARGETARCH" -a "${JOB_VALUES[$i-1]}" != "$TARGETARCH" ] && return 0;
JOB_ARGS="$JOB_ARGS-A \"${JOB_VALUES[$i-1]}\" "
;;
*)
if [ "${JOB_VALUES[$i-1]}" ]; then
[ "$DEFINES_STRING" ] &&
DEFINES_STRING="${DEFINES_STRING}," ||
DEFINES_STRING="--define "
DEFINES_STRING="${DEFINES_STRING}${JOB_VARNAMES[$i-1]}=${JOB_VALUES[$i-1]}"
fi
;;
esac
done
# don't build cross package for the same arch as target arch
[[ ( "$autodist_crossonly" = "1" ) && ( "$cross_target_cpu" = "$TARGETARCH" ) ]] && return 0;
JOB_ARGS="$JOB_ARGS$DEFINES_STRING"
[ "$patch_operation" = "buildinstall" ] && patch_operation=build
[ "$patch_operation" = "autoupdate" -o "$patch_operation" = "rebuild" ] && patch_operation=update
# launch loop for each package
for pkg in ${JOB_PKGS[*]}; do
unset LOGFILE_SUFFIX AUTOUPDATE_SCRIPT_ALREADY_RUN
for a in ${JOB_VALUES[*]}; do
tr_job=`echo $a | tr / _`
LOGFILE_SUFFIX=${LOGFILE_SUFFIX}__$tr_job
done
LOGFILE_SUFFIX=$LOGFILE_SUFFIX.$TARGETARCH
[ "$JOB_NAME" = "${pkg}" ] &&
LOGFILE_PKG_NAME=${pkg}${LOGFILE_SUFFIX} ||
LOGFILE_PKG_NAME=${JOB_NAME}_${pkg}${LOGFILE_SUFFIX}
LOGFILE_PKG=${LOGDIR}/${LOGFILE_PKG_NAME}
# clean previous logs for this package
[ -e ${LOGDIR}/ok/${LOGFILE_PKG_NAME}${LOGFILE_SUFFIX} ] &&
rm -f ${LOGDIR}/ok/${LOGFILE_PKG_NAME}${LOGFILE_SUFFIX}
[ -e ${LOGDIR}/failed/${LOGFILE_PKG_NAME}${LOGFILE_SUFFIX} ] &&
rm -f ${LOGDIR}/failed/${LOGFILE_PKG_NAME}-${LOGFILE_SUFFIX}
case $operation in
autoupdate|update|build|rebuild|buildinstall)
[ -e $spec_dir/$pkg.spec ] || {
case $SEVERITY in
0) ;;
1) echo "!! Error: spec filename must be the same as package name or invalid job name; skipping $pkg package."
[ "$do_autobuild" ] && autobuild_log $pkg $operation 240 $JOB_NAME $LOGDIR/failed/${LOGFILE_PKG_NAME}
continue ;;
*) echo "!! Error: spec filename must be the same as package name or invalid job name; aborting."
exit 1 ;;
esac
}
# apply patches
SPEC_DATE=`stat $spec_dir/$pkg.spec --printf=%y`
if [ $JOB_IDX -eq 0 -a "$do_autobuild" ]; then
# preserve specfile modification date
if [ -e $AUTOUPDATEDIR/spec-patches-$patch_operation/$pkg.spec.patch ]; then
echo -n "?= "
patch -p1 $spec_dir/$pkg.spec $AUTOUPDATEDIR/spec-patches-$patch_operation/$pkg.spec.patch || {
case $SEVERITY in
0) ;;
1) echo "%! Error: could not apply patch to specfile; skipping $pkg package."
[ "$do_autobuild" ] && autobuild_log $pkg $operation 241 $JOB_NAME $LOGDIR/failed/${LOGFILE_PKG_NAME}
ret=1
continue ;;
*) echo "!! Error: could not apply patch to specfile; aborting."
exit 1 ;;
esac
}
[ "$operation" = "update" -o "$operation" = "autoupdate" ] && continue
fi
fi
if [ -x $SCRIPT_UPDATE_SPECFILE ]; then
$SCRIPT_UPDATE_SPECFILE $spec_dir/$pkg.spec ${passed_arguments/ *} $SCRIPT_ARGS || {
case $SEVERITY in
0) ;;
1) echo "%! Error: update-specfile script returned $?; skipping $pkg package."
ret=1
continue ;;
*) echo "!! Error: update-specfile script returned $?; aborting."
exit 1 ;;
esac
}
fi
if [ -x $SCRIPT_UPDATE_SPECFILE_CUSTOM ]; then
$SCRIPT_UPDATE_SPECFILE_CUSTOM $spec_dir/$pkg.spec ${passed_arguments/ *} $SCRIPT_ARGS || {
case $SEVERITY in
0) ;;
1) echo "%! Error: update-specfile-custom script returned $?; skipping $pkg package."
ret=1
continue ;;
*) echo "!! Error: update-specfile-custom script returned $?; aborting."
exit 1 ;;
esac
}
fi
;;
esac
[ -e $spec_dir/$pkg.spec ] && {
SPEC_EPOCH=`grep "Epoch:" $spec_dir/$pkg.spec | sed "s|Epoch:[[:space:]]*||"`
SPEC_VERSION=`grep "Version:" $spec_dir/$pkg.spec | sed "s|Version:[[:space:]]*||"`
SPEC_RELEASE=`grep "Release:" $spec_dir/$pkg.spec | sed "s|Release:[[:space:]]*||"`
}
[ -e "$SRCPKGLIST" ] && PKGLINE=`grep "^${pkg} " $SRCPKGLIST` || PKGLINE=
[ "$PKGLINE" -a -e "$BUILDSLIST" ] && BUILDSLINE=`grep "^${pkg}:" $BUILDSLIST` || BUILDSLINE=
[ -e "$SRCPKGLIST_DELAYED" ] && PKGLINE_DELAYED=`grep "^${pkg} " $SRCPKGLIST_DELAYED` || PKGLINE_DELAYED=
[ "$PKGLINE_DELAYED" -a -e "$BUILDSLIST_DELAYED" ] && BUILDSLINE_DELAYED=`grep "^${pkg} " $SRCPKGLIST_DELAYED` || BUILDSLINE_DELAYED=
if [ "$PKGLINE_DELAYED" -a "$do_autobuild" ]; then
set -- $PKGLINE
_ver1=$2
_rel1=$6
set -- $PKGLINE_DELAYED
_ver2=$2
_rel2=$6
version_find_bigger ${_ver1} ${_ver2}
if [ $? -eq 2 ]; then
PKGLINE=$PKGLINE_DELAYED
echo "!! Warning: using package from delayed repository (${_ver2} > ${_ver1})"
elif [ $? -eq 0 ]; then
version_find_bigger ${_rel1} ${_rel2}
if [ $? -eq 0 ]; then
echo "!! Warning: package with same version (${_ver1}-${_rel1}) exists in delayed repository"
elif [ $? -eq 2 ]; then
echo "!! Warning: using package from delayed repository (${_ver2}-${_rel2} > ${_ver1}-${_rel1})"
PKGLINE=$PKGLINE_DELAYED
fi
fi
fi
case $operation in
prepare)
command_opts="-a1"
if [ "$PKGLINE" ]; then
set -- $PKGLINE
[[ $4 =~ "^[0-9]+$" ]] && REPNAME=${AUTODIST_REPOSITORIES[$4]} || REPNAME="$4"
if [ "$REPNAME" != "$AUTODIST_REPOSITORY" -a "$REPOSITORY_STRICT" ]; then
case $SEVERITY in
0) echo "!! Warning: package comes from $REPNAME instead of $AUTODIST_REPOSITORY" ;;
1) echo "!! Error: package comes from $REPNAME instead of $AUTODIST_REPOSITORY; skipping $pkg package."
continue ;;
*) echo "!! Error: package comes from $REPNAME instead of $AUTODIST_REPOSITORY; aborting."
exit 1 ;;
esac
fi
if [ "$REPNAME" ]; then
command_opts="$command_opts --server ${REPNAME}"
else
echo "!! Warning: undefined repository $4 in srcpkglist, check AUTODIST_REPOSITORIES in configuration file"
fi
else
echo "!! Warning: package $pkg is missing in srcpkglist file"
fi
;;
rebuild) command_opts="-a4 --rebuild" ;;
autoupdate) command_opts="-a2:4" ;;
update)
# skip package in job if up to date
if [ "$PKGLINE" ]; then
set -- $PKGLINE
pkglinever=$2
# warning: assuming version is passed first
version_find_bigger "${passed_arguments/ *}" "$pkglinever"
[ $? -eq 1 ] || {
echo "!! Warning: skipping ${pkg} package already up to date ($pkglinever >= ${passed_arguments/ *})."
# echo "%% Adding ${pkg} job to skipped list."
# echo "${pkg} $DATE_NOW 255" >> $SKIPPEDLISTDIR/auto.skip
[ "$do_autobuild" ] && autobuild_log $pkg $operation skipped $JOB_NAME
continue
}
fi
if [ -e $source_dir/$pkg-autoupdate ]; then
echo "?= Running $pkg-autoupdate script with version ${passed_arguments/ *}"
(cd $source_dir; sh ./$pkg-autoupdate ${passed_arguments/ *} >/dev/null)
AUTOUPDATE_SCRIPT_ALREADY_RUN=1
fi
command_opts="-a3:4" ;;
build)
# skip package in job if it is in the delayed repository
if [ "$PKGLINE_DELAYED" -a "$BUILDSLINE_DELAYED" -a "$do_autobuild" ]; then
set -- $PKGLINE_DELAYED
if [ "$SPEC_VERSION-$SPEC_RELEASE" = "$2-$6" ]; then
echo "!! Warning: skipping ${pkg} package build because already present in delayed repository."
echo "%% Adding ${pkg} job to skipped list."
echo "${pkg} $DATE_NOW 254" >> $SKIPPEDLISTDIR/auto.skip
[ "$do_autobuild" ] && autobuild_log $pkg $operation skipped $JOB_NAME
continue
fi
fi
command_opts="-a5:6 -b" ;;
buildsrpm)
command_opts="-a5:6 --norpm" ;;
buildinstall)
# skip package in job if up to date
if [ "$PKGLINE" -a "$BUILDSLINE" ]; then
set -- $PKGLINE
pkglinever=$2
pkglinerel=$6
# warning: assuming version is passed first
version_find_bigger "$SPEC_VERSION" "$pkglinever"
[ $? -eq 0 ] && {
version_find_bigger "$SPEC_RELEASE" "$pkglinerel"
if [ $? -ne 1 ]; then
echo "!! Warning: skipping ${pkg} package already up to date ($SPEC_VERSION-$SPEC_RELEASE >= $pkglinever-$pkglinerel)."
continue
fi
}
fi
# skip package in job if it is in the delayed repository
if [ "$PKGLINE_DELAYED" -a "$BUILDSLINE_DELAYED" -a "$do_autobuild" ]; then
set -- $PKGLINE_DELAYED
if [ "$SPEC_VERSION-$SPEC_RELEASE" = "$2-$6" ]; then
echo "!! Warning: skipping ${pkg} package build because already present in delayed repository."
continue
fi
fi
command_opts="-a5,6,10,11 --force-install" ;;
send)
# skip package in job if up to date
if [ "$PKGLINE" -a "$BUILDSLINE" -a "$do_autobuild" ]; then
set -- $PKGLINE
pkglinever=$2
pkglinerel=$6
# warning: assuming version is passed first
version_find_bigger "$SPEC_VERSION" "$pkglinever"
[ $? -eq 0 ] && {
version_find_bigger "$SPEC_RELEASE" "$pkglinerel"
if [ $? -ne 1 ]; then
echo "!! Warning: skipping ${pkg} package already up to date ($SPEC_VERSION-$SPEC_RELEASE >= $pkglinever-$pkglinerel)."
continue
fi
}
fi
# skip package in job if it is in the delayed repository
if [ "$PKGLINE_DELAYED" -a "$BUILDSLINE_DELAYED" -a "$do_autobuild" ]; then
set -- $PKGLINE_DELAYED
if [ "$SPEC_VERSION-$SPEC_RELEASE" = "$2-$6" ]; then
echo "!! Warning: skipping ${pkg} package send because already present in delayed repository."
continue
fi
fi
command_opts="-a10" ;;
install) command_opts="-a11" ;;
*)
echo "!! Internal error: unknown operation $operation; aborting."
exit 1
;;
esac
command="$AUTOSPEC_CMD -u $pkg $command_opts $passed_arguments $JOB_ARGS"
tmpfile=${LOGBASEDIR}/current.$$
> $tmpfile
tmpfile1=`tempfile`
echo -n "== "`log_date`" $JOB_NAME with args: $JOB_ARGS..." >> $LOGFILE
echo "
=> $command" >> $LOGFILE_PKG
[ "$verbose" ] && echo "== "`log_date`" $JOB_NAME with args: $JOB_ARGS...
=> $command"
if [ "$simulate" ]; then
echo "Command: $command"
else
# eval "$command 2>&1 && echo '0'>$tmpfile1 || echo '1'>$tmpfile1" | tail_file $tmpfile "== $pkg (${JOB_VALUES[*]})..."
(export LANG=en_US.UTF-8; $command 2>&1; echo $? >$tmpfile1) | tail_file $tmpfile "== $pkg (${JOB_VALUES[*]})..."
if [ -e $tmpfile1 ]; then
ret=`cat $tmpfile1`
rm -f $tmpfile1
else
ret=0
fi
cat $tmpfile >> $LOGFILE_PKG
if [ $ret -gt 0 ]; then
echo " FAILED (ret=$ret)"
echo " FAILED (ret=$ret)" >> $LOGFILE
[ ! "$quiet" -a ! "$verbose" ] && {
echo "=> $command"
echo
echo " == begin of output log =="
echo
tail -n 40 $tmpfile
echo
echo " == end of output log =="
echo
}
mv $LOGFILE_PKG $LOGDIR/failed/
echo "?= See $LOGDIR/failed/${LOGFILE_PKG_NAME}"
[ "$do_autobuild" ] && autobuild_log $pkg $operation $ret $JOB_NAME $LOGDIR/failed/${LOGFILE_PKG_NAME}
[ $SEVERITY -gt 0 -a ! "$continue_on_error" ] && {
rm -f $tmpfile
return $ret
}
else
echo
echo " OK" >> $LOGFILE
mv $LOGFILE_PKG $LOGDIR/ok/
echo "?= See $LOGDIR/ok/${LOGFILE_PKG_NAME}"
[ "$do_autobuild" ] && autobuild_log $pkg $operation ok $JOB_NAME $LOGDIR/ok/${LOGFILE_PKG_NAME}
case $operation in
prepare)
[ -e $spec_dir/.$pkg.spec.autodist.prebuild ] && \
rm -f $spec_dir/.$pkg.spec.autodist.prebuild
cp $spec_dir/$pkg.spec $spec_dir/.$pkg.spec.autodist.preupdate
;;
rebuild)
cp $spec_dir/$pkg.spec $spec_dir/.$pkg.spec.autodist.prebuild
;;
update|autoupdate)
cp $spec_dir/$pkg.spec $spec_dir/.$pkg.spec.autodist.prebuild
SPEC_EPOCH=`grep -m1 "^Epoch:" $spec_dir/$pkg.spec | sed "s|Epoch:[[:space:]]*||"`
SPEC_VERSION=`grep -m1 "^Version:" $spec_dir/$pkg.spec | sed "s|Version:[[:space:]]*||"`
SPEC_RELEASE=`grep -m1 "^Release:" $spec_dir/$pkg.spec | sed "s|Release:[[:space:]]*||"`
if [ "$PKGLINE" ]; then
set -- $PKGLINE
echo "?= Specfile updated from version $2-$6 to $SPEC_VERSION-$SPEC_RELEASE"
if [ "`echo $SPEC_VERSION | grep -i alpha`" -o \
"`echo $SPEC_VERSION | grep -i beta`" -o \
"`echo $SPEC_VERSION | grep -i rc`" -o \
"`echo $SPEC_VERSION | grep -i pre`" -o \
"`echo $SPEC_VERSION | grep -i pl`" ]; then
if [ ! "`echo $2 | grep -i alpha`" -a \
! "`echo $2 | grep -i beta`" -a \
! "`echo $2 | grep -i rc`" -a \
! "`echo $2 | grep -i pre`" -a \
! "`echo $2 | grep -i pl`" ]; then
echo "!! Looks like an update to an unstable release; skipping."
[ $SEVERITY -gt 0 ] && {
rm -f $tmpfile
return 3
}
fi
fi
if [ "$2" != "$SPEC_VERSION" -a -e $source_dir/$pkg-autoupdate -a ! "$AUTOUPDATE_SCRIPT_ALREADY_RUN" ]; then
echo "?= Running $pkg-autoupdate script with version ${passed_arguments/ *}"
(cd $source_dir; sh ./$pkg-autoupdate ${passed_arguments/ *} >/dev/null)
AUTOUPDATE_SCRIPT_ALREADY_RUN=1
fi
fi
;;
buildinstall|send)
if [ $JOB_IDX -eq $JOB_LAST -a "$do_autobuild" ]; then
# archive patches
[ -e $AUTOUPDATEDIR/spec-patches-update/$pkg.spec.patch ] && \
mv $AUTOUPDATEDIR/spec-patches-update/$pkg.spec.patch \
$AUTOUPDATEDIR/spec-patches-update/old/
[ -e $AUTOUPDATEDIR/spec-patches-build/$pkg.spec.patch ] && \
mv $AUTOUPDATEDIR/spec-patches-build/$pkg.spec.patch \
$AUTOUPDATEDIR/spec-patches-build/old/
PATCHES=`diff $spec_dir/$pkg.spec $spec_dir/.$pkg.spec.autodist.preupdate | grep "> Patch" | sed "s|.*[[:space:]]\([^[:space:]]*\)|\1|"`
for p in $PATCHES; do
[ -e $SOURCESDIR/$p ] && rm -f $SOURCESDIR/$p
done
fi
if [ "$operation" = "buildinstall" -o "${passed_arguments/--norpm}" != "${passed_arguments}" ]; then
# send operation: check for --norpm (source send) to avoid sending notification twice
[ "$WEBBUILD_URL" -a "$WEBBUILD_USER" ] && {
SPEC_VERSION=`grep -m1 "^Version:" $spec_dir/$pkg.spec | sed "s|Version:[[:space:]]*||"`
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) sent <b>$pkg $SPEC_VERSION-$SPEC_RELEASE</b> for ${TARGETARCH} to <b>$SEND_SERVER</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 \"sent <b>$pkg $SPEC_VERSION-$SPEC_RELEASE</b> for ${TARGETARCH} to <b>$SEND_SERVER</b>\"`" >/dev/null
fi
}
fi
;;
esac
fi
rm -f $tmpfile
fi
done
return $ret
}
function launch_job_loop() {
# Iterates launch_pkgs_loop for each of the lines of current job
# (defined from JOB_FIRST to JOB_LAST)
# This is needed for build, send and install operations
numerr=0
for j in `seq $JOB_FIRST $JOB_LAST`; do
launch_pkgs_loop "$1" "$2" "${JOBS[$j]}" $j
if [ $? -gt 0 ]; then
numerr=$(($numerr + 1))
[ "$continue_on_error" ] || return $numerr;
fi
done
return $numerr
}
function log_date() {
echo -n `LANG=C date +%Y%m%d@%H%M%S`
}
[ -e $LOGBASEDIR ] || {
mkdir -p $LOGBASEDIR/prepare/{ok,failed}
mkdir -p $LOGBASEDIR/update/{ok,failed}
mkdir -p $LOGBASEDIR/build/{ok,failed}
mkdir -p $LOGBASEDIR/install/{ok,failed}
mkdir -p $LOGBASEDIR/send/{ok,failed}
}
#
# Main
#
DISTDBFILES=
DISTDB=`fetch_repository_file ${AUTODIST_REPOSITORY/-*}/distdb`
[ "$DISTDB" ] && DISTDBFILES="$DISTDB"
DISTDBARCH=`fetch_repository_file ${AUTODIST_REPOSITORY/-*}/distdb.$TARGETARCH`
if [ "$DISTDBARCH" ]; then
DISTDBFILES="$DISTDBFILES $DISTDBARCH"
fi
if [ ! "$DISTDBFILES" ]; then
[ -e $SYSCONFDIR/distdb ] && DISTDBFILES="$SYSCONFDIR/distdb"
[ -e $SYSCONFDIR/distdb.$TARGETARCH ] && DISTDBFILES="$DISTDBFILES $SYSCONFDIR/distdb.$TARGETARCH"
fi
if [ "$do_listjobs" ]; then
for f in $DISTDBFILES; do
for j in `grep -v "^#" $f | grep ".*=(" | sed "s|\(.*\)=(.*|\1|"`; do
echo $j
done
done
exit 0
fi
# include global distdb files
for f in $DISTDBFILES; do
. $f
done
if [ "$do_listpkgs" ]; then
get_job_vector $LISTPKGSJOB
for p in ${JOB_PKGS[*]}; do
echo $p
done
exit 0
fi
# FIXME: DISTDBDIR contains private jobs we don't want to publish on webbuild
for f in $DISTDBDIR/*.db; do
. $f
done
eval `autospec -q --eval="srpms_dir"`
eval `autospec -q --eval="rpms_dir"`
eval `autospec -q --eval="spec_dir"`
eval `autospec -q --eval="source_dir"`
eval `autospec -q --eval="tmppath_dir"`
for a in $LOGBASEDIR/{,prepare/{,ok,failed},update/{,ok,failed},build/{,ok,failed},install/{,ok,failed},send/{,ok,failed}}; do
[ ! -w $a ] && {
echo "!! Error: directory $a is missing or read-only; aborting."
exit 1
}
[ "$do_cleanlogs" ] && {
find $a -type f -exec rm -f {} \;
}
done
AUTOUPDATEDIR=${LOCAL_REPS_BASE_DIR}/$AUTODIST_REPOSITORY/autoupdate/
[ -r $AUTOUPDATEDIR ] || {
AUTOUPDATEDIR=$USERCONFDIR/$AUTODIST_REPOSITORY/autoupdate
mkdir -p $AUTOUPDATEDIR
}
SOURCESDIR=$AUTOUPDATEDIR/sources/
SUCCESSLISTDIR=$AUTOUPDATEDIR
SKIPPEDLISTDIR=$AUTOUPDATEDIR
SRCPKGLIST=`fetch_repository_file $AUTODIST_REPOSITORY/srcpkglist`
[ $? -eq 0 ] || echo "Warning: unable to fetch $SRCPKGLIST">&2
[ "$AUTODIST_DELAYED_REPOSITORY" ] && SRCPKGLIST_DELAYED=`fetch_repository_file $AUTODIST_DELAYED_REPOSITORY/srcpkglist`
[ $? -eq 0 ] || echo "Warning: unable to fetch $SRCPKGLIST_DELAYED">&2
BUILDSLIST=`fetch_repository_file distromatic/$AUTODIST_REPOSITORY/builds-$TARGETARCH`
[ "$AUTODIST_DELAYED_REPOSITORY" ] && BUILDSLIST_DELAYED=`fetch_repository_file distromatic/$AUTODIST_DELAYED_REPOSITORY/builds-$TARGETARCH`
[ $? -eq 0 ] || echo "Warning: unable to fetch $BUILDSLIST">&2
LEGACYLIST=`fetch_repository_file ${AUTODIST_REPOSITORY/-*}/legacy`
[ "$LEGACYLIST" ] || LEGACYLIST=$SYSCONFDIR/legacy
[ $? -eq 0 ] || echo "Warning: unable to fetch $LEGACYLIST">&2
echo "%% Autodist started with PID $$ @ `LANG=C date`"
# autobuild: add jobs ordered by oldest builds
if [ "$do_autobuild" = "1" ]; then
trap "rm -f $PIDFILE; exit 1" SIGQUIT SIGINT SIGKILL SIGTERM
echo $$ > $PIDFILE
[ -e "$SRCPKGLIST" ] || {
echo "ERROR: missing srcpkglist file $SRCPKGLIST; aborting."
exit 1
}
srctmpfile=`tempfile`
cat $AUTOUPDATEDIR/*.in > $srctmpfile
cat $SRCPKGLIST | sort --key=3 >> $srctmpfile
pkgtmpfile=`tempfile`
[ "$pkgtmpfile" ] || {
echo "ERROR: cannot create temporary files; aborting."
exit 1
}
## when autobuilding always rebuild packages
#SEND_FORCE_BUILD="--force-build"
AUTOBUILD_NUMADDED=0
BUILDDATE=0
PKGCOUNT=`wc -l $srctmpfile | awk '{ print $1 }'`
SKIPPEDCOUNT=0
BLACKLISTCOUNT=0
SUCCESSLISTCOUNT=0
REBUILDOLDCOUNT=0
> $pkgtmpfile
# cat $srctmpfile | sort --key=3 | \
while read line; do
set -- $line
PKGNAME=${1}
VERSION=${2}
BUILDDATE=${3}
SOURCEREP=${4}
RELEASE=${5}
EPOCH=${6}
# skip duplicates
grep "^$PKGNAME " $pkgtmpfile >/dev/null && continue
# check blacklist
awk '{ print $1 }' $BLACKLIST | grep "^$PKGNAME$" >/dev/null && {
BLACKLISTCOUNT=`expr $BLACKLISTCOUNT + 1`
# echo "?= Job $PKGNAME is in the blacklist; skipping"
continue
}
if [ "${VERSION:0:1}" != "+" ]; then
if [ $REBUILDOLDCOUNT -lt $AUTODIST_REBUILDOLD_MAX -a $BUILDDATE -ge $AUTODIST_REBUILDOLD_FROMDATE ]; then
# rebuilt oldest packages
REBUILDOLDCOUNT=$(($REBUILDOLDCOUNT + 1))
VERSION=+0
else
# check skippedlist (but ignore for scheduled updates)
SKIPPEDLINE=`awk '{ print $1" "$2 }' $SKIPPEDLISTDIR/*.skip | grep -m1 "^$PKGNAME "`
if [ "$SKIPPEDLINE" ]; then
set -- $SKIPPEDLINE
SKIPPEDTIME=$2
SKIPPEDDAYS=`expr \( $DATE_NOW - $SKIPPEDTIME \) / 86400`
if [ "$SKIPPEDDAYS" -le "$AUTOBUILD_SKIP_DAYS" ]; then
SKIPPEDCOUNT=`expr $SKIPPEDCOUNT + 1`
#echo "?= Package $PKGNAME has been in the skippedlist for $SKIPPEDDAYS days; skipping"
continue
else
sed -i "/^$PKGNAME /d" $SKIPPEDLISTDIR/*.skip
fi
fi
fi
fi
if [ "${VERSION:0:1}" != "+" ]; then
# check legacylist
awk '{ print $1 }' $LEGACYLIST | grep "^$PKGNAME$" >/dev/null && {
echo "?= Job $PKGNAME is in the legacy list; skipping automatic update"
echo "$PKGNAME $DATE_NOW 100" >> $SKIPPEDLISTDIR/auto.skip
continue
}
fi
# manually or from lists scheduled jobs
if [ "${VERSION:0:1}" == "+" -a "$VERSION" != "+0" ]; then
TRVER=`echo ${VERSION:1} | tr - .`
get_job_vector $PKGNAME
NEED_REBUILD=0
if [ ${#JOB_PKGS[*]} -gt 1 ]; then
# jobs are not fully rebuilt
for j in ${JOB_PKGS[*]}; do
REPVER=`grep "^$j " $SRCPKGLIST | gawk '{ print $2 }'`
version_find_bigger "$TRVER" "$REPVER"
[ $? -eq 1 ] && NEED_REBUILD=1
done
else
# single packages are rebuilt if scheduled
NEED_REBUILD=1
fi
if [ "$NEED_REBUILD" = "0" ]; then
echo "?= Job $PKGNAME is already up to date; skipping"
continue
fi
elif [ "$VERSION" != "+0" ]; then
# check successlist
SUCCESSLINE=`awk '{ print $1" "$2 }' $SUCCESSLISTDIR/*.success | grep -m1 "^$PKGNAME "`
if [ "$SUCCESSLINE" ]; then
set -- $SUCCESSLINE
SUCCESSTIME=$2
[ "$SUCCESSTIME" ] || SUCCESSTIME=0
SUCCESSDAYS=`expr \( $DATE_NOW - $SUCCESSTIME \) / 86400`
if [ "$SUCCESSDAYS" -le "$AUTOBUILD_SUCCESS_DAYS" ]; then
SUCCESSLISTCOUNT=`expr $SUCCESSLISTCOUNT + 1`
#echo "?= Job $PKGNAME has been in the successlist for $SUCCESSDAYS days; skipping"
continue
else
sed -i "/^$PKGNAME /d" $SUCCESSLISTDIR/*.success
fi
fi
fi
[ $AUTOBUILD_NUMADDED -ge $AUTOBUILD_MAXNUM ] && break
# FIXME: hardcoded skipped packages
#[ "${PKGNAME:0:5}" = "java-" -o "${PKGNAME:0:7}" = "apache-" -o \
# "${PKGNAME:0:8}" = "jakarta-" -o "${PKGNAME:0:6}" = "compiz" ] && continue
if [ $BUILDDATE -ge $AUTOBUILD_DATEFROM -o $BUILDDATE -eq 0 ]; then
AUTOBUILD_NUMADDED=`expr $AUTOBUILD_NUMADDED + 1`
echo "$PKGNAME $VERSION" >> $pkgtmpfile
fi
done < $srctmpfile
echo "%% Total pkgs: $PKGCOUNT, skipped list: $SKIPPEDCOUNT, blacklist: $BLACKLISTCOUNT, success list: $SUCCESSLISTCOUNT, rebuild-old list: $REBUILDOLDCOUNT, last build date: $BUILDDATE"
while read line; do
set -- $line
PKGNAME=${1}
VERSION=${2}
JOBVER[${#JOBNAME[@]}]=$VERSION
JOBNAME[${#JOBNAME[@]}]=$PKGNAME
done < $pkgtmpfile
echo -n "%% autoupdate jobs: "
for i in `seq 1 ${#JOBNAME[@]}`; do
echo -n "${JOBNAME[$i-1]}(${JOBVER[$i-1]}) "
done
echo
rm -f $pkgtmpfile $srctmpfile
[ -e $LOGBASEDIR/autoupdate-current ] && mv $LOGBASEDIR/autoupdate-current $LOGBASEDIR/autoupdate-last
fi
OPERATION_ERRORS=0
echo "%% ${#JOBNAME[*]} job(s) scheduled"
echo "%% Starting main jobs loop"
for JOB_NUM in `seq 1 ${#JOBNAME[*]}`; do
JOB_NAME=${JOBNAME[$JOB_NUM-1]}
JOB_VER=${JOBVER[$JOB_NUM-1]}
JOB_VER=`echo $JOB_VER | tr - .`
# resolve JOB_NAME from distdb
get_job_vector $JOB_NAME
JOB_NAME=${JOB_NAME/*\/}
[ "$quiet" ] || echo "== =======================$JOB_NAME============================="
echo -n "%% Doing $JOB_NAME (VER=$JOB_VER"
for k in ${JOB_VARNAMES[*]}; do
echo -n " %${k}"
done
echo ") job"
DATE_NOW=`LANG=C date +%s`
JOBS=()
for k in `seq 3 ${#JOB[*]}`; do
JOBS=(${JOBS[*]} "${JOB[$k-1]}")
done
JOB_NUMBER=${#JOBS[*]}
JOB_FIRST=0
JOB_LAST=`expr $JOB_NUMBER - 1`
if [ "$do_prepare" ]; then
LOGDIR=$LOGBASEDIR/prepare
LOGFILE=$LOGDIR/last
> $LOGFILE
echo "%% Starting PREPARE operation @ `LANG=C date`"
echo "%% "`log_date`" Starting PREPARE operation" > $LOGFILE
launch_pkgs_loop prepare "$AUTOSPEC_ARGS --force" || {
case $SEVERITY in
0) ;;
1) echo "%! Error during package prepare; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during package prepare; aborting."
exit 255 ;;
esac
}
if [ ! "$do_update" -a "$do_autobuild" = "1" ]; then
[ "${AUTOSPEC_ARGS/--changelog}" = "${AUTOSPEC_ARGS}" ] &&
AUTOSPEC_CHANGELOG="--changelog \"automatic rebuild by autodist\"" || AUTOSPEC_CHANGELOG=
launch_pkgs_loop rebuild "$AUTOSPEC_ARGS $AUTOSPEC_CHANGELOG" || {
case $SEVERITY in
0) ;;
1) echo "%! Error during package update for rebuild; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during package update for rebuild; aborting."
exit 255 ;;
esac
}
fi
fi
if [ "$do_update" ]; then
LOGDIR=$LOGBASEDIR/update
LOGFILE=$LOGDIR/last
echo "%% Starting UPDATE operation @ `LANG=C date`"
echo "%% "`log_date`" Starting UPDATE operation" > $LOGFILE
if [ "${JOB_VER:0:1}" != "+" -o "${JOB_VER}" = "+0" ]; then
ret=1
# don't update when --rebuild is passed
if [ ! "$rebuild_packages" ]; then
# check legacylist
awk '{ print $1 }' $LEGACYLIST | grep "^$JOB_NAME$" >/dev/null && {
echo "?= Job $JOB_NAME is in the legacy list; forcing rebuild"
} || {
[ "${AUTOSPEC_ARGS/--changelog}" = "${AUTOSPEC_ARGS}" ] &&
AUTOSPEC_CHANGELOG="--changelog \"automatic update by autodist\"" || AUTOSPEC_CHANGELOG
launch_pkgs_loop autoupdate "$AUTOSPEC_ARGS $AUTOSPEC_CHANGELOG $SEND_FORCE"
ret=$?
}
fi
if [ $ret != 0 ]; then
if [ ! "$rebuild_packages" -a "${JOB_VER}" != "+0" ]; then
[ $ret -ge 2 -a "$do_autobuild" ] && {
echo "%% Adding $JOB_NAME job to skipped list."
echo "$JOB_NAME $DATE_NOW $ret" >> $SKIPPEDLISTDIR/auto.skip
}
case $SEVERITY in
0) ;;
1) echo "%! Error during package update; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during package update; aborting."
exit 255 ;;
esac
else
echo "%% Rebuilding package(s)"
[ "${AUTOSPEC_ARGS/--changelog}" = "${AUTOSPEC_ARGS}" ] &&
AUTOSPEC_CHANGELOG="--changelog \"automatic rebuild by autodist\"" || AUTOSPEC_CHANGELOG=
launch_pkgs_loop rebuild "$AUTOSPEC_ARGS $AUTOSPEC_CHANGELOG" || {
case $SEVERITY in
0) ;;
1) echo "%! Error during package update for rebuild; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during package update for rebuild; aborting."
exit 255 ;;
esac
}
fi
fi
else
## skip package in job if up to date
#for j in ${JOB_PKGS[*]}; do
# REPVER=`grep "^$j " $SRCPKGLIST | gawk '{ print $2 }'`
# version_find_bigger "$TRVER" "$REPVER"
# [ $? -eq 1 ] && NEED_REBUILD=1
# done
echo "%% Updating to version ${JOB_VER:1}"
# WARNING: JOB_VER must be passed to launch_pkgs_loop as the first string in the second parameter
[ "${AUTOSPEC_ARGS/--changelog}" = "${AUTOSPEC_ARGS}" ] &&
AUTOSPEC_CHANGELOG="--changelog \"automatic version update by autodist\"" || AUTOSPEC_CHANGELOG=
launch_pkgs_loop update "${JOB_VER:1} $AUTOSPEC_ARGS $AUTOSPEC_CHANGELOG $SEND_FORCE" || {
if [ ! "$rebuild_packages" ]; then
case $SEVERITY in
0) ;;
1) echo "%! Error during update; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during update; aborting."
exit 255 ;;
esac
else
[ "${AUTOSPEC_ARGS/--changelog}" = "${AUTOSPEC_ARGS}" ] &&
AUTOSPEC_CHANGELOG="--changelog \"automatic rebuild by autodist\"" || AUTOSPEC_CHANGELOG=
launch_pkgs_loop rebuild "$AUTOSPEC_ARGS $AUTOSPEC_CHANGELOG" || {
case $SEVERITY in
0) ;;
1) echo "%! Error during package update for rebuild; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during package update for rebuild; aborting."
exit 255 ;;
esac
}
fi
}
fi
fi
if [ "$do_build" ]; then
LOGDIR=$LOGBASEDIR/build
LOGFILE=$LOGDIR/last
echo "%% Starting BUILD operation @ `LANG=C date`"
echo "%% "`log_date`" Starting BUILD operation" > $LOGFILE
launch_job_loop build "$AUTOSPEC_ARGS $SEND_FORCE_BUILD $SEND_SERVER_CMD" || {
case $SEVERITY in
0) ;;
1) echo "%! Error during build; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during build; aborting."
exit 255 ;;
esac
}
fi
if [ "$do_install" ]; then
LOGDIR=$LOGBASEDIR/install
LOGFILE=$LOGDIR/last
> $LOGFILE
echo "%% Starting INSTALL operation @ `LANG=C date`"
echo "%% "`log_date`" Starting INSTALL operation" > $LOGFILE
launch_job_loop install "$AUTOSPEC_ARGS" || {
case $SEVERITY in
0) ;;
1) echo "%! Error during installation; skipping $JOB_NAME job."
OPERATION_ERRORS=`expr $OPERATION_ERRORS + 1`
continue ;;
*) echo "!! Error during installation; aborting."
exit 255 ;;
esac
}
fi
if [ "$do_send" ]; then
LOGDIR=$LOGBASEDIR/send
LOGFILE=$LOGDIR/last
> $LOGFILE
echo "%% Starting SEND operation @ `LANG=C date`"
echo "%% "`log_date`" Starting SEND operation" > $LOGFILE
launch_job_loop send "$AUTOSPEC_ARGS --nosrpm $SEND_SERVER_CMD" || {
case $SEVERITY in
0) ;;
1) echo "%! Error sending packages; skipping $JOB_NAME job."
continue ;;
*) echo "!! Error sending packages; aborting."
exit 1 ;;
esac
}
# avoid calling autospec with --nosrpm --norpm (not working as expected and not useful)
if [ "${AUTOSPEC_ARGS/--nosrpm}" = "$AUTOSPEC_ARGS" ]; then
if [ $REBUILD_SRPMS ]; then
echo "== rebuilding and sending source rpms"
launch_pkgs_loop buildsrpm "$AUTOSPEC_ARGS --norpm"
else
echo "== sending source rpms"
fi
launch_pkgs_loop send "$AUTOSPEC_ARGS --norpm $SEND_SERVER_CMD"
if [ $? -gt 0 ]; then
case $SEVERITY in
0) ;;
1) echo "%! Error sending sources; skipping $JOB_NAME job."
continue ;;
*) echo "!! Error sending sources; aborting."
exit 1 ;;
esac
else
# archive patches
if [ "$do_autobuild" ]; then
[ -e $AUTOUPDATEDIR/spec-patches-update/$JOB_NAME.spec.patch ] && \
mv $AUTOUPDATEDIR/spec-patches-update/$JOB_NAME.spec.patch \
$AUTOUPDATEDIR/spec-patches-update/old/${JOB_NAME}.spec.${DATE_NOW}.patch
[ -e $AUTOUPDATEDIR/spec-patches-build/$JOB_NAME.spec.patch ] && \
mv $AUTOUPDATEDIR/spec-patches-build/${JOB_NAME}.spec.${DATE_NOW}.patch \
$AUTOUPDATEDIR/spec-patches-build/old/${JOB_NAME}.spec.${DATE_NOW}.patch
fi
fi
fi
fi
# if we are here the job was completed; remove manual entry, if any, and add to successlist
[ "$do_autobuild" ] && {
sed -i "/^$JOB_NAME .*/d" $AUTOUPDATEDIR/*.in
echo "$JOB_NAME $DATE_NOW" >> $SUCCESSLISTDIR/auto.success
}
done
[ "$do_autobuild" = "1" ] && rm -f $PIDFILE
echo "%! $OPERATION_ERRORS error(s)"
echo "%% All jobs done @ `LANG=C date`"
exit $OPERATION_ERRORS