Build/AtlasBuildScripts/checkout_atlasexternals.sh

+#!/bin/bash
+#
+# Script for automating the checkout of the atlasexternals repository when
+# building the whole software stack in a nightly/release.
+#
+# The script must receive the tag/branch that should be checked out of the
+# atlasexternals repository. And it can write the commit hash that the
+# checkout ended up with, into another file.
+#
+
+# Stop on errors:
+set -e
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: checkout_atlasexternals.sh [options]"
+    echo "  Options:"
+    echo "    -t branch/tag: Mandatory branch/tag/hash to check out"
+    echo "    -s directory: Mandatory source directory to use"
+    echo "    -e url: Optional source URL to use for the checkout"
+    echo
+    echo "  This script will allow the environment variables"
+    echo "  AtlasExternals_URL and AtlasExternals_REF to override"
+    echo "  other values (even those on the command line)."
+    echo "  If AtlasExternals_URL is set to 'current' then"
+	echo "  no clone or checkout is done and the working copy"
+	echo "  in the source directory is left untouched."
+}
+
+_max_retry_=5
+
+_retry_ () {
+    local cmd="$*"
+    local n=0
+    while ! $cmd ; do
+        if test $n -eq $_max_retry_ ; then
+            echo "ERROR: $cmd FAILED $_max_retry_ times. EXIT(1)" >&2
+            exit 1
+        fi
+        echo "WARNING: $cmd FAILED, retry in 30 sec ... "
+        sleep 30s
+        n=`expr $n + 1`
+    done
+}
+
+_max_retry_=5
+
+_retry_ () {
+    local cmd="$*"
+    local n=0
+    while ! $cmd ; do
+        if test $n -eq $_max_retry_ ; then
+            echo "ERROR: $cmd FAILED $_max_retry_ times. EXIT(1)" >&2
+            exit 1
+        fi
+        echo "WARNING: $cmd FAILED, retry in 30 sec ... "
+        sleep 30s
+        n=`expr $n + 1`
+    done
+}
+
+# Parse the command line arguments:
+TAGBRANCH=""
+SOURCEDIR=""
+EXTERNALSURL="https://gitlab.cern.ch/atlas/atlasexternals.git"
+while getopts ":t:o:s:e:h" opt; do
+    case $opt in
+        t)
+            TAGBRANCH=$OPTARG
+            ;;
+        s)
+            SOURCEDIR=$OPTARG
+            ;;
+        e)
+            EXTERNALSURL=$OPTARG
+            ;;
+        h)
+            usage
+            exit 0
+            ;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+if [ "$AtlasExternals_URL" != "" ]; then
+	EXTERNALSURL=$AtlasExternals_URL
+	echo "Externals URL overridden to $EXTERNALSURL from environment"
+	if [ "$AtlasExternals_URL" = "current" ]; then
+		echo "Leaving current checkout in place for build"
+		exit 0
+	fi 
+fi
+
+if [ "$AtlasExternals_REF" != "" ]; then
+	TAGBRANCH=$AtlasExternals_REF
+	echo "Externals ref overridden to $TAGBRANCH from environment"
+fi
+
+# The tag/branch and a source directory must have been specified:
+if [ "$TAGBRANCH" = "" ] || [ "$SOURCEDIR" = "" ]; then
+    echo "Not all required arguments were provided!"
+    usage
+    exit 1
+fi
+
+# Tell the user what will happen:
+echo "Checking out atlasexternals tag/branch: $TAGBRANCH"
+echo "   from: $EXTERNALSURL"
+
+if [ ! -d "${SOURCEDIR}" ]; then
+    # Clone the repository:
+    _retry_ git clone ${EXTERNALSURL} ${SOURCEDIR}
+else
+    echo "${SOURCEDIR} already exists -> assume previous checkout"
+fi
+
+# Get the appropriate version of it:
+cd ${SOURCEDIR}
+_retry_ git fetch --prune origin
+_retry_ git checkout -f ${TAGBRANCH}

Build/AtlasBuildScripts/copy_rpm_eos.sh

