676 lines
20 KiB
Bash
Executable File
676 lines
20 KiB
Bash
Executable File
function print_separator() {
|
|
echo "--------------------------------------------------------------------------------------------------"
|
|
}
|
|
|
|
# Gets svn revision for app whose tree starts in current dir.
|
|
# INPUT:
|
|
# arg1 (optional) dir to check, default is the current dir
|
|
# OUTPUT:
|
|
# $SVN_REVISION
|
|
function get_svn_revision {
|
|
local DIR=$1
|
|
if [ -n "$DIR" ]; then
|
|
pushd $DIR > /dev/null
|
|
fi
|
|
SVN_REVISION=""
|
|
local revision=$(svn info . | grep -i '^last changed rev' | cut '-d ' -f4)
|
|
local ccm_app=$(pwd | sed 's!.*/!!')
|
|
if [ -z "$revision" ]; then
|
|
echo "Could not find the most recent svn revision number for $ccm_app"
|
|
exit 1
|
|
fi
|
|
# Woo hoo, we have revision number now!
|
|
echo "Found the svn revision number for $ccm_app: $revision"
|
|
SVN_REVISION=".r$revision"
|
|
if [ -n "$DIR" ]; then
|
|
popd > /dev/null
|
|
fi
|
|
}
|
|
|
|
|
|
# Bails out if uncommitted svn changes found in current dir
|
|
function check_svn_clean {
|
|
local DIR=$1
|
|
if [ -n "$DIR" ]; then
|
|
pushd $DIR > /dev/null
|
|
fi
|
|
echo "Running 'svn status' in $(pwd)"
|
|
local svnstatus=$(svn st | grep -v '^\?')
|
|
if [ -n "$svnstatus" ]; then
|
|
echo "$svnstatus"
|
|
echo "Uncommited changes exist. Bailing out."
|
|
exit 1
|
|
fi
|
|
if [ -n "$DIR" ]; then
|
|
popd > /dev/null
|
|
fi
|
|
}
|
|
|
|
function check_svn_tagged {
|
|
SVN_REVISION=
|
|
if [ -n "$SVN_TAGGED" ]; then
|
|
check_svn_clean $@ && get_svn_revision $@
|
|
fi
|
|
}
|
|
|
|
# INPUT:
|
|
# arg1: Build root dir
|
|
# arg2: app dir, whose properties we're about to inquire
|
|
# arg3: SVN_TAGGED
|
|
# OUTPUT:
|
|
# $APP_NAME
|
|
# $APP_VERSION
|
|
# $RELEASE
|
|
function set_application_properties() {
|
|
|
|
local BUILD_HOME=$1
|
|
local APP=$2
|
|
local SVN_TAGGED=$3
|
|
|
|
local PROJ_FILE=$BUILD_HOME/$APP/project.xml
|
|
|
|
if [ ! -e $PROJ_FILE ]; then
|
|
echo "$PROJ_FILE doesn't exist"
|
|
exit 1;
|
|
fi
|
|
|
|
local VERSION_FROM=`grep "versionFrom=\".*\"" $PROJ_FILE | sed 's/.*versionFrom="\(.*\)"/\1/'`
|
|
|
|
if [ -z $VERSION_FROM ]; then
|
|
echo "versionFrom not found"
|
|
fi
|
|
|
|
local APP_FILE=$BUILD_HOME/$APP/$VERSION_FROM/application.xml
|
|
|
|
if [ ! -e $APP_FILE ]; then
|
|
echo "$APP_FILE doesn't exist"
|
|
exit 1
|
|
fi
|
|
|
|
local FRAGMENT=$BUILD_HOME/$APP/application.xml.frag
|
|
|
|
awk 'BEGIN { inTag = 0; } /<ccm:application/ { inTag=1; } inTag==1 { print $0; } inTag==1 && />/ { inTag = 0; }' \
|
|
$APP_FILE > $FRAGMENT
|
|
|
|
APP_VERSION=`grep 'version=\"[^"]*\"' $FRAGMENT | sed 's/.*version="\([^\"]*\)".*/\1/'`
|
|
RELEASE=`grep 'release=\"[^"]*\"' $FRAGMENT | sed 's/.*release="\([^\"]*\)".*/\1/'`
|
|
if [ -n "$SVN_TAGGED" ]; then
|
|
get_svn_revision $BUILD_HOME/$APP/$APP
|
|
RELEASE="${RELEASE}${SVN_REVISION}"
|
|
fi
|
|
|
|
APP_NAME=`grep 'name=\"[^"]*\"' $FRAGMENT | sed 's/.*name="\([^\"]*\)".*/\1/'`
|
|
|
|
rm -f $FRAGMENT
|
|
|
|
}
|
|
|
|
|
|
# Here's how we deal with eq,lt,le,gt,ge relations:
|
|
#
|
|
# [eq]: - easiest, we look for the exact match
|
|
#
|
|
# [ge]: we compose the list which is made up from
|
|
# installed version(s) of the required packages and the required
|
|
# version.
|
|
#
|
|
# An example:
|
|
# <ccm:requires name="ccm-core" version="6.1.2" relation="ge"/>
|
|
# Now suppose that we have following ccm-core available in our local rpm db:
|
|
# ccm-core-6.1.1
|
|
# ccm-core-6.1.3
|
|
#
|
|
# We now construct a list of versions:
|
|
#
|
|
# 6.1.1
|
|
# 6.1.3
|
|
# 6.1.2.-1
|
|
#
|
|
# First two are installed ones, the last is one mentioned in Requires:
|
|
# We call that one the 'tagged' version.
|
|
# We append '.-1' b/c we're just about to sort numerically that list, which
|
|
# will put the tagged version before the 6.1.2, if such exists. Sorting is
|
|
# performed numerically with field delimiter being period (.), so the sorted
|
|
# list looks like:
|
|
#
|
|
# 6.1.1
|
|
# 6.1.2.-1
|
|
# 6.1.3
|
|
#
|
|
# We now grep this list for the tagged version (6.1.2.-1), and take the first line *below*
|
|
# the match. In the case 6.1.2 was available, it will yield a match, since it will be
|
|
# the first one below the tag 6.1.2.-1. However, in our example, the match is '6.1.3'.
|
|
# In case there are no lines after the tagged version, dependencies can't be met.
|
|
#
|
|
# [le]: similar to [ge], except that the tagged version carries the .001 suffix.
|
|
# We proceed with composing the list and sorting it as above, but we take the first
|
|
# line *above* the tagged version. If no line exists above the tagged version,
|
|
# dependencies can't be met.
|
|
#
|
|
# [gt,lt]: similar to [ge,le], except that we do no funky suffixes to
|
|
# the tagged version. Every time we sort, we use '-u' to supress duplicate lines.
|
|
# We then grep for the tagged version and take the first one below or above it,
|
|
# respectively.
|
|
#
|
|
# INPUT:
|
|
# arg1: path to local rpm database
|
|
# arg2: package name to check
|
|
# arg3: package version to check; optional
|
|
# arg4: dependency relation (eq, le, lt, ge, gt); optional, default = eq
|
|
# checked only if package version (arg3) is provided
|
|
# OUTPUT:
|
|
# RPM_CHECK_ERROR: empty on successful check
|
|
# RPM_MATCH: version number of installed package that resolves dependency
|
|
#
|
|
function check_local_rpm() {
|
|
local rpmdb=$1
|
|
local pkg_name=$2
|
|
local pkg_version=$3
|
|
local pkg_relation=$4
|
|
|
|
if [ -z "$pkg_relation" ]
|
|
then
|
|
pkg_relation=eq
|
|
fi
|
|
|
|
local dependency="$2 $4 $3"
|
|
|
|
local output=""
|
|
local sortedoutput=""
|
|
local match=""
|
|
|
|
if [ -n "$pkg_version" ]
|
|
then
|
|
local pkg_tagged_version="$pkg_version"
|
|
|
|
# Mangle the tagged version
|
|
case $pkg_relation in
|
|
le) pkg_tagged_version="${pkg_version}.001";;
|
|
ge) pkg_tagged_version="${pkg_version}.-1";;
|
|
esac
|
|
|
|
output=$(rpm --dbpath $rpmdb -q --queryformat '%{VERSION}\n' $pkg_name | grep -v 'is not installed') || true;
|
|
sortedoutput=$(echo -e "$output\n$pkg_tagged_version")
|
|
|
|
sortedoutput=$(echo "$sortedoutput" | sort -u -n -t. -k1,1 -k2,2 -k3,3 -k4,4 -k5,5)
|
|
|
|
# echo -e "output: \n$output"
|
|
# echo -e "sortedoutput: \n$sortedoutput"
|
|
|
|
case $pkg_relation in
|
|
eq) match=$(echo "$output" | grep -F -x "$pkg_version") ;;
|
|
le|lt) match=$(echo "$sortedoutput" | grep -B1 -F -x "$pkg_tagged_version" | head --lines=-1) ;;
|
|
ge|gt) match=$(echo "$sortedoutput" | grep -A1 -F -x "$pkg_tagged_version" | tail --lines=+2) ;;
|
|
esac
|
|
else
|
|
output=$(rpm --dbpath $rpmdb -q --queryformat '%{VERSION}\n' $pkg_name | grep -v 'is not installed') \
|
|
&& match=$(echo "$output" | sort -u -n -t. -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 | tail -1)
|
|
fi
|
|
|
|
RPM_MATCH=""
|
|
RPM_CHECK_ERROR=""
|
|
|
|
if [ "$(echo "$match" | sed 's/ //g')" = "" ]
|
|
then
|
|
if [ "$output" != "" ]
|
|
then
|
|
RPM_CHECK_ERROR="'$output'"
|
|
else
|
|
RPM_CHECK_ERROR="'$pkg_name' not built at all"
|
|
fi
|
|
else
|
|
RPM_MATCH="$match"
|
|
fi
|
|
}
|
|
|
|
|
|
|
|
# Generate skeleton project.xml.
|
|
#
|
|
# We will generate the <ccm:prebuilt> block by expanding
|
|
# the <ccm:dependencies> for each required CCM app in turn.
|
|
# The actual expansion work will be done by a perl script.
|
|
# However we must deal with the relation="eq,gt,ge,lt,le" as well.
|
|
# This is where life gets interesting. This shell function will
|
|
# use:
|
|
# 1. the output of the perl script, which looks like:
|
|
# ccm-core -> version="6.1.1" relation="ge"
|
|
# ccm-forum -> version="1.4.2"
|
|
# 2. local rpm database
|
|
# to find out which RPM packages (installed in scratch RPM
|
|
# database, and which have been built during the execution of
|
|
# this very script) can satisfy the dependencies listed.
|
|
#
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
# arg2: ccm app name, which must match the directory name in
|
|
# the build root dir
|
|
#
|
|
# OUTPUT:
|
|
# - project.xml will be written to the $arg1/$arg2 directory
|
|
# - RPM_CHECK_ERROR will contain the error message, if something
|
|
# goes wrong, eg. unresolved dependencies
|
|
|
|
function write_project_xml() {
|
|
|
|
echo "Generating project.xml"
|
|
|
|
local BUILD_ROOT="$1"
|
|
local CCM_APP="$2"
|
|
|
|
local PROJ_FILE="$BUILD_ROOT/$CCM_APP/project.xml"
|
|
|
|
rm -f $PROJ_FILE
|
|
|
|
cat > $PROJ_FILE <<EOF
|
|
<?xml version="1.0" encoding="ISO-8859-1"?>
|
|
|
|
<ccm:project name="$CCM_APP"
|
|
prettyName="Red Hat Web Application Framework"
|
|
ccmVersion="6.1"
|
|
versionFrom="$CCM_APP"
|
|
xmlns:ccm="http://ccm.redhat.com/ccm-project">
|
|
|
|
<ccm:build>
|
|
<ccm:application name="$CCM_APP"/>
|
|
</ccm:build>
|
|
|
|
<ccm:prebuilt>
|
|
EOF
|
|
|
|
$BUILD_ROOT/tools/misc/expand-dependencies $BUILD_ROOT $CCM_APP |
|
|
while read app_dep
|
|
do
|
|
echo -n " Processing dependency: $app_dep"
|
|
|
|
local app_name=$(expr match "$app_dep" '\([^ ]*\) *->')
|
|
local app_version=$(expr match "$app_dep" '.*version="\([^"]*\)"')
|
|
local app_relation=$(expr match "$app_dep" '.*relation="\([^"]*\)"')
|
|
|
|
check_local_rpm $RPM_DB $app_name $app_version $app_relation
|
|
|
|
if [ -n "$RPM_CHECK_ERROR" ]
|
|
then
|
|
echo " ... $RPM_CHECK_ERROR"
|
|
# It seems there's no easy way to pass the error message to the caller
|
|
# b/c of while ... do ... done construct constraints
|
|
echo error >> $PROJ_FILE
|
|
else
|
|
echo " ... found '$RPM_MATCH'"
|
|
echo "<ccm:application name=\"$app_name\" version=\"$RPM_MATCH\"/>" >> $PROJ_FILE
|
|
fi
|
|
|
|
done
|
|
|
|
local FAILED=$(grep -c ^error $PROJ_FILE)
|
|
|
|
if [ "$FAILED" -gt 0 ]
|
|
then
|
|
echo "$FAILED unresolved dependencies"
|
|
exit 1
|
|
fi
|
|
|
|
|
|
cat >> $PROJ_FILE << EOF2
|
|
</ccm:prebuilt>
|
|
|
|
</ccm:project>
|
|
EOF2
|
|
|
|
echo "Successfully written $PROJ_FILE"
|
|
|
|
}
|
|
|
|
|
|
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
#
|
|
function set_environment() {
|
|
|
|
local BUILD_HOME=$1
|
|
export VIRTUAL_ROOT=$BUILD_HOME/root
|
|
if [ -f $BUILD_HOME/rpm ]
|
|
then
|
|
RPM="$BUILD_HOME/rpm"
|
|
else
|
|
RPM="$(which rpm)"
|
|
fi
|
|
|
|
export RPM
|
|
|
|
export RPM_DB=$VIRTUAL_ROOT/rpmdb
|
|
export RPM_ARGS="--dbpath $RPM_DB"
|
|
|
|
export HOMETOPDIR="$(echo ~/rpm)"
|
|
export HOMERPMDIR="$HOMETOPDIR/RPMS/noarch"
|
|
export HOMESRPMDIR="$HOMETOPDIR/SRPMS"
|
|
export HOMEBUILDDIR="$HOMETOPDIR/BUILD"
|
|
|
|
export PATH=$VIRTUAL_ROOT/usr/bin:$PATH
|
|
}
|
|
|
|
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
#
|
|
function build_tools() {
|
|
|
|
local BUILD_HOME=$1
|
|
set_environment $BUILD_HOME
|
|
|
|
rm -rf $VIRTUAL_ROOT
|
|
|
|
mkdir $VIRTUAL_ROOT
|
|
mkdir $RPM_DB
|
|
|
|
# (20041108 Seb)
|
|
# This directory must exist because 'rpm -i' of httpunit and friends will fail.
|
|
# In a real world, this dir would have been already created by the packages httpunit at ali depend on.
|
|
mkdir -p $VIRTUAL_ROOT/usr/share/java
|
|
mkdir -p $VIRTUAL_ROOT/etc/ccm
|
|
mkdir -p $VIRTUAL_ROOT/etc/profile.d
|
|
mkdir -p $VIRTUAL_ROOT/usr/share/ccm-tools
|
|
mkdir -p $VIRTUAL_ROOT/usr/share/doc
|
|
mkdir -p $VIRTUAL_ROOT/usr/bin
|
|
mkdir -p $VIRTUAL_ROOT/var/cache
|
|
mkdir -p $VIRTUAL_ROOT/var/lib/ccm
|
|
mkdir -p $VIRTUAL_ROOT/var/lib/ccm-devel
|
|
mkdir -p $VIRTUAL_ROOT/var/log
|
|
mkdir -p $VIRTUAL_ROOT/var/opt/ccm/data
|
|
|
|
$RPM $RPM_ARGS --initdb
|
|
|
|
cat > fake.spec <<EOF
|
|
Name: fake
|
|
Version: 2.0.0
|
|
Release: 1
|
|
BuildArchitectures: noarch
|
|
Summary: fake depends
|
|
License: None
|
|
Group: Fake
|
|
Provides: /bin/bash
|
|
Provides: /bin/sh
|
|
Provides: /usr/bin/perl
|
|
Provides: /bin/tar
|
|
Provides: /usr/bin/md5sum
|
|
Provides: /usr/bin/locate
|
|
Provides: /usr/bin/rpmbuild
|
|
Provides: /usr/bin/unzip
|
|
Provides: /usr/bin/zip
|
|
Provides: tomcat4
|
|
Provides: resin
|
|
Provides: perl(File::Path)
|
|
Provides: perl(Getopt::Long)
|
|
Provides: perl(Sys::Hostname)
|
|
Provides: perl(strict)
|
|
Provides: perl(Exporter)
|
|
Provides: perl(vars)
|
|
Provides: perl(Cwd)
|
|
Provides: perl(File::Basename)
|
|
Provides: perl(File::Spec)
|
|
Provides: perl(File::Copy)
|
|
Provides: perl(File::Find)
|
|
Provides: perl(File::stat)
|
|
Provides: perl(POSIX)
|
|
Provides: perl(Carp)
|
|
Provides: perl(lib)
|
|
Provides: perl
|
|
Provides: ant = 0:1.6.2
|
|
Provides: ant-nodeps = 0:1.6.2
|
|
Provides: ant-contrib = 0:0.6
|
|
|
|
|
|
%description
|
|
Fake
|
|
|
|
%files
|
|
EOF
|
|
|
|
rpmbuild --define="_topdir $HOMETOPDIR" -ba fake.spec
|
|
|
|
$RPM $RPM_ARGS -ivh --noscripts $HOMERPMDIR/fake-2.0.0-1.noarch.rpm
|
|
|
|
export RPM_DIR=$HOMETOPDIR
|
|
|
|
# Build the build tools
|
|
for i in ccm-java httpunit junit junitperf servlet
|
|
do
|
|
pushd $BUILD_HOME/tools/rpms/$i > /dev/null
|
|
(
|
|
print_separator
|
|
set -e
|
|
check_svn_tagged
|
|
./rollingbuild.sh
|
|
TOOLS_NAME=`grep 'Name:' *.spec | sed -e 's/Name://' | sed -e 's/ //g'`
|
|
TOOLS_VERSION=`grep 'Version:' *.spec | sed -e 's/Version://' | sed -e 's/ //g'`
|
|
TOOLS_RELEASE=`grep 'Release:' *.spec | sed -e 's/Release://' | sed -e 's/ //g'`
|
|
$RPM $RPM_ARGS -ivh --noscripts --relocate /usr=$VIRTUAL_ROOT/usr --relocate /etc=$VIRTUAL_ROOT/etc $HOMERPMDIR/$TOOLS_NAME-$TOOLS_VERSION-$TOOLS_RELEASE.noarch.rpm
|
|
) || exit $?
|
|
popd > /dev/null
|
|
done
|
|
|
|
pushd $BUILD_HOME/tools/tools > /dev/null
|
|
(
|
|
print_separator
|
|
set -e
|
|
check_svn_tagged
|
|
TOOLS_VERSION=`grep 'VERSION=' configure.in | sed -e 's/VERSION=//'`
|
|
TOOLS_RELEASE="`grep 'RELEASE=' configure.in | sed -e 's/RELEASE=//'`${SVN_REVISION}"
|
|
ccm_tools_home="$HOMEBUILDDIR/ccm-tools-$TOOLS_VERSION"
|
|
CCM_TOOLS_HOME="$ccm_tools_home" ./rollingbuild.sh
|
|
$RPM $RPM_ARGS -ivh --noscripts --relocate /usr=$VIRTUAL_ROOT/usr --relocate /etc=$VIRTUAL_ROOT/etc --relocate /var=$VIRTUAL_ROOT/var $HOMERPMDIR/ccm-tools-$TOOLS_VERSION-$TOOLS_RELEASE.noarch.rpm
|
|
) || exit $?
|
|
popd > /dev/null
|
|
. $VIRTUAL_ROOT/etc/profile.d/ccm-tools.sh
|
|
|
|
pushd $BUILD_HOME/tools/devel > /dev/null
|
|
(
|
|
print_separator
|
|
set -e
|
|
check_svn_tagged
|
|
CCM_TOOLS_HOME=$VIRTUAL_ROOT/usr/share/ccm-tools ./rollingbuild.sh
|
|
DEVEL_VERSION=`grep 'VERSION=' configure.in | sed -e 's/VERSION=//'`
|
|
DEVEL_RELEASE="`grep 'RELEASE=' configure.in | sed -e 's/RELEASE=//'`${SVN_REVISION}"
|
|
$RPM $RPM_ARGS -ivh --noscripts --relocate /usr=$VIRTUAL_ROOT/usr --relocate /etc=$VIRTUAL_ROOT/etc --relocate /var=$VIRTUAL_ROOT/var $HOMERPMDIR/ccm-devel-$DEVEL_VERSION-$DEVEL_RELEASE.noarch.rpm
|
|
) || exit $?
|
|
popd > /dev/null
|
|
. $VIRTUAL_ROOT/etc/profile.d/ccm-devel.sh
|
|
|
|
pushd $BUILD_HOME/tools/scripts > /dev/null
|
|
(
|
|
print_separator
|
|
set -e
|
|
check_svn_tagged
|
|
CCM_TOOLS_HOME=$VIRTUAL_ROOT/usr/share/ccm-tools ./rollingbuild.sh
|
|
SCRIPTS_VERSION=`grep 'VERSION=' configure.in | sed -e 's/VERSION=//'`
|
|
SCRIPTS_RELEASE="`grep 'RELEASE=' configure.in | sed -e 's/RELEASE=//'`${SVN_REVISION}"
|
|
$RPM $RPM_ARGS -ivh --noscripts --relocate /usr=$VIRTUAL_ROOT/usr --relocate /etc=$VIRTUAL_ROOT/etc $HOMERPMDIR/ccm-scripts-$SCRIPTS_VERSION-$SCRIPTS_RELEASE.noarch.rpm
|
|
) || exit $?
|
|
popd > /dev/null
|
|
. $VIRTUAL_ROOT/etc/profile.d/ccm-scripts.sh
|
|
|
|
pushd $BUILD_HOME/tools/bundle > /dev/null
|
|
(
|
|
print_separator
|
|
set -e
|
|
check_svn_tagged
|
|
./rollingbuild.sh
|
|
BUNDLE_VERSION=`grep 'VERSION=' configure.in | sed -e 's/VERSION=//'`
|
|
BUNDLE_RELEASE="`grep 'RELEASE=' configure.in | sed -e 's/RELEASE=//'`${SVN_REVISION}"
|
|
$RPM $RPM_ARGS -ivh --noscripts --relocate /usr=$VIRTUAL_ROOT/usr $HOMERPMDIR/ccm-tools-bundle-$BUNDLE_VERSION-$BUNDLE_RELEASE.noarch.rpm
|
|
) || exit $?
|
|
popd > /dev/null
|
|
|
|
# This is somewhat lame-ish way, but we really need
|
|
# ant-contrib package installed.
|
|
# The build system needs ant-contrib.jar (<if> task).
|
|
# It is no longer present in the ccm-devel, so the appropriate
|
|
# RPM must be installed beforehand.
|
|
|
|
if rpm -q ant-contrib | grep 'not installed'
|
|
then
|
|
echo "Please install ant-contrib RPM, the build system depends on it."
|
|
exit 1
|
|
else
|
|
for file in $(rpm -ql ant-contrib)
|
|
do
|
|
if [ -f $file ]
|
|
then
|
|
local dir=$VIRTUAL_ROOT${file%/*}
|
|
mkdir -p $dir
|
|
cp -f $file $dir
|
|
fi
|
|
done
|
|
fi
|
|
|
|
}
|
|
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
# arg2: ccm app dir below the build root
|
|
# $VIRTUAL_ROOT
|
|
# $SVN_TAGGED
|
|
# $RPM
|
|
# $RPM_ARGS
|
|
# $HOMERPMDIR
|
|
function build_app() {
|
|
local BUILD_ROOT=$1
|
|
local CCM_APP=$2
|
|
pushd $BUILD_ROOT/$CCM_APP > /dev/null
|
|
(
|
|
echo "BUILDING $CCM_APP"
|
|
|
|
write_project_xml $BUILD_ROOT $CCM_APP
|
|
|
|
rm -rf rollingbuild build MANIFEST MANIFEST.SKIP
|
|
|
|
check_svn_tagged $CCM_APP
|
|
|
|
CCM_SHARED_LIB_DIST_DIR=$VIRTUAL_ROOT/usr/share/java CCM_CONFIG_LIB_DIR=$VIRTUAL_ROOT/usr/share/java CCM_TOOLS_HOME=$VIRTUAL_ROOT/usr/share/ccm-tools CCM_SCRIPTS_HOME=$VIRTUAL_ROOT/usr/share/ccm-scripts CCM_CONFIG_HOME=$VIRTUAL_ROOT/usr/share/ccm-devel $VIRTUAL_ROOT/usr/share/ccm-scripts/bin/build.sh
|
|
|
|
) || exit $?
|
|
(
|
|
set -e
|
|
set_application_properties $BUILD_ROOT $CCM_APP $SVN_TAGGED
|
|
$RPM $RPM_ARGS --oldpackage --replacefiles --replacepkgs --relocate /usr=$VIRTUAL_ROOT/usr --relocate /etc=$VIRTUAL_ROOT/etc -Uvh $HOMERPMDIR/$APP_NAME-$APP_VERSION-$RELEASE.noarch.rpm
|
|
) || exit $?
|
|
popd > /dev/null
|
|
}
|
|
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
# arg2, arg3, ....: list of apps to build
|
|
# OUTPUT:
|
|
# $SORTED_APPS
|
|
#
|
|
function arrange_build_order() {
|
|
pushd $1 > /dev/null
|
|
shift
|
|
SORTED_APPS=""
|
|
local apps="$@"
|
|
local app_build_order=$(grep ccm:requires */*/application.xml | sed 's!^\(ccm-[^/]*\)/.*name="\([^"]*\)".*!\2 \1!' | tsort)
|
|
local app
|
|
for app in $app_build_order
|
|
do
|
|
if echo " ${apps} " | grep -F " ${app} " > /dev/null
|
|
then
|
|
SORTED_APPS="$SORTED_APPS $app"
|
|
fi
|
|
done
|
|
|
|
for app in $apps
|
|
do
|
|
if ! echo " ${SORTED_APPS} " | grep -F " ${app} " > /dev/null
|
|
then
|
|
echo "Could not read $app/*/application.xml."
|
|
echo "Make sure to include a copy or symbolic link of this application in the build area."
|
|
exit 1
|
|
fi
|
|
done
|
|
popd > /dev/null
|
|
}
|
|
|
|
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
# arg2, arg3, ....: list of apps to build
|
|
# OUTPUT:
|
|
# $RESOLVED_APPS ... a list of all applications to build, with dependencies resolved,
|
|
# might contain duplicates
|
|
#
|
|
function add_required_apps() {
|
|
local BUILD_HOME=$1
|
|
shift
|
|
RESOLVED_APPS=""
|
|
local app
|
|
local deps
|
|
for app in "$@"
|
|
do
|
|
deps=$($BUILD_HOME/tools/misc/expand-dependencies $BUILD_HOME $app) || {
|
|
echo " Could not build the dependencies for: $app"
|
|
echo " Consult earlier messages, if any, to determine the culprit."
|
|
exit 1
|
|
}
|
|
RESOLVED_APPS=$(echo -e "$app\n$RESOLVED_APPS\n$deps" | cut -d " " -f1)
|
|
done
|
|
# A lame way to convert all whitespace into single space, I know, ...
|
|
RESOLVED_APPS=$(echo $RESOLVED_APPS)
|
|
}
|
|
|
|
|
|
# INPUT:
|
|
# arg1: build root dir
|
|
# arg2: list of args to build supplied on the command line
|
|
# arg3: app to check and, maybe, build
|
|
# $RPM_DB
|
|
#
|
|
# The arg3 app will be built unconditionally if it's included in $BUILD_ARGS.
|
|
# Otherwise, it will only be built if it hasn't already been built.
|
|
#
|
|
function build_app_conditionally() {
|
|
local BUILD_ROOT=$1
|
|
local BUILD_ARGS=$2
|
|
local CCM_APP=$3
|
|
if echo " $BUILD_ARGS " | grep -F " ${CCM_APP} " > /dev/null
|
|
then
|
|
build_app $BUILD_ROOT $CCM_APP
|
|
else
|
|
check_local_rpm $RPM_DB $CCM_APP
|
|
if [ -z "$RPM_CHECK_ERROR" ]
|
|
then
|
|
echo "Application '$CCM_APP' appears already built ($RPM_MATCH), skipping ..."
|
|
else
|
|
build_app $BUILD_ROOT $CCM_APP
|
|
fi
|
|
fi
|
|
print_separator
|
|
}
|
|
|
|
|
|
# INPUT:
|
|
# arg1: path to local rpm database
|
|
# arg2: non-empty if -x has been provided on the command line
|
|
# $RPM_DB
|
|
#
|
|
# OUTPUT:
|
|
# $BUILD_TOOLS non-empty if tools must be built
|
|
#
|
|
function check_tools() {
|
|
BUILD_TOOLS=yes
|
|
if [ -n "$2" ]
|
|
then
|
|
echo "Starting the build process from scratch on user demand (-x flag provided)."
|
|
elif rpm -q --dbpath $1 ccm-tools-bundle > /dev/null
|
|
then
|
|
BUILD_TOOLS=
|
|
echo "Tools OK."
|
|
else
|
|
echo "Starting the build process from scratch, tools appear built incompletely or not at all."
|
|
fi
|
|
echo "${BUILD_TOOLS:+..... Building: TOOLS}"
|
|
}
|
|
|
|
|
|
|