+#!/bin/bash
+#
+# Script to copy local nightly RPMs to EOS and run createrepo
+#
+
+ERROR_COUNT=0
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: copy_rpm_eos.sh <-b branch> <-a arch> <-d week_day> <-s source dir> " 
+	echo "copy_rpm_eos.sh -b 22.0.X -a x86_64-slc6-gcc49-opt -s /build2/atnight/localbuilds/nightlies/22.0.X-GIT/build"
+
+}
+
+# Parse the command line arguments
+BRANCH=""
+ARCH=""
+SOURCEDIR=""
+WEEKDAY=""
+DESTDIR="/eos/project/a/atlas-software-dist/www/RPMs/nightlies"
+
+while getopts ":b:a:s:d:" opt; do
+	case $opt in
+	    b)
+			BRANCH=$OPTARG
+			;;
+		a) 
+			ARCH=$OPTARG
+			;;
+		s)
+			SOURCEDIR=$OPTARG
+			;;
+		d)
+			WEEKDAY=$OPTARG
+			;;
+			
+		:)
+			echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+# Make sure that the required options were all specified:
+if  [ "$BRANCH" = "" ] || [ "$ARCH" = "" ] || [ "$SOURCEDIR" = "" ] ; then
+    echo "Not all required parameters received!"
+    usage
+    exit 1
+fi
+
+if [ "$WEEKDAY" = "" ]; then
+   DDAY=rel_`date +%w`
+else 
+   DDAY=${WEEKDAY}
+fi
+
+echo "====================================================="
+echo "=== STARTING RPMs copy to /eos at `date`"
+echo "====================================================="
+
+
+DESTDIR=${DESTDIR}/${BRANCH}/${ARCH}/${DDAY}
+
+_retry_() {
+    local cmd="$*" dt=16 retr=0
+    while ! $cmd ; do
+        if test $retr -ge 6 ; then
+            echo "ERROR: 6 retries of $cmd FAILED ... " >&2
+            return 1
+        fi
+        echo "WARNING: $cmd failed, waiting $dt sec ..."
+        sleep ${dt}s
+        dt=`expr $dt + $dt`
+        retr=`expr $retr + 1`
+    done
+    return 0
+}
+
+if [ ! -d ${DESTDIR} ] ; then 
+   echo "mkdir -p ${DESTDIR}"
+   _retry_ mkdir -p ${DESTDIR} 
+   if [ ! -d ${DESTDIR} ] ; then ((ERROR_COUNT++)) ; fi  #avoid false positive eos error if the directory was actually created
+fi
+
+echo "====================================================="
+echo "=== Create repodata on local machine"
+echo "====================================================="
+echo "nicos_rpm::::::: createrepo --workers 8 --update ${SOURCEDIR} :::::::" `date`
+createrepo --workers 8 --update ${SOURCEDIR} || ((ERROR_COUNT++))
+
+arr_rpm=(`(shopt -s nocaseglob; ls ${SOURCEDIR}/*.rpm)`)
+if [ "${#arr_rpm[@]}" -le 0 ]; then
+   echo "nicos_rpm: Warning: no rpm files are found in ${SOURCEDIR}"
+   ((ERROR_COUNT++))
+ else
+   for ele in "${arr_rpm[@]}" 
+   do
+      echo "Info: copying $ele to ${DESTDIR}"                                                 
+      _retry_ cp -a $ele ${DESTDIR} || ((ERROR_COUNT++))
+   done
+fi 
+
+echo "====================================================="
+echo "=== Copy repodata to nightly eos location"
+echo "====================================================="
+echo "Info: copying ${SOURCEDIR}/repodata to ${DESTDIR}" 
+_retry_ cp -a -rf ${SOURCEDIR}/repodata ${DESTDIR} || ((ERROR_COUNT++))
+
+exit ${ERROR_COUNT}

Build/AtlasBuildScripts/tag_build.sh

+#! /bin/bash
+#
+# Copyright (C) 2017 CERN for the benefit of the ATLAS collaboration
+#
+
+# Function printing the usage information for the script
+usage() {
+    echo "Usage: tag_build.sh [-d date_stamp] [-u repository_url]" \
+		" Tag a 'nightly' build based on the current branch and timestamp."\
+		" This script should really only be used by NICOS to tag nightly builds."\
+		" Private builds should not do this."\
+        " 'date_stamp' defaults to $datestamp, repository_url to the ATLAS athena"\
+        " repository in CERN GitLab (krb5 authenticated)"
+}
+
+# Parse the command line arguments:
+DATESTAMP="$datestamp"
+REPOURL="https://:@gitlab.cern.ch:8443/atlas/athena.git"
+while getopts ":d:u:h" opt; do
+    case $opt in
+        d)
+            DATESTAMP=$OPTARG
+            ;;
+        u)
+            REPOURL=$OPTARG
+            ;;
+        h)
+        	usage
+        	exit 0
+        	;;
+        :)
+            echo "Argument -$OPTARG requires a parameter!"
+            usage
+            exit 1
+            ;;
+        ?)
+            echo "Unknown argument: -$OPTARG"
+            usage
+            exit 1
+            ;;
+    esac
+done
+
+# Check we got a datestamp and that it's a valid format
+if [ "$DATESTAMP" = "" ]; then
+	echo "No date_stamp defined from NICOS or given as a parameter"
+	exit 1
+fi
+echo $DATESTAMP | egrep "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{4}$" >& /dev/null
+if [ $? != "0" ]; then
+	echo "Datestamp '$DATESTAMP' does not correspond to the ATLAS format YYYY-MM-DDTHHMM"
+	exit 1
+fi
+
+# Abort if any of the next commands fail
+set -e
+
+# Use the source of this script to ensure that we cd to within the root of the
+# local repository
+ScriptSrcDir=$(dirname ${BASH_SOURCE[0]})
+cd $ScriptSrcDir/../..
+
+# Get branch name, then tag and push
+BRANCH=$(git symbolic-ref --short HEAD)
+TAG="nightly/$BRANCH/$DATESTAMP"
+echo "Creating tag $TAG"
+git tag $TAG
+git push $REPOURL $TAG

Build/AtlasCMake/AtlasCMakeConfig-version.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: AtlasCMakeConfig-version.cmake 711151 2015-11-27 12:00:55Z krasznaa $
-
-# The version is just a dummy. Note that we can't actually use svn's
-# Revision keyword here... (As it's not in a format that CMake would
-# understand as a version.)
-set( PACKAGE_VERSION "1.0.0" )
-
-# Check whether the requested PACKAGE_FIND_VERSION is compatible with this
-# installed version:
-if( "${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" )
-   set( PACKAGE_VERSION_COMPATIBLE FALSE )
-else()
-   set( PACKAGE_VERSION_COMPATIBLE TRUE )
-   if( "${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}" )
-      set( PACKAGE_VERSION_EXACT TRUE )
-   endif()
-endif()

Build/AtlasCMake/AtlasCMakeConfig.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: AtlasCMakeConfig.cmake 746543 2016-05-12 11:31:22Z krasznaa $
-#
-# This file is used to make it possible to pull in the code of this package into
-# a top level CMake file using:
-#
-#   find_package( AtlasCMake )
-#
-# Then, to make CMake find this file correctly, one has to use something like
-# the following on the command line:
-#
-#   CMAKE_PREFIX_PATH=../source/AtlasCMake cmake ../source
-#
-# Or:
-#
-#   cmake -DAtlasCMake_DIR=../source/AtlasCMake ../source
-#
-# The meat of the code is in the other files of the package, this file just
-# provides the interface to the find_package(...) function.
-
-# Print a status message that the file was found:
-if( NOT AtlasCMake_FIND_QUIETLY )
-   message( STATUS "AtlasCMake found with version: $Revision: 746543 $" )
-endif()
-
-# Get the current directory:
-get_filename_component( _thisdir "${CMAKE_CURRENT_LIST_FILE}" PATH )
-if( NOT AtlasCMake_FIND_QUIETLY )
-   message( STATUS "Including ATLAS CMake code from directory: ${_thisdir}" )
-endif()
-set( ATLASCMAKE_MODULEDIR ${_thisdir}/modules CACHE STRING
-   "Directory holding the ATLAS CMake files" FORCE )
-
-# Add it to the CMake module path:
-list( INSERT CMAKE_MODULE_PATH 0 ${_thisdir}/modules )
-list( REMOVE_DUPLICATES CMAKE_MODULE_PATH )
-
-# Make sure that since this project is being included directly, the built
-# projects don't shadow the modules of this package with possibly older
-# versions of the files.
-set( ATLAS_DONT_PREPEND_PROJECT_MODULES TRUE
-   CACHE BOOL "Prevent built projects from prepending to CMAKE_MODULE_PATH" )
-
-# Install the helper script(s) from the package:
-install( PROGRAMS ${_thisdir}/scripts/acmake.py DESTINATION bin )
-install( DIRECTORY ${_thisdir}/cmt2cmake DESTINATION .
-   USE_SOURCE_PERMISSIONS
-   PATTERN ".*" EXCLUDE
-   PATTERN "*.pyc" EXCLUDE )
-
-# If CTEST_USE_LAUNCHERS is turned on, create a dummy log file already
-# during configuration, which NICOS can pick up, and conclude that the
-# package's "build" was successful.
-if( CTEST_USE_LAUNCHERS )
-   file( MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/BuildLogs )
-   file( WRITE ${CMAKE_BINARY_DIR}/BuildLogs/AtlasCMake.log
-      "Dummy build log\n"
-      "AtlasCMake: Package build succeeded" )
-endif()
-
-# Include the AtlasFunctions file:
-include( AtlasFunctions )
-
-# For now include the Athena adaptor functions:
-include( AthenaFunctions )
-
-# Enable/Configure the use of CTest in the project:
-atlas_ctest_setup()
-
-# Environment variable(s) needed for the build:
-set( ATLASCMAKE_ENVIRONMENT
-   APPEND PATH \${${CMAKE_PROJECT_NAME}_DIR}/cmt2cmake
-   SET GFORTRAN_UNBUFFERED_ALL "y" )
-
-# If there's a version file available, declare the version of this package
-# to the project:
-if( EXISTS ${_thisdir}/version.cmake )
-   file( READ ${_thisdir}/version.cmake _version LIMIT 10000 )
-   set_property( GLOBAL APPEND PROPERTY ATLAS_SPECIAL_PACKAGES
-      "Build/AtlasCMake" "${_version}" )
-elseif( EXISTS ${_thisdir}/cmt/version.cmt )
-   file( READ ${_thisdir}/cmt/version.cmt _version LIMIT 10000 )
-   set_property( GLOBAL APPEND PROPERTY ATLAS_SPECIAL_PACKAGES
-      "Build/AtlasCMake" "${_version}" )
-endif()
-
-# Clean up:
-unset( _thisdir )

Build/AtlasCMake/cmt/README

-The only reason this package has a cmt/ subdirectory, and a requirements file
-in it, is to make it usable in TagCollector. Once the existence of a
-requirements file will no longer be necessary for our release management
-infrastructure, this subdirectory should be removed.

Build/AtlasCMake/cmt/requirements

-package AtlasCMake
-
-author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>

Build/AtlasCMake/cmt2cmake/README.rst

-Instructions for the cmt2cmake.py tool
-======================================
-
-Introduction
-------------
-The script ``cmt2cmake.py`` is a tool that can convert the configuration of a
-CMT_ project based on Gaudi_ to the equivalent one for CMake.
-
-This tools have limitations: it cannot cover all the possible cases, so, in some
-(hopefully few) circumstances, there is the need for manual adaptation of the
-generated files.
-
-To be noted that ``cmt2cmake.py`` doesn't use CMT and, instead of analyzing what
-CMT_ would do, it parses the configuration files (``requirements``) to try to
-understand what the developer wanted to do. Because of this approach, it
-requires a cache with the information collected for the projects the one to be
-converted depends on.  This cache has to be in the same directory as the script
-and can be easily generated running the script on all the required projects.
-
-Usage
------
-The usage is simple: just go to the top directory of the project to be converted
-and call the script.
-
-For example, to process LHCb, one has to prepare the cache for the information
-of Gaudi::
-
-    $ python cmt2cmake.py --cache-only /path/to/Gaudi
-
-The next step is to translate LHCb::
-
-    $ python cmt2cmake.py --cache-only /path/to/LHCb
-    $ python cmt2cmake.py /path/to/LHCb
-
-The first call updates the cache so that it can be used for the
-interdependencies of the packages in LHCb.
-
-Configuration
--------------
-Some packages need special treatment. Few cases are supported:
-
-    - `ignored_packages`: packages that should not treated at all
-    - `data_packages`: known data packages, cannot be used in dependencies
-    - `needing_python`: packages that need to link against Python
-    - `no_pedantic`: packages that cannot compile of the -pedantic option is used
-    - `ignore_env`: special environment variables that should not be set in CMake
-
-The configuration required for the conversion of a project can be stored in a
-JSON file called `cmt2cmake.cfg` at the top level directory of the project.
-
-It must be noted that `ignored_packages` and `data_packages` require the full
-name of the package (hat+name) while the others use only the simple package name
-(without hat).
-
-Testing
--------
-This directory contains also the tests for ``cmt2cmake.py``, written for
-nosetests_. To run the tests it is enough to go to the directory containing
-``cmt2cmake.py`` and call the nosetests command::
-
-    $ cd /path/to/cmt2cmake
-    $ nosetests -v --with-doctest
-
-
-Note
-----
-The parsing of CMT ``requirements`` files is implemented using the module
-``pyparsing``_. To simplify the use of the script, a copy of it is available
-together with the script itself.
-
-
-.. _CMT: http://www.cmtsite.org
-.. _CMake: http://www.cmake.org
-.. _Gaudi: http://cern.ch/gaudi
-.. _pyparsing: http://pyparsing.wikispaces.com
-.. _nosetests: http://nose.readthedocs.org
-

Build/AtlasCMake/cmt2cmake/cmt2cmake.cfg

-{
-   "ignored_packages": [
-      "AtlasExternalsRelease", "DetCommonRelease", "AtlasCoreRelease",
-      "AtlasConditionsRelease", "AtlasEventRelease", "AtlasReconstructionRelease",
-      "AtlasTriggerRelease", "AtlasAnalysisRelease", "AtlasSimulationRelease",
-      "AtlasOfflineRelease", "AtlasHLTRelease", "DetCommonRunTime", "AtlasCoreRunTime",
-      "AtlasConditionsRunTime", "AtlasEventRunTime", "AtlasReconstructionRunTime",
-      "AtlasTriggerRunTime", "AtlasAnalysisRunTime", "AtlasSimulationRunTime",
-      "AtlasOfflineRunTime", "AtlasHLTRunTime", "DetCommonPolicy", "AtlasCommonPolicy",
-      "AtlasCxxPolicy", "AtlasFortranPolicy",  "AtlasPolicy", "External/ExternalPolicy",
-      "External/AtlasCompilers",  "LCG_Settings", "LCG_Configuration", "LCG_Platforms", 
-      "TDAQCPolicy/TDAQCPolicyExt", 
-      "Tools/RunTimeTester/testsuite/testsuites/linuxinteractive/TestProject",
-      "Tools/RunTimeTester/testsuite/testsuites/linuxinteractive/Control/AthenaExamples/AthExHelloWorld",
-      "graphics/VP1/VP1Qt", "graphics/VP1/VP1Qwt",
-      "Build/AtlasCMake", "Build/AtlasLCG"
-   ],
-   "data_packages": [],
-   "needing_python": [],
-   "no_pedantic": [],
-   "ignore_env": [ "EXPORT_ALL_SYMBOLS" ]
-}

Build/AtlasCMake/cmt2cmake/test_cmt_parser.py

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-from cmt2cmake import makeParser
-from pyparsing import ParseException
-
-CMTParser = makeParser(set(["QMTest", "install_python_modules", "install_scripts",
-                            "install_more_includes", "god_headers", "god_dictionary",
-                            "PyQtResource", "PyQtUIC"])
-                       | set(['reflex_dictionary', 'component_library', 'linker_library',
-                              'copy_relax_rootmap']))
-def _test_package():
-    tokens = list(CMTParser.parseString('package Test'))
-    assert tokens == ['package', 'Test']
-
-def test_version():
-    tokens = list(CMTParser.parseString('version v1r2p3'))
-    assert tokens == ['version', 'v1r2p3']
-
-def test_library():
-    statement = 'library  GaudiKernelLib  *.cpp  -no_static  -import=Boost'
-    tokens = list(CMTParser.parseString(statement))
-    print tokens
-    assert tokens == ['library', 'GaudiKernelLib', '*.cpp', '-no_static', '-import=Boost']
-
-    statement = 'library  TestLib  test/lib/*.cpp  a_variable=some_value  -group=tests'
-    tokens = list(CMTParser.parseString(statement))
-    print tokens
-    assert tokens == ['library', 'TestLib', 'test/lib/*.cpp', 'a_variable=some_value', '-group=tests']
-
-def test_macro():
-    s = 'macro_append ROOT_linkopts "some" WIN32 "other"'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['macro_append', 'ROOT_linkopts', '"some"', 'WIN32', '"other"']
-
-    s = 'macro a_var "value"'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['macro', 'a_var', '"value"']
-
-    s = 'macro a_var'
-    try:
-        tokens = list(CMTParser.parseString(s))
-        assert False, 'parsing should have failed: %r' % s
-    except ParseException:
-        pass
-
-def test_apply_pattern():
-    s = 'apply_pattern component_library library=L0DU'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['apply_pattern', 'component_library', 'library=L0DU']
-
-def test_implicit_apply_pattern():
-    s = 'component_library library=L0DU'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['apply_pattern', 'component_library', 'library=L0DU']

Build/AtlasCMake/modules/AthenaFunctions.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: AthenaFunctions.cmake 717517 2016-01-13 13:06:59Z krasznaa $
-#
-# This file collects the functions forming a bridge between the calls made in
-# the offline packages at the time of writing, and the functions implemented
-# in AtlasFunctions.cmake.
-#
-
-# Include the required module(s):
-include( AtlasFunctions )
-
-# A very simple call forwarding to atlas_subdir.
-#
-# Note  that one actually has to use a macro here, and not a function. As the
-# atlas_subdir function makes the assumption that when it sets some variables
-# in its parents' scope, that is the scope of the package's CMakeLists.txt
-# file.
-#
-# Usage: athena_subdir( MyPackage None )
-#
-macro( athena_subdir name version )
-   atlas_subdir( ${name} ${version} )
-endmacro( athena_subdir )
-
-# Hide the function when building Gaudi itself...
-if( NOT GAUDI_ATLAS )
-   # A very simple call forwarding to atlas_depends_on_subdirs.
-   #
-   # In this case we may have used either a function or a macro. I just chose
-   # a function because I thoguht that it would result in cleaner code.
-   #
-   # Usage: gaudi_depends_on_subdirs( Control/AthContainers ... )
-   #
-   function( gaudi_depends_on_subdirs )
-      atlas_depends_on_subdirs( ${ARGN} )
-   endfunction( gaudi_depends_on_subdirs )
-endif()
-
-# Provide a function for setting up the NightlyBuild.cmake and
-# ExperimentalBuild.cmake scripts for building Gaudi.
-#
-# Usage: gaudi_ctest_setup()
-#
-macro( gaudi_ctest_setup )
-
-   # First call the basic setup:
-   atlas_ctest_setup()
-
-   # Get the number of processor cores to use for the compilation.
-   # Used by the release building script(s).
-   atlas_cpu_cores( PROCESSOR_COUNT )
-
-   # Get the name of the running machine. Needed for the CTest script(s).
-   site_name( SITE_NAME )
-
-   # Construct a platform name:
-   atlas_platform_id( BUILDNAME )
-
-   # Generate the build control script(s):
-   find_file( _expBuild ExperimentalBuild.cmake.in
-      PATH_SUFFIXES skeletons PATHS ${CMAKE_MODULE_PATH} )
-   configure_file( ${_expBuild}
-      ${CMAKE_BINARY_DIR}/ExperimentalBuild.cmake @ONLY )
-   unset( _expBuild )
-   find_file( _nightlyBuild NightlyBuild.cmake.in
-      PATH_SUFFIXES skeletons PATHS ${CMAKE_MODULE_PATH} )
-   configure_file( ${_nightlyBuild}
-      ${CMAKE_BINARY_DIR}/NightlyBuild.cmake @ONLY )
-   unset( _nightlyBuild )
-
-   # Unset the now unnecessary variables:
-   unset( PROCESSOR_COUNT )
-   unset( SITE_NAME )
-
-endmacro( gaudi_ctest_setup )
-
-# A very simple call forwarding to atlas_install_headers.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_install_headers( HeaderDir )
-#
-function( athena_install_headers )
-   atlas_install_headers( ${ARGN} )
-endfunction( athena_install_headers )
-
-# A very simple call forwarding to atlas_install_python_modules.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_install_python_modules( python/*.py )
-#
-function( athena_install_python_modules )
-   atlas_install_python_modules( ${ARGN} )
-endfunction( athena_install_python_modules )
-
-# A very simple call forwarding to atlas_install_joboptions.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_install_joboptions( share/*.py )
-#
-function( athena_install_joboptions )
-   atlas_install_joboptions( ${ARGN} )
-endfunction( athena_install_joboptions )
-
-# A very simple call forwarding to atlas_install_docs.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_install_docs( doc/*.html )
-#
-function( athena_install_docs )
-   atlas_install_docs( ${ARGN} )
-endfunction( athena_install_docs )
-
-# A very simple call forwarding to atlas_add_alias.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_alias( newName command1 command2... )
-#
-function( athena_alias name )
-   atlas_add_alias( ${name} ${ARGN} )
-endfunction( athena_alias )
-
-# A very simple call forwarding to atlas_install_runtime.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_install_runtime( share/*.sh )
-#
-function( athena_install_runtime )
-   atlas_install_runtime( ${ARGN} )
-endfunction( athena_install_runtime )
-
-# A very simple call forwarding to atlas_install_xmls.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_install_xmls( data/*.xml )
-#
-function( athena_install_xmls )
-   atlas_install_xmls( ${ARGN} )
-endfunction( athena_install_xmls )
-
-# This is a convenience function to translate between the offline script
-# installation mechanism and the RootCore one. On this function I'm actually
-# not sure that my interface would be the superior one. :-/ So maybe I'll just
-# introduce a function called atlas_install_scripts later on...
-#
-function( athena_install_scripts )
-
-   # This rule is ignored in release mode:
-   if( ATLAS_RELEASE_MODE )
-      return()
-   endif()
-
-   # Call atlas_add_executable with the right options for all the arguments
-   # received:
-   foreach( _file ${ARGN} )
-      # Find all such files:
-      file( GLOB _scripts RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${_file} )
-      foreach( _script ${_scripts} )
-         # Get the name of the script file:
-         get_filename_component( _scriptFile ${_script} NAME )
-         # Call atlas_add_executable:
-         atlas_add_executable( ${_scriptFile} SCRIPT ${_script} )
-      endforeach()
-   endforeach()
-
-endfunction( athena_install_scripts )
-
-# This function adapts the slightly weird function calls of the offline
-# release to the atlas_add_library function. Eventually the offline code
-# should migrate to use atlas_add_library directly.
-#
-# The offline code declares include and library dependencies on external
-# projects using the project names. And not the actual include directories
-# or library names. This code makes sure that those declarations are
-# interpreted in the way it was intended.
-#
-# Usage: athena_add_library( libraryName source1.cxx source2.cxx...
-#                            [NO_PUBLIC_HEADERS | PUBLIC_HEADERS HeaderDir...]
-#                            [INCLUDE_DIRS ROOT...]
-#                            [LINK_LIBRARIES Library1 Library2...] )
-#
-function( athena_add_library libName )
-
-   # We tweak the INCLUDE_DIRS and LINK_LIBRARIES parameters...
-   cmake_parse_arguments( ARG "" "" "INCLUDE_DIRS;LINK_LIBRARIES" ${ARGN} )
-
-   # Construct the arguments for the atlas_add_library call:
-   set( _args ${ARG_UNPARSED_ARGUMENTS} )
-
-   # Massage the include declarations:
-   if( ARG_INCLUDE_DIRS )
-      # Translate the specified "includes":
-      atlas_get_includes( ARG_INCLUDE_DIRS _includes )
-      # Now add them to the arguments:
-      list( APPEND _args INCLUDE_DIRS )
-      list( APPEND _args ${_includes} )
-   endif()
-
-   # Massage the library declarations:
-   if( ARG_LINK_LIBRARIES )
-      # Translate the specified "libraries":
-      atlas_get_libraries( ARG_LINK_LIBRARIES _libraries )
-      # Now add them to the arguments:
-      list( APPEND _args LINK_LIBRARIES )
-      list( APPEND _args ${_libraries} )
-   endif()
-
-   # Now call the underlying function:
-   atlas_add_library( ${libName} ${_args} )
-
-endfunction( athena_add_library )
-
-# Just like athena_add_library, this function takes care of interpreting
-# the includes and libraries coming from external packages correctly for the
-# offline build.
-#
-# Usage: athena_add_component( libraryName source1.cxx source2.cxx...
-#                              [NOCLIDDB]
-#                              [GENCONF_PRELOAD preload]
-#                              [INCLUDE_DIRS ROOT...]
-#                              [LINK_LIBRARIES Library1 Library2...] )
-#
-function( athena_add_component libName )
-
-   # We tweak the INCLUDE_DIRS and LINK_LIBRARIES parameters...
-   cmake_parse_arguments( ARG "" "" "INCLUDE_DIRS;LINK_LIBRARIES" ${ARGN} )
-
-   # Construct the arguments for the atlas_add_library call:
-   set( _args ${ARG_UNPARSED_ARGUMENTS} )
-
-   # Massage the include declarations:
-   if( ARG_INCLUDE_DIRS )
-      # Translate the specified "includes":
-      atlas_get_includes( ARG_INCLUDE_DIRS _includes )
-      # Now add them to the arguments:
-      list( APPEND _args INCLUDE_DIRS )
-      list( APPEND _args ${_includes} )
-   endif()
-
-   # Massage the library declarations:
-   if( ARG_LINK_LIBRARIES )
-      # Translate the specified "libraries":
-      atlas_get_libraries( ARG_LINK_LIBRARIES _libraries )
-      # Now add them to the arguments:
-      list( APPEND _args LINK_LIBRARIES )
-      list( APPEND _args ${_libraries} )
-   endif()
-
-   # Now call the underlying function:
-   atlas_add_component( ${libName} ${_args} )
-
-endfunction( athena_add_component )
-
-# A very simple call forwarding to atlas_generate_cliddb.
-#
-# The function just provides an alias for the atlas prefixed function behaving
-# the same way as the offline code expects it to work.
-#
-# Usage: athena_generate_cliddb( MyLibrary )
-#
-function( athena_generate_cliddb )
-
-   # Forward the call:
-   atlas_generate_cliddb( ${ARGN} )
-
-endfunction( athena_generate_cliddb )
-
-# Just like athena_add_library, this function takes care of interpreting
-# the includes and libraries coming from external packages correctly for the
-# offline build.
-#
-# Usage: athena_add_tpcnv_library( libraryName source1.cxx source2.cxx...
-#                                  PUBLIC_HEADERS HeaderDir...
-#                                  [INCLUDE_DIRS ROOT...]
-#                                  [LINK_LIBRARIES Library1 Library2...] )
-#
-function( athena_add_tpcnv_library libName )
-
-   # We tweak the INCLUDE_DIRS and LINK_LIBRARIES parameters...
-   cmake_parse_arguments( ARG "" "" "INCLUDE_DIRS;LINK_LIBRARIES" ${ARGN} )
-
-   # Construct the arguments for the atlas_add_library call:
-   set( _args ${ARG_UNPARSED_ARGUMENTS} )
-
-   # Massage the include declarations:
-   if( ARG_INCLUDE_DIRS )
-      # Translate the specified "includes":
-      atlas_get_includes( ARG_INCLUDE_DIRS _includes )
-      # Now add them to the arguments:
-      list( APPEND _args INCLUDE_DIRS )
-      list( APPEND _args ${_includes} )
-   endif()
-
-   # Massage the library declarations:
-   if( ARG_LINK_LIBRARIES )
-      # Translate the specified "libraries":
-      atlas_get_libraries( ARG_LINK_LIBRARIES _libraries )
-      # Now add them to the arguments:
-      list( APPEND _args LINK_LIBRARIES )
-      list( APPEND _args ${_libraries} )
-   endif()
-
-   # Now call the underlying function:
-   atlas_add_tpcnv_library( ${libName} ${_args} )
-
-endfunction( athena_add_tpcnv_library )
-
-# Just like athena_add_library, this function takes care of interpreting
-# the includes and libraries coming from external packages correctly for the
-# offline build.
-#
-# Usage: athena_add_poolcnv_library( libraryName source1.cxx source2.cxx...
-#                                    FILES EventInfo/EventInfo.h...
-#                                    [INCLUDE_DIRS ROOT...]
-#                                    [LINK_LIBRARIES Library1 Library2...] )
-#
-function( athena_add_poolcnv_library libName )
-
-   # We tweak the INCLUDE_DIRS and LINK_LIBRARIES parameters...
-   cmake_parse_arguments( ARG "" "" "INCLUDE_DIRS;LINK_LIBRARIES" ${ARGN} )
-
-   # Construct the arguments for the atlas_add_library call:
-   set( _args ${ARG_UNPARSED_ARGUMENTS} )
-
-   # Massage the include declarations:
-   if( ARG_INCLUDE_DIRS )
-      # Translate the specified "includes":
-      atlas_get_includes( ARG_INCLUDE_DIRS _includes )
-      # Now add them to the arguments:
-      list( APPEND _args INCLUDE_DIRS )
-      list( APPEND _args ${_includes} )
-   endif()
-
-   # Massage the library declarations:
-   if( ARG_LINK_LIBRARIES )
-      # Translate the specified "libraries":
-      atlas_get_libraries( ARG_LINK_LIBRARIES _libraries )
-      # Now add them to the arguments:
-      list( APPEND _args LINK_LIBRARIES )
-      list( APPEND _args ${_libraries} )
-   endif()
-
-   # Now call the underlying function:
-   atlas_add_poolcnv_library( ${libName}PoolCnv ${_args} )
-
-endfunction( athena_add_poolcnv_library )
-
-# This function adapts the slightly weird function calls of the offline
-# release to the atlas_add_dictionary function. Eventually the offline code
-# should migrate to use atlas_add_library directly.
-#
-# Usage: athena_add_dictionary( LibName Lib/LibDict.h Lib/selection.xml
-#                               [INCLUDE_DIRS ROOT...]
-#                               [LINK_LIBRARIES Library1 Library2...]
-#                               [EXTRA_FILES Root/dict/*.cxx] )
-#
-function( athena_add_dictionary libName )
-
-   # A convenience variable:
-   set( _argDefs INCLUDE_DIRS LINK_LIBRARIES )
-
-   # We tweak the INCLUDE_DIRS and LINK_LIBRARIES parameters...
-   cmake_parse_arguments( ARG "" "" "${_argDefs}" ${ARGN} )
-
-   # Construct the arguments for the atlas_add_dictionary call:
-   set( _args ${ARG_UNPARSED_ARGUMENTS} )
-
-   # Massage the include declarations:
-   if( ARG_INCLUDE_DIRS )
-      # Translate the specified "includes":
-      atlas_get_includes( ARG_INCLUDE_DIRS _includes )
-      # Now add them to the arguments:
-      list( APPEND _args INCLUDE_DIRS )
-      list( APPEND _args ${_includes} )
-   endif()
-
-   # Massage the library declarations:
-   if( ARG_LINK_LIBRARIES )
-      # Translate the specified "libraries":
-      atlas_get_libraries( ARG_LINK_LIBRARIES _libraries )
-      # Now add them to the arguments:
-      list( APPEND _args LINK_LIBRARIES )
-      list( APPEND _args ${_libraries} )
-   endif()
-
-   # Now call the underlying function. Note the addition of the "Dict" postfix.
-   # Which is just a different naming convention than what atlas_add_dictionary
-   # uses...
-   atlas_add_dictionary( ${libName}Dict ${_args} )
-
-endfunction( athena_add_dictionary )
-
-# Function adapting the "proper" function to work in the current
-# Athena environment.
-#
-# The Athena code just uses a naming convention that we need to adapt to...
-#
-# Usage: athena_add_root_dictionary( mainLibName dictFileNameVar
-#                                    [ROOT_HEADERS Header1.h LinkDef.h]
-#                                    [EXTERNAL_PACKAGES ROOT]
-#                                    [INCLUDE_PATHS /some/path...] )
-#
-function( athena_add_root_dictionary name )
-
-   # Remove a possible "Dict" postfix from the name to get the name of the
-   # main library that this file is being made for:
-   string( REPLACE "Dict" "" _libName ${name} )
-
-   # Call the "normal" function:
-   atlas_add_root_dictionary( ${_libName} _cxxFileName ${ARGN} )
-
-   # Set up a rule that makes a copy of this file with the name that the
-   # Athena code expects at the moment:
-   add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/dict/${name}.cxx
-      COMMAND ${CMAKE_COMMAND} -E make_directory
-      ${CMAKE_CURRENT_BINARY_DIR}/dict
-      COMMAND ${CMAKE_COMMAND} -E copy ${_cxxFileName}
-      ${CMAKE_CURRENT_BINARY_DIR}/dict/${name}.cxx
-      DEPENDS ${_cxxFileName} )
-
-   # Create a dummy target that the current CMake code depends on:
-   add_custom_target( ${name} )
-
-endfunction( athena_add_root_dictionary )
-
-# This function adapts the atlas_add_executable function to work in the
-# offline environment. It massages the LINK_LIBRARIES argument so that it
-# would swallow external package names, and then calls atlas_add_executable
-# with the right options.
-#
-# Usage: athena_add_executable( ExecutableName util/source1.cxx...
-#                               [LINK_LIBRARIES Pkg1...] )
-#
-function( athena_add_executable exeName )
-
-   # Parse the options given to the function:
-   cmake_parse_arguments( ARG "" "" "INCLUDE_DIRS;LINK_LIBRARIES" ${ARGN} )
-
-   # Construct the arguments for the atlas_add_executable call:
-   set( _args ${ARG_UNPARSED_ARGUMENTS} )
-
-   # Massage the include declarations:
-   if( ARG_INCLUDE_DIRS )
-      # Translate the specified "includes":
-      atlas_get_includes( ARG_INCLUDE_DIRS _includes )
-      # Now add them to the arguments:
-      list( APPEND _args INCLUDE_DIRS )
-      list( APPEND _args ${_includes} )
-   endif()
-
-   # Massage the library declarations:
-   if( ARG_LINK_LIBRARIES )
-      # Translate the specified "libraries":
-      atlas_get_libraries( ARG_LINK_LIBRARIES _libraries )
-      # Now add them to the arguments:
-      list( APPEND _args LINK_LIBRARIES )
-      list( APPEND _args ${_libraries} )
-   endif()
-
-   # Call the underlying function with the right options:
-   atlas_add_executable( ${exeName} ${_args} SOURCES ${ARG_UNPARSED_ARGUMENTS} )
-
-endfunction( athena_add_executable )
-
-# Translate the settings made here for the atlas_add_env_setting function.
-# This is not a too much used function in the offline build, so not much
-# clue on how it should really work...
-#
-function( athena_env )
-
-endfunction( athena_env )
-
-# This is a no-op function for us, as the normal atlas_install_headers function
-# picks up the files that apparently athena_install_headers doesn't.
-#
-function( athena_install_nonstandard_headers )
-
-endfunction( athena_install_nonstandard_headers )
-
-# This function just takes care of compiling the L1Common package in the
-# DetCommon project. So eventually all this code should just be put into
-# that particular package, and not live with all the generic release building
-# code...
-#
-function( athena_add_l1common_files l1name )
-
-   # This rule is ignored in release mode:
-   if( ATLAS_RELEASE_MODE )
-      return()
-   endif()
-
-   find_package( PythonInterp )
-
-   atlas_get_package_name( package )
-   set( generator XMLtoHeader.py )
-
-   CMAKE_PARSE_ARGUMENTS( ARG "" "SCHEMA" "" ${ARGN} )
-
-   find_file( genfile ${generator}
-      PATHS ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} )
-
-   if( NOT genfile )
-      if( EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/scripts/${generator} )
-         file( INSTALL ${CMAKE_CURRENT_SOURCE_DIR}/scripts/${generator}
-            DESTINATION ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}
-            PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
-            GROUP_EXECUTE GROUP_READ
-            WORLD_EXECUTE WORLD_READ )
-         install( FILES ${CMAKE_CURRENT_SOURCE_DIR}/scripts/${generator}
-            DESTINATION ${CMAKE_INSTALL_BINDIR}
-            PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
-            GROUP_EXECUTE GROUP_READ
-            WORLD_EXECUTE WORLD_READ)
-      endif()
-   endif()
-
-   set_directory_properties( PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES
-      ${CMAKE_CURRENT_SOURCE_DIR}/scripts/${generator} )
-
-   find_file( genfile ${generator}
-      PATHS ${CMAKE_RUNTIME_OUTPUT_DIRECTORY} )
-
-   if( genfile )
-      set( out_dir ${CMAKE_INCLUDE_OUTPUT_DIRECTORY}/${package} )
-      set( l1out ${out_dir}/${l1name} )
-
-      add_custom_command( OUTPUT ${l1out}
-         COMMAND ${CMAKE_COMMAND} -E make_directory ${out_dir}
-         COMMAND ${PYTHON_EXECUTABLE} ${genfile} -o ${l1out}
-         -i ${CMAKE_CURRENT_SOURCE_DIR}/${ARG_SCHEMA} )
-
-      add_custom_target( ${l1name} ALL DEPENDS ${l1out} )
-      install( DIRECTORY ${out_dir} DESTINATION include
-         FILES_MATCHING PATTERN "*.h" )
-      install( DIRECTORY ${out_dir} DESTINATION ${CMAKE_INSTALL_PYTHONDIR} 
-         FILES_MATCHING PATTERN "*.py" )
-   endif()
-endfunction()