.gitignore

+# Ignore the most common extra files that can
+# be produced while developing
+*~
+*.sw?
+#*
+.DS_Store
+.pydevproject
+.project
+*.pyc
+.asetup*
+.cproject
+*.kdevelop
+#Binary formats
+*.so*
+*.out
+*.exe*
+*.a
+*.la
+*.lib
+*.root
+tmp.*

AsgExternal/Asg_Test/CMakeLists.txt

+# $Id: CMakeLists.txt 782126 2016-11-03 13:55:04Z krasznaa $
+
+# The name of the package:
+atlas_subdir( Asg_Test )
+
+# Read in the settings of the package from the files under cmt/:
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/ReleaseSeries.txt
+   ROOTCORE_RELEASE_SERIES )
+string( STRIP "${ROOTCORE_RELEASE_SERIES}" ROOTCORE_RELEASE_SERIES )
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/TestFileData.txt
+   ASG_TEST_FILE_DATA )
+string( STRIP "${ASG_TEST_FILE_DATA}" ASG_TEST_FILE_DATA )
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/TestFileMC.txt
+   ASG_TEST_FILE_MC )
+string( STRIP "${ASG_TEST_FILE_MC}" ASG_TEST_FILE_MC )
+file( READ ${CMAKE_CURRENT_SOURCE_DIR}/cmt/TestFileMCAFII.txt
+   ASG_TEST_FILE_MC_AFII )
+string( STRIP "${ASG_TEST_FILE_MC_AFII}" ASG_TEST_FILE_MC_AFII )
+set( ROOTCORE_TEST_FILE ${ASG_TEST_FILE_MC} )
+get_filename_component( ROOTCORE_TEST_DATA ${ROOTCORE_TEST_FILE} PATH )
+
+# Create the CMake file that will be used to generate the environment config:
+configure_file( 
+   ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Asg_TestEnvironmentConfig.cmake.in
+   ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/Asg_TestEnvironmentConfig.cmake
+   @ONLY )
+set( Asg_TestEnvironment_DIR
+   ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}
+   CACHE PATH "Location of Asg_TestEnvironmentConfig.cmake" FORCE )
+
+# Now find it:
+find_package( Asg_TestEnvironment )

AsgExternal/Asg_Test/cmake/Asg_TestEnvironmentConfig.cmake.in

+# $Id: Asg_TestEnvironmentConfig.cmake.in 782126 2016-11-03 13:55:04Z krasznaa $
+#
+# File configuring the ASG environment variables.
+#
+
+# Set the environment variables:
+set( ASG_TESTENVIRONMENT_ENVIRONMENT
+   FORCESET ROOTCORE_RELEASE_SERIES @ROOTCORE_RELEASE_SERIES@
+   FORCESET ASG_TEST_FILE_DATA    @ASG_TEST_FILE_DATA@
+   FORCESET ASG_TEST_FILE_MC      @ASG_TEST_FILE_MC@
+   FORCESET ASG_TEST_FILE_MC_AFII @ASG_TEST_FILE_MC_AFII@
+   FORCESET ROOTCORE_TEST_FILE @ROOTCORE_TEST_FILE@
+   FORCESET ROOTCORE_TEST_DATA @ROOTCORE_TEST_DATA@ )
+
+# Signal that the module was found:
+set( ASG_TESTENVIRONMENT_FOUND TRUE )

AsgExternal/Asg_Test/cmt/ReleaseSeries.txt

+25

AsgExternal/Asg_Test/cmt/TestFileData.txt

+/afs/cern.ch/atlas/project/PAT/xAODs/r9264/data16_13TeV.00311321.physics_Main.recon.AOD.r9264/AOD.11038520._000001.pool.root.1

AsgExternal/Asg_Test/cmt/TestFileMC.txt

+/afs/cern.ch/atlas/project/PAT/xAODs/r9315/mc16_13TeV.410501.PowhegPythia8EvtGen_A14_ttbar_hdamp258p75_nonallhad.merge.AOD.e5458_s3126_r9364_r9315/AOD.11182705._000001.pool.root.1

AsgExternal/Asg_Test/cmt/TestFileMCAFII.txt

+/afs/cern.ch/user/a/asgbase/patspace/xAODs/a818/mc15_13TeV.410000.PowhegPythiaEvtGen_P2012_ttbar_hdamp172p5_nonallhad.merge.AOD.e3698_a766_a818_r7676/AOD.07919492._000100.pool.root.1

AsgExternal/Asg_Test/cmt/setup_external.RootCore.csh

+Asg_Test_Dir=`dirname $1`
+setenv ROOTCORE_RELEASE_SERIES `cat $Asg_Test_Dir/ReleaseSeries.txt`
+setenv ASG_TEST_FILE_DATA `cat $Asg_Test_Dir/TestFileData.txt`
+setenv ASG_TEST_FILE_MC `cat $Asg_Test_Dir/TestFileMC.txt`
+setenv ASG_TEST_FILE_MC_AFII `cat $Asg_Test_Dir/TestFileMCAFII.txt`
+setenv ROOTCORE_TEST_FILE `cat $Asg_Test_Dir/TestFileMC.txt`
+setenv ROOTCORE_TEST_DATA "`dirname $ROOTCORE_TEST_FILE | xargs dirname`"

AsgExternal/Asg_Test/cmt/setup_external.RootCore.sh

+Asg_Test_Dir=`dirname $1`
+export ROOTCORE_RELEASE_SERIES=`cat $Asg_Test_Dir/ReleaseSeries.txt`
+export ASG_TEST_FILE_DATA=`cat $Asg_Test_Dir/TestFileData.txt`
+export ASG_TEST_FILE_MC=`cat $Asg_Test_Dir/TestFileMC.txt`
+export ASG_TEST_FILE_MC_AFII=`cat $Asg_Test_Dir/TestFileMCAFII.txt`
+export ROOTCORE_TEST_FILE=`cat $Asg_Test_Dir/TestFileMC.txt`
+export ROOTCORE_TEST_DATA="`dirname $ROOTCORE_TEST_FILE | xargs dirname`"

AtlasCommonPolicy/cmt/fragments/application

-#-- start of application
-
-$(bin)${CONSTITUENT}${application_suffix} :: ${OBJS} $(use_stamps) $(${CONSTITUENT}_stamps) $(${CONSTITUENT}stamps) $(use_requirements)
-	$(link_echo) "application $@"
-	$(link_silent) ${LINKMACRO} -o $(@).new ${OBJS} $(cmt_installarea_linkopts) $(${CONSTITUENT}_use_linkopts) $(${CONSTITUENT}linkopts) && mv -f $(@).new $(@)
-ifneq (${SEPARATEDEBUG},)
-	$(echo) stripping dbg symbols into separate file $@$(debuginfosuffix)
-	$(link_silent) objcopy --only-keep-debug $@ $@$(debuginfosuffix)
-	$(link_silent) objcopy --strip-debug $@
-	$(link_silent) cd $(@D) && objcopy --add-gnu-debuglink=$(@F)$(debuginfosuffix) $(@F)
-endif
-
-ifneq ($(strip $(use_stamps)),)
-# Work around Make errors if stamps files do not exist
-$(use_stamps) :
-endif
-
-#-----------------------------------------------------------------
-#
-#  New section for automatic installation
-#
-#-----------------------------------------------------------------
-
-install_dir = ${CMTINSTALLAREA}/$(tag)/bin
-${CONSTITUENT}installname = ${CONSTITUENT}${application_suffix}
-
-${CONSTITUENT} :: ${CONSTITUENT}install ;
-
-install :: ${CONSTITUENT}install ;
-
-${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
-ifdef CMTINSTALLAREA
-	$(echo) "installation done"
-endif
-
-$(install_dir)/$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
-ifdef CMTINSTALLAREA
-	$(install_silent) $(cmt_install_action) \
-	    -source "`(cd $(bin); pwd)`" \
-	    -name "$(${CONSTITUENT}installname)" \
-	    -out "$(install_dir)" \
-	    -cmd "$(cmt_installarea_command)" \
-	    -cmtpath "$($(package)_cmtpath)"
-endif
-
-##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
-
-uninstall :: ${CONSTITUENT}uninstall ;
-
-${CONSTITUENT}uninstall ::
-ifdef CMTINSTALLAREA
-	$(cleanup_silent) $(cmt_uninstall_action) \
-	    -source "`(cd $(bin); pwd)`" \
-	    -name "$(${CONSTITUENT}installname)" \
-	    -out "$(install_dir)" \
-	    -cmtpath "$($(package)_cmtpath)"
-endif
-
-#	@echo "------> (${CONSTITUENT}.make) Removing installed files"
-#-- end of application

AtlasCommonPolicy/cmt/fragments/library

-#-- start of library_no_static ------
-
-#${CONSTITUENT}LIB :: $(${CONSTITUENT}lib) $(${CONSTITUENT}shstamp)
-${CONSTITUENT}LIB :: $(${CONSTITUENT}shstamp)
-	$(echo) "${CONSTITUENT} : library ok"
-
-$(${CONSTITUENT}lib) :: ${OBJS}
-	$(lib_echo) "static library $@"
-	$(lib_silent) cd $(bin); \
-	  $(ar) $(${CONSTITUENT}lib) $?
-	$(lib_silent) $(ranlib) $(${CONSTITUENT}lib)
-	$(lib_silent) cat /dev/null >$(${CONSTITUENT}stamp)
-
-#------------------------------------------------------------------
-#  Future improvement? to empty the object files after
-#  storing in the library
-#
-##	  for f in $?; do \
-##	    rm $${f}; touch $${f}; \
-##	  done
-#------------------------------------------------------------------
-
-#
-# We add one level of dependency upon the true shared library 
-# (rather than simply upon the stamp file)
-# this is for cases where the shared library has not been built
-# while the stamp was created (error??) 
-#
-
-$(${CONSTITUENT}libname).$(shlibsuffix) :: ${OBJS} $(use_requirements) $(${CONSTITUENT}stamps)
-	$(lib_echo) "shared library $@"
-	$(lib_silent) $(shlibbuilder) $(shlibflags) -o $@ ${OBJS} $(${CONSTITUENT}_shlibflags)
-	$(lib_silent) cat /dev/null >$(${CONSTITUENT}stamp) && \
-	  cat /dev/null >$(${CONSTITUENT}shstamp)
-
-$(${CONSTITUENT}shstamp) :: $(${CONSTITUENT}libname).$(shlibsuffix)
-	$(lib_silent) if test -f $(${CONSTITUENT}libname).$(shlibsuffix) ; then \
-	  cat /dev/null >$(${CONSTITUENT}stamp) && \
-	  cat /dev/null >$(${CONSTITUENT}shstamp) ; fi
-
-${CONSTITUENT}clean ::
-	$(cleanup_echo) objects ${CONSTITUENT}
-	$(cleanup_silent) /bin/rm -f ${OBJS}
-	$(cleanup_silent) /bin/rm -f $(patsubst %.o,%.d,${OBJS}) $(patsubst %.o,%.dep,${OBJS}) $(patsubst %.o,%.d.stamp,${OBJS})
-	$(cleanup_silent) cd $(bin); /bin/rm -rf ${CONSTITUENT}_deps ${CONSTITUENT}_dependencies.make
-
-#-----------------------------------------------------------------
-#
-#  New section for automatic installation
-#
-#-----------------------------------------------------------------
-
-install_dir = ${CMTINSTALLAREA}/$(tag)/lib
-${CONSTITUENT}installname = $(library_prefix)${CONSTITUENT}$(library_suffix).$(shlibsuffix)
-
-${CONSTITUENT} :: ${CONSTITUENT}install ;
-
-install :: ${CONSTITUENT}install ;
-
-${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
-ifdef CMTINSTALLAREA
-	$(echo) "installation done"
-endif
-
-$(install_dir)/$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
-ifdef CMTINSTALLAREA
-	$(install_silent) $(cmt_install_action) \
-	    -source "`(cd $(bin); pwd)`" \
-	    -name "$(${CONSTITUENT}installname)" \
-	    -out "$(install_dir)" \
-	    -cmd "$(cmt_installarea_command)" \
-	    -cmtpath "$($(package)_cmtpath)"
-endif
-
-##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
-
-uninstall :: ${CONSTITUENT}uninstall ;
-
-${CONSTITUENT}uninstall ::
-ifdef CMTINSTALLAREA
-	$(cleanup_silent) $(cmt_uninstall_action) \
-	    -source "`(cd $(bin); pwd)`" \
-	    -name "$(${CONSTITUENT}installname)" \
-	    -out "$(install_dir)" \
-	    -cmtpath "$($(package)_cmtpath)"
-endif
-
-#-- end of library_no_static ------

AtlasCommonPolicy/cmt/fragments/library_no_share

-
-${CONSTITUENT}LIB :: $(${CONSTITUENT}lib)
-	@/bin/echo ${CONSTITUENT} : library ok
-
-$(${CONSTITUENT}lib) :: ${OBJS}
-	$(lib_echo) library
-	$(lib_silent) cd $(bin); \
-	  $(ar) $(${CONSTITUENT}lib) $?
-	$(lib_silent) $(ranlib) $(${CONSTITUENT}lib)
-	$(lib_silent) cat /dev/null >$(${CONSTITUENT}stamp)
-
-#------------------------------------------------------------------
-#  Future improvement? to empty the object files after
-#  storing in the library
-#
-##	  for f in $?; do \
-##	    rm $${f}; touch $${f}; \
-##	  done
-#------------------------------------------------------------------
-
-#-----------------------------------------------------------------
-#
-#  New section for automatic installation
-#
-#-----------------------------------------------------------------
-
-ifeq ($(INSTALLAREA),)
-installarea = $(CMTINSTALLAREA)
-else
-ifeq ($(findstring `,$(INSTALLAREA)),`)
-installarea = $(shell $(subst `,, $(INSTALLAREA)))
-else
-installarea = $(INSTALLAREA)
-endif
-endif
-
-install_dir = ${installarea}/${CMTCONFIG}/lib
-${CONSTITUENT}installname = $(library_prefix)${CONSTITUENT}$(library_suffix).a
-
-${CONSTITUENT} :: ${CONSTITUENT}install
-
-install :: ${CONSTITUENT}install
-
-${CONSTITUENT}install :: $(install_dir)/$($(CONSTITUENT)installname)
-	@if test ! "${installarea}" = ""; then\
-	  echo "installation done"; \
-	fi
-
-$(install_dir)/$($(CONSTITUENT)installname) :: $(bin)$(${CONSTITUENT}installname)
-	@if test ! "${installarea}" = ""; then \
-	  cd $(bin); \
-	  if test ! "$(install_dir)" = ""; then \
-	    if test ! -d "$(install_dir)"; then \
-	      mkdir -p $(install_dir); \
-	    fi ; \
-	    if test -d "$(install_dir)"; then \
-	      echo "Installing library $(${CONSTITUENT}installname) into $(install_dir)"; \
-	      if test -e $(install_dir)/$($(CONSTITUENT)installname); then \
-	        $(cmt_uninstall_area_command) $(install_dir)/$($(CONSTITUENT)installname); \
-	        $(cmt_uninstall_area_command) $(install_dir)/$($(CONSTITUENT)installname).cmtref; \
-	      fi; \
-	      $(cmt_install_area_command) `pwd`/$(${CONSTITUENT}installname) $(install_dir)/$($(CONSTITUENT)installname); \
-	      echo `pwd`/$(${CONSTITUENT}installname) >$(install_dir)/$($(CONSTITUENT)installname).cmtref; \
-	    fi \
-          else \
-	    echo "Cannot install library $(${CONSTITUENT}installname), no installation directory specified"; \
-	  fi; \
-	fi
-
-${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
-
-uninstall :: ${CONSTITUENT}uninstall
-
-${CONSTITUENT}uninstall ::
-	@if test ! "${installarea}" = ""; then \
-	  cd $(bin); \
-	  if test ! "$(install_dir)" = ""; then \
-	    if test -d "$(install_dir)"; then \
-	      echo "Removing installed library $(${CONSTITUENT}installname) from $(install_dir)"; \
-	      $(cmt_uninstall_area_command) $(install_dir)/$($(CONSTITUENT)installname); \
-	      $(cmt_uninstall_area_command) $(install_dir)/$($(CONSTITUENT)installname).cmtref; \
-	    fi \
-          else \
-	    echo "Cannot uninstall library $(${CONSTITUENT}installname), no installation directory specified"; \
-	  fi; \
-	fi
-
-${CONSTITUENT}clean ::
-	$(cleanup_echo) ${OBJS}
-	$(cleanup_silent) cd $(bin); /bin/rm -f ${OBJS}
-

AtlasCommonPolicy/cmt/fragments/optdebug_library

-#-- start of optdebug_library ------
-#-- end of optdebug_library ------

AtlasCommonPolicy/cmt/fragments/optdebug_library_header

-#-- start of optdebug_library_header ------
-# create  a  two  part  executable.   One  a
-# stripped  binary  which will occupy less space in RAM and in a dis-
-# tribution and the second a debugging information file which is only
-# needed  if  debugging abilities are required
-# See GNU binutils OBJCOPY(1)
-# http://sourceware.org/binutils/docs-2.17/binutils/objcopy.html#objcopy
-
-depend=$(bin)$(library_prefix)$(library).$(shlibsuffix)
-target=$(depend)$(debuginfosuffix)
-
-${CONSTITUENT} :: $(target) ;
-
-$(target) : $(depend)
-	$(echo) stripping dbg symbols into separate file $@
-	$(link_silent) objcopy --only-keep-debug $< $@
-	$(link_silent) objcopy --strip-debug $<
-	$(link_silent) cd $(@D) && objcopy --add-gnu-debuglink=$(@F) $(<F)
-	$(link_silent) touch -c $@
-
-${CONSTITUENT}clean ::
-	$(cleanup_silent) /bin/rm -f $(target)
-
-#-----------------------------------------------------------------
-#
-#  New section for automatic installation
-#
-#-----------------------------------------------------------------
-
-install_dir = ${CMTINSTALLAREA}/$(tag)/lib
-${CONSTITUENT}installname = $(library_prefix)$(library)$(library_suffix).$(shlibsuffix)$(debuginfosuffix)
-
-${CONSTITUENT} :: ${CONSTITUENT}install ;
-
-install :: ${CONSTITUENT}install ;
-
-${CONSTITUENT}install :: $(install_dir)/$(${CONSTITUENT}installname)
-ifdef CMTINSTALLAREA
-	$(echo) "$(${CONSTITUENT}installname) installation done"
-endif
-
-$(install_dir)/$(${CONSTITUENT}installname) :: $(bin)$(${CONSTITUENT}installname)
-ifdef CMTINSTALLAREA
-	$(install_silent) $(cmt_install_action) \
-	    -source "`(cd $(bin); pwd)`" \
-	    -name "$(${CONSTITUENT}installname)" \
-	    -out "$(install_dir)" \
-	    -cmd "$(cmt_installarea_command)" \
-	    -cmtpath "$($(package)_cmtpath)"
-endif
-
-##${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
-
-uninstall :: ${CONSTITUENT}uninstall ;
-
-${CONSTITUENT}uninstall ::
-ifdef CMTINSTALLAREA
-	$(cleanup_silent) $(cmt_uninstall_action) \
-	    -source "`(cd $(bin); pwd)`" \
-	    -name "$(${CONSTITUENT}installname)" \
-	    -out "$(install_dir)" \
-	    -cmtpath "$($(package)_cmtpath)"
-endif
-
-#-- start of optdebug_library_header ------

AtlasCommonPolicy/cmt/fragments/setup_runtime_cache_header

-#
-#  We want to install all header files that follow the standard convention
-#
-#    ../<package>
-#
-#  into
-#
-#    ${CMTINSTALLAREA}/include/<package>/<package>
-#
-#  (with two levels of <package> directory)
-#
-
-install_cache_dir = ../${CMTCONFIG}/runtime
-
-${CONSTITUENT} :: ${CONSTITUENT}install
-
-install :: ${CONSTITUENT}install
-
-${CONSTITUENT}install :: $(install_cache_dir)
-
-$(install_cache_dir) ::
-	@if test "$(install_cache_dir)" = ""; then \
-	  echo "Cannot install header files, no installation directory specified"; \
-	else \
-	  $(ATLASCOMMONPOLICYROOT)/scripts/setup_runtime_cache.sh; \
-	fi
-
-clean :: ${CONSTITUENT}clean
-
-${CONSTITUENT}clean :: ${CONSTITUENT}uninstall
-
-uninstall :: ${CONSTITUENT}uninstall
-
-${CONSTITUENT}uninstall ::
-	@if test "$(install_cache_dir)" = ""; then \
-	  echo "Cannot uninstall header files, no installation directory specified"; \
-	else \
-	  if test -d $(install_cache_dir) ; then \
-	    echo "Uninstalling files from $(install_cache_dir)"; \
-	    eval rm -rf $(install_cache_dir) ; \
-	  fi \
-	fi
-
-

AtlasCommonPolicy/cmt/post_install.sh

-#!/bin/sh
-#+
-#	Script to execute post-installation commands
-#
-#	Author:-
-#	David Quarrie
-#-
-
-if [ ! -z "$1" ]; then
-	if [ -f $1 ]; then
-		sh $1
-	fi
-fi

AtlasCommonPolicy/cmt/requirements

-package AtlasCommonPolicy
-
-author David Quarrie
-
-use LCG_Platforms *
-
-use AtlasDoxygen AtlasDoxygen-* Tools
-
-# This package is designed to be the base for policies and patterns that are
-# common between the ATLAS offline and online environments
-
-# Define action that implements a post-install action
-action post_install "$(ATLASCOMMONPOLICYROOT)/cmt/post_install.sh $(post_install_script)"
-
-action post_merge_rootmap "true"
-# "$(ATLASCOMMONPOLICYROOT)/scripts/abuild-merge-rootmap.py"
-
-action post_merge_genconfdb \
- "$(ATLASCOMMONPOLICYROOT)/scripts/abuild-merge-genconfdb.py"
-
-#action post_build_tpcnvdb \
-# "$(ATLASCOMMONPOLICYROOT)/scripts/abuild-gen-tpcnvdb.py $(CMTINSTALLAREA)"
-action post_build_tpcnvdb \
- "true"
-
-action all_post_constituents echo "running postaction"
-
-#document installer install_merge_rootmap install_dir=$(CMTINSTALLAREA)/share/bin "../scripts/abuild-merge-rootmap.py"
-
-document installer install_merge_genconfdb install_dir=$(CMTINSTALLAREA)/share/bin "../scripts/abuild-merge-genconfdb.py"
-
-#document installer install_build_tpcnvdb install_dir=$(CMTINSTALLAREA)/share/bin "../scripts/abuild-gen-tpcnvdb.py"
-
-# DRQ: This pattern and fragment create the runtime setup cache during "make". 
-# They are retained for backwards compatibility but should be deleted at some point 
-make_fragment setup_runtime_cache -header=setup_runtime_cache_header
-pattern do_setup_runtime_cache \
-    document setup_runtime_cache do_setup_runtime_cache
-
-# library_no_static fragment from core CMT (renamed as library)
-# to allow for shared library only to be built by default
-# (instead of shared + static libraries)
-# to disable this fragment/behaviour, activate tag WithStatic
-tag static WithStatic
-tag UnixStatic WithStatic
-macro library_fragment "library" WithStatic ""
-make_fragment $(library_fragment)
-make_fragment application
-
-tag_exclude no-separate-debug separate-debug
-
-apply_tag separate-debug
-macro SEPARATEDEBUG "" separate-debug&target-opt&target-linux "1"
-macro_append cppflags  ""  separate-debug&target-opt&target-linux  " -g "
-macro_append cflags    ""  separate-debug&target-opt&target-linux  " -g "
-macro_append fflags    ""  separate-debug&target-opt&target-linux  " -g "
-macro debuginfosuffix  ".debug"
-
-make_fragment optdebug_library -header=optdebug_library_header
-
-pattern cmake_add_command \
-   private ; \
-   macro dummy_for_cmake "<command>" ; \
-   end_private
-
-pattern cmake_add_definitions \
-   private ; \
-   macro dummy_for_cmake "<defines>" ; \
-   end_private
-	
-pattern cmake_add_dependency \
-   private ; \
-   macro dummy_for_cmake "<package>" "<packages>"; \
-   end_private
-	
-pattern cmake_add_generated_files \
-   private ; \
-   macro dummy_for_cmake "<library>" "<files>" ; \
-   end_private
-	
-pattern cmake_add_libraries \
-   private ; \
-   macro dummy_for_cmake "<target>" "<libraries>" ; \
-   end_private
-	
-pattern cmake_conditional_target \
-   private ; \
-   macro dummy_for_cmake "<target>" "<type>" ; \
-   end_private
-	
-pattern cmake_ignore_import \
-   private ; \
-   macro dummy_for_cmake "<library>" "<import>" ; \
-   end_private
-	
-pattern cmake_set_macro \
-   private ; \
-   macro dummy_for_cmake "<macro>" "<value>" ; \
-   end_private
-	
-pattern cmake_override_library_type \
-   private ; \
-   macro dummy_for_cmake "<library>" "<type>" ; \
-   end_private
-	
-pattern optdebug_library \
-   private ; \
-   macro apply_optdebug_library "without_optdebug_library" separate-debug&target-opt&target-linux "with_optdebug_library" ; \
-   apply_pattern $(apply_optdebug_library) name=<name>  ; \
-   end_private
-
-pattern with_optdebug_library \
-   private ; \
-   document optdebug_library <name>_optdebug_library library=<name>  ; \
-   macro_append <name>_optdebug_library_dependencies " <name>" ; \
-   macro_append <name>_library_dependencies " <name>_optdebug_library " ; \ 
-   action <name>_NICOS_Fix_debuginfo ' if test ! -z "$(NICOS_PROJECT_HOME)" -a ! -z "$(NICOS_PROJECT_RELNAME)" -a \ 
-                                               ! -z "$(NICOS_COPY_HOME)"    -a ! -z "$(NICOS_PROJECT_RELNAME_COPY)" -a \ 
- 					         -x /usr/lib/rpm/debugedit ; then \ 
-                              echo fixing debug info in NICOS ; \
-			      if env test -l "$(NICOS_PROJECT_RELNAME_COPY)" -gt -l "$(NICOS_PROJECT_RELNAME)" ; then \
-			           echo Warning: new path ${NICOS_PROJECT_RELNAME_COPY} is longer than old path ${NICOS_PROJECT_RELNAME} - fixing will not work ;\
-			      else \
-			           readelf -wl $(bin)$(library_prefix)<name>.$(shlibsuffix) | grep '\/\/' && echo WARNING above lines might cause problems with debugedit - notice the double slash; \
- 	                           /usr/lib/rpm/debugedit -b $(NICOS_COPY_HOME)/$(NICOS_PROJECT_RELNAME) -d \ 
- 	                                                $(NICOS_COPY_HOME)/$(NICOS_PROJECT_RELNAME_COPY) \ 
- 	                                             $(bin)$(library_prefix)<name>.$(shlibsuffix); fi; \
-			      fi; ' ; \
-   macro_append <name>_NICOS_Fix_debuginfo_dependencies "" \
-         NICOSrel_nightly " <name> " ; \ 
-   macro_append <name>_optdebug_library_dependencies "" \
-         NICOSrel_nightly " <name>_NICOS_Fix_debuginfo " ; \ 
-   end_private
-
-pattern without_optdebug_library \
-   private ; \
-   macro dummy_for_library "<name>" ; \
-   end_private
-
-action checkreq "true"
-macro_append all_dependencies " checkreq "
-
-# translate source location in debug information to the AFS location where nightly will be installed 
-# protect also against only partial variable definitions 
-
-macro NICOS "NICOS${NICOS_PROJECT_RELNAME}" 
-apply_tag $(NICOS) 
-
-macro NICOS_TMP_A "NICOS$(NICOS_PROJECT_HOME)" 
-macro NICOS_TMP_B "NICOS$(NICOS_COPY_HOME)" 
-macro NICOS_TMP_C "NICOS$(NICOS_PROJECT_RELNAME_COPY)" 
-
-apply_tag $(NICOS_TMP_A) 
-apply_tag $(NICOS_TMP_B) 
-apply_tag $(NICOS_TMP_C) 
-
-tag_exclude NICOS NICOSrel_nightly 
-
-# this is a two stage translation. First we replace the NICOS_PROJECT_HOME to NICOS_COPY_HOME here, keeping the longer "rel_nightly" in place 
-# then in the second stage after building the library, we relace "rel_nightly" with the shorter rel_N, with N a single digit. The debugedit tools 
-# requires that the new path is shorter than the old path. ccache requires that the replaced and original path do not depend on the nightly it runs.  
-macro_append AtlasCommonPolicy_cppflags "" \ 
-      NICOSrel_nightly ' -fdebug-prefix-map=$(NICOS_PROJECT_HOME)=$(NICOS_COPY_HOME) '
-	 
-#--------------------------------------------
-## Filling the JOBOPTSEARCHPATH list with list of currently visible installation areas
-#--------------------------------------------
-
-#path_remove  JOBOPTSEARCHPATH "InstallArea"
-#path_prepend JOBOPTSEARCHPATH `${ATLASPOLICYROOT}/cmt/jo.sh`
-
-cmtpath_pattern \
-  path JOBOPTSEARCHPATH "" ; \
-  path_remove PYTHONPATH "$(cmt_installarea_prefix)" ; \
-  path_remove DATAPATH "$(cmt_installarea_prefix)" ; \
-  path_remove ROOTMAPSEARCHPATH "$(cmt_installarea_prefix)" ; \
-  path_remove XMLPATH "$(cmt_installarea_prefix)"
-
-cmtpath_pattern \
-  path_prepend JOBOPTSEARCHPATH  "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/jobOptions" ; \
-  path_prepend PYTHONPATH        "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/python" ; \
-  path_prepend PYTHONPATH        "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/${CMTCONFIG}/lib/python$(Python_version)" ; \
-  path_prepend DATAPATH          "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/share" ; \
-  path_prepend DATAPATH          "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/${CMTCONFIG}/share" ; \
-  path_prepend ROOTMAPSEARCHPATH "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/rootmap" ; \
-  path_prepend XMLPATH           "" \
-               <project>_with_installarea&Unix "<path>/$(cmt_installarea_prefix)/XML"
-
-cmtpath_pattern \
-  path_prepend JOBOPTSEARCHPATH "."
-
-# temporary fix for https://its.cern.ch/jira/browse/ATEAM-151
-#  import and fix merge_files.py from GaudiPolicy
-macro merge_componentslist_cmd "python $(AtlasCommonPolicy_root)/scripts/merge_files.py"
-macro merge_rootmap_cmd "python $(AtlasCommonPolicy_root)/scripts/merge_files.py"
-macro merge_genconfDb_cmd "python $(AtlasCommonPolicy_root)/scripts/merge_files.py"
-macro merge_componentslist_cmd "python $(AtlasCommonPolicy_root)/scripts/merge_files.py"

AtlasCommonPolicy/scripts/abuild-merge-genconfdb.py

-#!/usr/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-__doc__ = """asimple script to merge all _confDb files into a project-wide _merged_confDb file"""
-
-### imports --------------------------------------------------------------------
-import os
-import sys
-from fnmatch import fnmatch
-import shutil
-import getopt
-import subprocess
-
-_useropts = "o:vh"
-_userlongopts = [
-    "install-area=",
-    "output-file=",
-    "verbose",
-    "help"
-    ]
-_error_msg = """\
-inspect a (set of) InstallArea(s), collect all confDb files and merge them into one single project-wide merged_confDb file.
-
-Accepted command line options:
-     --install-area=<path or env.var> ...  path to the InstallArea to inspect
- -o, --output-file                    ...  name of the merged output file
- -v, --verbose                        ...  enable verbose mode
- -h, --help                           ...  print this help message
-"""
-
-### functions ------------------------------------------------------------------
-
-def collect_genconfdb_fnames(topdir,
-                             pattern='*confDb.py',
-                             exclude_pattern='*_merged_confDb.py'):
-                          
-    """ recursively inspect the `topdir` directory for files named '*confDb.py'
-        but exclude the files named '*_merged_confDb.py'
-        returns a list of unique real paths
-    """
-    print "::: collecting genconfdb files..."
-    all_files = []
-    # we need the 'followlinks' argument
-    if sys.version_info[:2] < (2,6): os_walk = _walk
-    else:                            os_walk = os.walk
-
-    for root, dirs, files in os_walk(topdir, followlinks=True):
-        for f in files:
-            if fnmatch(f, pattern) and not fnmatch(f, exclude_pattern):
-                full_name = os.path.join(root, f)
-                full_name = os.path.realpath(full_name)
-                all_files.append(full_name)
-                print " - [%s]" % (full_name,)
-                
-    all_files = list(set(all_files))
-    print "::: collecting genconfdb files... [done] (nbr=%i)" % (len(all_files),)
-    return all_files
-    
-def merge_files(fnames, ofname):
-    """merge the content of all files `fnames` into the file `ofname`
-    """
-    print "::: merging files into [%s]..." % (ofname,)
-    _copy = shutil.copyfileobj
-    ofile = open(ofname, 'w')
-    for fname in fnames:
-        print "::: processing [%s]..." % (fname,)
-        _copy(fsrc=open(fname, 'r'), fdst=ofile)
-        ofile.flush()
-    ofile.close()
-    
-    print "::: merging files into [%s]... [done]" % (ofname,)
-    return 0
-
-def do_merge_files(topdir, ofname,
-                   pattern='*_confDb.py',
-                   exclude_pattern='*_merged_confDb.py'):
-
-    if isinstance(topdir, basestring):
-        topdir = topdir.split(os.pathsep)
-        
-    confdb_fnames = []
-    for d in topdir:
-        confdb_fnames.extend(collect_genconfdb_fnames(d, pattern,
-                                                      exclude_pattern))
-
-    return merge_files(confdb_fnames, ofname)
-
-def main():
-    """the main entry point of this script
-    """
-
-    class Options(object):
-        """place holder for command line options values"""
-        pass
-    
-    def _help_and_exit():
-        print _error_msg
-        sys.exit(1)
-        
-    def _get_currentpath():
-        current = []
-        for m in ('CMTINSTALLAREA', 'cmt_installarea_prefix'):
-            cmd = 'cmt -disable_warnings show macro_value %s' % m
-            p = subprocess.Popen(cmd, shell = True,
-                                 stdout = subprocess.PIPE,
-                                 stderr = subprocess.STDOUT)
-            out = p.communicate()[0]
-            if p.returncode != 0:
-                raise OSError(out)
-            current.append(out)
-        return current[0].rstrip(current[1]).rstrip(os.sep)
-
-    def _install_area():
-        cmtpath = _get_currentpath()
-        install_area = os.path.join(cmtpath, 'InstallArea')
-        return install_area
-    
-    def _outfname():
-        cmtpath = _get_currentpath()
-        proj_name = os.path.basename(cmtpath)
-        try:
-            proj_name = cmtpath.split(os.sep)[-2]
-        except Exception:
-            pass
-        cmtconf = os.environ['CMTCONFIG']
-        install_area = os.path.join(cmtpath, 'InstallArea')
-        pyvers = 'python%s.%s' % sys.version_info[:2]
-        outdir = os.path.join(install_area, cmtconf, 'lib', pyvers)
-        outfname = os.path.join(outdir, '%s_merged_confDb.py' % proj_name)
-        return outfname
-
-    opts = Options()
-    opts.install_area = _install_area()
-    opts.output_file = _outfname()
-    opts.verbose = False
-
-    # process user options
-    try:
-        optlist, args = getopt.getopt(sys.argv[1:], _useropts, _userlongopts)
-    except getopt.error:
-        print sys.exc_value
-        _help_and_exit()
-        pass
-
-    if args:
-        print "Unhandled arguments:", args
-        _help_and_exit()
-        pass
-
-    for opt, arg in optlist:
-        if opt in ("--install-area",):
-            opts.install_area = arg
-            pass
-        elif opt in ("-o", "--output-file",):
-            opts.output_file = arg
-            pass
-        elif opt in ("-v", "--verbose"):
-            opts.verbose = True
-            pass
-        elif opt in ("-h", "--help"):
-            _help_and_exit()
-            pass
-        else:
-            print "Unknown option:", opt
-            _help_and_exit()
-            pass
-        
-    #print args
-
-    install_area = []
-    _install_area = opts.install_area[:]
-    if isinstance(_install_area, basestring):
-        _install_area =[_install_area]
-    else:
-        _install_area = list(_install_area)
-
-    for i,d in enumerate(_install_area[:]):
-        _install_area[i] = os.path.expanduser(os.path.expandvars(d))
-
-    for d in _install_area:
-        install_area.extend(d.split(os.pathsep))
-        
-    outdir = os.path.dirname(opts.output_file)
-    if not os.path.exists(outdir):
-        if outdir:
-            try:
-                os.makedirs(outdir)
-            except OSError, err:
-                import errno
-                # "handle" race condition
-                if err.errno == errno.EEXIST:
-                    pass
-                else:
-                    raise
-    
-    if os.path.exists(opts.output_file):
-        os.remove(opts.output_file)
-        
-    print ":"*80
-    print "::: abuild-merge-genconfdb"
-    rc = do_merge_files(topdir=install_area,
-                        ofname=opts.output_file)
-    print "::: bye."
-    print ":"*80
-    return rc
-
-# copied verbatim from py-2.6
-def _walk(top, topdown=True, onerror=None, followlinks=False):
-    """Directory tree generator.
- 
-    For each directory in the directory tree rooted at top (including top
-    itself, but excluding '.' and '..'), yields a 3-tuple
- 
-        dirpath, dirnames, filenames
- 
-    dirpath is a string, the path to the directory.  dirnames is a list of
-    the names of the subdirectories in dirpath (excluding '.' and '..').
-    filenames is a list of the names of the non-directory files in dirpath.
-    Note that the names in the lists are just names, with no path components.
-    To get a full path (which begins with top) to a file or directory in
-    dirpath, do os.path.join(dirpath, name).
- 
-    If optional arg 'topdown' is true or not specified, the triple for a
-    directory is generated before the triples for any of its subdirectories
-    (directories are generated top down).  If topdown is false, the triple
-    for a directory is generated after the triples for all of its
-    subdirectories (directories are generated bottom up).
- 
-    When topdown is true, the caller can modify the dirnames list in-place
-    (e.g., via del or slice assignment), and walk will only recurse into the
-    subdirectories whose names remain in dirnames; this can be used to prune
-    the search, or to impose a specific order of visiting.  Modifying
-    dirnames when topdown is false is ineffective, since the directories in
-    dirnames have already been generated by the time dirnames itself is
-    generated.
- 
-    By default errors from the os.listdir() call are ignored.  If
-    optional arg 'onerror' is specified, it should be a function; it
-    will be called with one argument, an os.error instance.  It can
-    report the error to continue with the walk, or raise the exception
-    to abort the walk.  Note that the filename is available as the
-    filename attribute of the exception object.
- 
-    By default, os.walk does not follow symbolic links to subdirectories on
-    systems that support them.  In order to get this functionality, set the
-    optional argument 'followlinks' to true.
- 
-    Caution:  if you pass a relative pathname for top, don't change the
-    current working directory between resumptions of walk.  walk never
-    changes the current directory, and assumes that the client doesn't
-    either.
- 
-    Example:
- 
-    import os
-    from os.path import join, getsize
-    for root, dirs, files in os.walk('python/Lib/email'):
-        print root, "consumes",
-        print sum([getsize(join(root, name)) for name in files]),
-        print "bytes in", len(files), "non-directory files"
-        if 'CVS' in dirs:
-            dirs.remove('CVS')  # don't visit CVS directories
-    """
- 
-    from os.path import join, isdir, islink
- 
-    # We may not have read permission for top, in which case we can't
-    # get a list of the files the directory contains.  os.path.walk
-    # always suppressed the exception then, rather than blow up for a
-    # minor reason when (say) a thousand readable directories are still
-    # left to visit.  That logic is copied here.
-    try:
-        # Note that listdir and error are globals in this module due
-        # to earlier import-*.
-        names = os.listdir(top)
-    except os.error, err:
-        if onerror is not None:
-            onerror(err)
-        return
- 
-    dirs, nondirs = [], []
-    for name in names:
-        if isdir(join(top, name)):
-            dirs.append(name)
-        else:
-            nondirs.append(name)
- 
-    if topdown:
-        yield top, dirs, nondirs
-    for name in dirs:
-        path = join(top, name)
-        if followlinks or not islink(path):
-            for x in _walk(path, topdown, onerror, followlinks):
-                yield x
-    if not topdown:
-        yield top, dirs, nondirs
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())

AtlasCommonPolicy/scripts/abuild-merge-rootmap.py

-#!/usr/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-__doc__ = """a simple script to merge all .dsomap files into a project-wide .rootmap file"""
-
-### imports --------------------------------------------------------------------
-import os
-import sys
-from fnmatch import fnmatch as _fnmatch
-import shutil
-import getopt
-import subprocess
-
-### globals --------------------------------------------------------------------
-_dsomap_exclude_list = [
-    "TestRootConversions1Dict.dsomap",
-    "TestRootConversions2Dict.dsomap",
-    "DataModelTestDataRead.rootmap",
-    "DataModelTestDataWriteCnvPoolCnv.rootmap",
-    "DataModelTestDataReadCnvPoolCnv.rootmap",
-    "DataModelTestDataReadDict.dsomap",
-    "DataModelTestDataWriteDict.dsomap",
-    # from APR
-    "test_PersistencySvc_CustomReferenceAndStreamerDict.dsomap",
-    "test_PersistencySvc_CustomReferenceDict.dsomap",
-    "test_PersistencySvc_CustomStreamersDict.dsomap",
-    "test_PersistencySvc_NoClassIDDict.dsomap",
-    "test_StorageSvc_TransientMembersDict.dsomap",
-    "test_TestDictionaryDict.dsomap",
-    ]
-"""list of dsomap files to ignore from the merge"""
-
-_useropts = "i:o:vh"
-_userlongopts = [
-    "install-area=",
-    "output-file=",
-    "verbose",
-    "help"
-    ]
-_error_msg = """\
-inspect a (set of) InstallArea(s), collect all .dsomap files and merge them into one single project-wide .rootmap file.
-
-Accepted command line options:
- -i, --install-area=<path or env.var> ...  path to the InstallArea to inspect
- -o, --output-file                    ...  name of the merged output file
- -v, --verbose                        ...  enable verbose mode
- -h, --help                           ...  print this help message
-"""
-
-### functions ------------------------------------------------------------------
-
-def fnmatch(path, pattern):
-    """helper function to test multiple patterns
-    """
-    patterns = pattern
-    if isinstance(patterns, basestring):
-        patterns = [patterns]
-    for pattern in patterns:
-        if _fnmatch(path, pattern):
-            return True
-    return False
-
-def _is_in_ignore_list(fname):
-    """ helper method to test if `fname` is in any of the ignore list
-    """
-    bfname = os.path.basename(fname)
-    return bfname in _dsomap_exclude_list
-
-def collect_dsomap_fnames(topdir, pattern=['*.dsomap','*.rootmap']):
-    """ recursively inspect the `topdir` directory for files named '*.dsomap'
-        returns a list of unique real paths
-    """
-    print "::: collecting dsomap files..."
-    all_files = []
-    # we need the 'followlinks' argument
-    if sys.version_info[:2] < (2,6): os_walk = _walk
-    else:                            os_walk = os.walk
-
-    if isinstance(pattern, basestring):
-        pattern = [pattern]
-
-    # opt hack
-    _install_area_cmtcfg = os.path.join('InstallArea', os.environ['CMTCONFIG'])
-    
-    for root, dirs, files in os_walk(topdir, followlinks=True):
-        for f in files:
-            if fnmatch(f, pattern):
-                full_name = os.path.join(root, f)
-                full_name = os.path.realpath(full_name)
-                if (os.environ['CMTCONFIG'] in full_name and
-                    not _is_in_ignore_list(full_name) and
-                    # FIXME: we can't rely on *ALL* files being under the
-                    # install-area b/c of component libs!
-                    #not _install_area_cmtcfg in full_name and
-                    1):
-                    all_files.append(full_name)
-                    print " - [%s]" % (full_name,)
-                
-    all_files = list(set(all_files))
-    print "::: collecting dsomap files... [done] (nbr=%i)" % (len(all_files),)
-    return all_files
-    
-def merge_files(fnames, ofname):
-    """merge the content of all files `fnames` into the file `ofname`
-    """
-    print "::: merging files into [%s]..." % (ofname,)
-    _copy = shutil.copyfileobj
-    ofile = open(ofname, 'w')
-    for fname in fnames:
-        print "::: processing [%s]..." % (fname,)
-        _copy(fsrc=open(fname, 'r'), fdst=ofile)
-        ofile.flush()
-    ofile.close()
-    
-    print "::: merging files into [%s]... [done]" % (ofname,)
-    return 0
-
-def do_merge_files(topdir, ofname, pattern=['*.dsomap','*.rootmap']):
-
-    if isinstance(topdir, basestring):
-        topdir = topdir.split(os.pathsep)
-        
-    dsomap_fnames = []
-    for d in topdir:
-        dsomap_fnames.extend(collect_dsomap_fnames(d, pattern))
-    return merge_files(dsomap_fnames, ofname)
-
-def main():
-    """the main entry point of this script
-    """
-
-    class Options(object):
-        """place holder for command line options values"""
-        pass
-    
-    def _help_and_exit():
-        print _error_msg
-        sys.exit(1)
-
-    def _get_currentpath():
-        current = []
-        for m in ('CMTINSTALLAREA', 'cmt_installarea_prefix'):
-            cmd = 'cmt -disable_warnings show macro_value %s' % m
-            p = subprocess.Popen(cmd, shell = True,
-                                 stdout = subprocess.PIPE,
-                                 stderr = subprocess.STDOUT)
-            out = p.communicate()[0]
-            if p.returncode != 0:
-                raise OSError(out)
-            current.append(out)
-        return current[0].rstrip(current[1]).rstrip(os.sep)
-
-    def _install_area():
-        cmtpath = _get_currentpath()
-        install_area = os.path.join(cmtpath, 'InstallArea')
-        #return install_area
-        # FIXME: we should only return the install-area, but some needed
-        # rootmap files (for component libs) are installed under the pkg
-        # $CMTCONFIG directory and not installed under the install-area
-        return cmtpath
-    
-    def _outfname():
-        cmtpath = _get_currentpath()
-        proj_name = os.path.basename(cmtpath)
-        try:
-            proj_name = cmtpath.split(os.sep)[-2]
-        except Exception:
-            pass
-        cmtconf = os.environ['CMTCONFIG']
-        install_area = os.path.join(cmtpath, 'InstallArea')
-        outdir = os.path.join(install_area, cmtconf, 'lib')
-        outfname = os.path.join(outdir, '%s.rootmap' % proj_name)
-        return outfname
-
-    opts = Options()
-    opts.install_area = _install_area()
-    opts.output_file = _outfname()
-    opts.verbose = False
-
-    # process user options
-    try:
-        optlist, args = getopt.getopt(sys.argv[1:], _useropts, _userlongopts)
-    except getopt.error:
-        print "-->",_useropts
-        print sys.exc_value
-        _help_and_exit()
-        pass
-
-    if args:
-        print "Unhandled arguments:", args
-        _help_and_exit()
-        pass
-
-    for opt, arg in optlist:
-        if opt in ("-i", "--install-area",):
-            opts.install_area = arg
-            pass
-        elif opt in ("-o", "--output-file",):
-            opts.output_file = arg
-            pass
-        elif opt in ("-v", "--verbose"):
-            opts.verbose = True
-            pass
-        elif opt in ("-h", "--help"):
-            _help_and_exit()
-            pass
-        else:
-            print "Unknown option:", opt
-            _help_and_exit()
-            pass
-        
-    #print args
-
-    install_area = []
-    _install_area = opts.install_area[:]
-    if isinstance(_install_area, basestring):
-        _install_area =[_install_area]
-    else:
-        _install_area = list(_install_area)
-
-    for i,d in enumerate(_install_area[:]):
-        _install_area[i] = os.path.expanduser(os.path.expandvars(d))
-
-    for d in _install_area:
-        install_area.extend(d.split(os.pathsep))
-        
-    
-    
-    outdir = os.path.dirname(opts.output_file)
-    if not os.path.exists(outdir):
-        if outdir:
-            try:
-                os.makedirs(outdir)
-            except OSError, err:
-                import errno
-                # "handle" race condition
-                if err.errno == errno.EEXIST:
-                    pass
-                else:
-                    raise
-
-    if os.path.exists(opts.output_file):
-        os.remove(opts.output_file)
-        
-    print ":"*80
-    print "::: abuild-merge-rootmap"
-    rc = do_merge_files(topdir=install_area,
-                        ofname=opts.output_file)
-    print "::: bye."
-    print ":"*80
-    return rc
-
-# copied verbatim from py-2.6
-def _walk(top, topdown=True, onerror=None, followlinks=False):
-    """Directory tree generator.
- 
-    For each directory in the directory tree rooted at top (including top
-    itself, but excluding '.' and '..'), yields a 3-tuple
- 
-        dirpath, dirnames, filenames
- 
-    dirpath is a string, the path to the directory.  dirnames is a list of
-    the names of the subdirectories in dirpath (excluding '.' and '..').
-    filenames is a list of the names of the non-directory files in dirpath.
-    Note that the names in the lists are just names, with no path components.
-    To get a full path (which begins with top) to a file or directory in
-    dirpath, do os.path.join(dirpath, name).
- 
-    If optional arg 'topdown' is true or not specified, the triple for a
-    directory is generated before the triples for any of its subdirectories
-    (directories are generated top down).  If topdown is false, the triple
-    for a directory is generated after the triples for all of its
-    subdirectories (directories are generated bottom up).
- 
-    When topdown is true, the caller can modify the dirnames list in-place
-    (e.g., via del or slice assignment), and walk will only recurse into the
-    subdirectories whose names remain in dirnames; this can be used to prune
-    the search, or to impose a specific order of visiting.  Modifying
-    dirnames when topdown is false is ineffective, since the directories in
-    dirnames have already been generated by the time dirnames itself is
-    generated.
- 
-    By default errors from the os.listdir() call are ignored.  If
-    optional arg 'onerror' is specified, it should be a function; it
-    will be called with one argument, an os.error instance.  It can
-    report the error to continue with the walk, or raise the exception
-    to abort the walk.  Note that the filename is available as the
-    filename attribute of the exception object.
- 
-    By default, os.walk does not follow symbolic links to subdirectories on
-    systems that support them.  In order to get this functionality, set the
-    optional argument 'followlinks' to true.
- 
-    Caution:  if you pass a relative pathname for top, don't change the
-    current working directory between resumptions of walk.  walk never
-    changes the current directory, and assumes that the client doesn't
-    either.
- 
-    Example:
- 
-    import os
-    from os.path import join, getsize
-    for root, dirs, files in os.walk('python/Lib/email'):
-        print root, "consumes",
-        print sum([getsize(join(root, name)) for name in files]),
-        print "bytes in", len(files), "non-directory files"
-        if 'CVS' in dirs:
-            dirs.remove('CVS')  # don't visit CVS directories
-    """
- 
-    from os.path import join, isdir, islink
- 
-    # We may not have read permission for top, in which case we can't
-    # get a list of the files the directory contains.  os.path.walk
-    # always suppressed the exception then, rather than blow up for a
-    # minor reason when (say) a thousand readable directories are still
-    # left to visit.  That logic is copied here.
-    try:
-        # Note that listdir and error are globals in this module due
-        # to earlier import-*.
-        names = os.listdir(top)
-    except os.error, err:
-        if onerror is not None:
-            onerror(err)
-        return
- 
-    dirs, nondirs = [], []
-    for name in names:
-        if isdir(join(top, name)):
-            dirs.append(name)
-        else:
-            nondirs.append(name)
- 
-    if topdown:
-        yield top, dirs, nondirs
-    for name in dirs:
-        path = join(top, name)
-        if followlinks or not islink(path):
-            for x in _walk(path, topdown, onerror, followlinks):
-                yield x
-    if not topdown:
-        yield top, dirs, nondirs
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())

AtlasCommonPolicy/scripts/merge_files.py

-#!/usr/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# @file: GaudiPolicy/cmt/fragments/merge_files.py
-# @purpose: merge_files <fragment> file into a 'per-project' <merged> file
-# @author: Sebastien Binet <binet@cern.ch>
-
-import os
-import sys
-from datetime import datetime
-import fcntl
-
-def mergeFiles( fragFileNames, mergedFileName, commentChar, doMerge, ignoreMissing ):
-
-    startMark = "%s --Beg " % commentChar
-    timeMark  = "%s --Date inserted: %s" % (commentChar, datetime.now())
-    endMark   = "%s --End " % commentChar
-    nameOffset = len(startMark)
-
-    basenames = map(os.path.basename, fragFileNames)
-
-    isNewFile = not os.path.exists(mergedFileName)
-
-    # create an empty file if it does not exist
-    # "append mode" ensures that, in case of two processes trying to
-    # create the file, they do not truncate each other file
-    if isNewFile:
-        # check if the destination directory exists
-        path_to_file = os.path.split(mergedFileName)[0]
-        if path_to_file and not os.path.isdir(path_to_file):
-            # if doesn't exist, create it
-            os.makedirs(path_to_file)
-        open(mergedFileName,'a')
-
-    lockFile = open( mergedFileName + '.lock', 'a' )
-
-    # locking file, gaining exclusive access to it
-    # code from locker.py, only posix relevant part - we don't support NT - did we ever ??
-    # Lock with a simple call to lockf() - this blocks until the lock is aquired
-    try:
-        fcntl.lockf( lockFile, fcntl.LOCK_EX )
-    except IOError, exc_value:
-        print "Problem when trying to lock {0}, IOError {1}".format(mergedFile, exc_value[0])
-        raise
-
-    mergedFile = open( mergedFileName, 'r' )
-
-    try:
-
-        newLines = [ ]
-        skipBlock = ""
-        for line in mergedFile.readlines():
-            if line.startswith(startMark) and line[nameOffset:].strip() in basenames:
-                skipBlock = endMark + line[nameOffset:].strip()
-                # remove all the empty lines occurring before the start mark
-                while (len(newLines) > 0) and (newLines[-1].strip() == ''):
-                    newLines.pop()
-            if not skipBlock:
-                newLines.append(line)
-            if line.startswith(skipBlock):
-                skipBlock = ""
-        if skipBlock:
-            print "WARNING: missing end mark ('%s')" % skipBlock
-
-        if doMerge:
-            for f in fragFileNames:
-                if ignoreMissing and not os.path.exists(f):
-                    print "WARNING: '%s' does not exist, I'm ignoring it" % f
-                    continue
-                # I do not want to add 2 empty lines at the beginning of a file
-                if newLines:
-                    newLines.append('\n\n')
-                bf = os.path.basename(f)
-                newLines.append(startMark + bf + '\n')
-                newLines.append(timeMark + '\n')
-                fileData = open(f, 'r').read()
-                newLines.append(fileData)
-                if fileData and fileData[-1] != '\n':
-                    newLines.append('\n')
-                newLines.append(endMark + bf + '\n')
-
-        #mergedFile.seek(0)
-        #mergedFile.truncate(0)
-        #mergedFile.writelines(newLines)
-
-        newFile = open( mergedFileName + ".new" , 'w' )
-        newFile.writelines(newLines)
-        newFile.close()
-        os.rename(mergedFileName + ".new",mergedFileName)
-        
-    finally:
-        # unlock file
-        fcntl.lockf( lockFile, fcntl.LOCK_UN )
-
-    return 0
-
-if __name__ == "__main__":
-
-    from optparse import OptionParser
-    parser = OptionParser(usage="usage: %prog [options]")
-    parser.add_option(
-        "-i",
-        "--input-file",
-        action = "append",
-        dest = "fragFileNames",
-        default = [],
-        help = "The path and name of the file one wants to merge into the 'master' one"
-        )
-    parser.add_option(
-        "-m",
-        "--merged-file",
-        dest = "mergedFileName",
-        default = None,
-        help = "The path and name of the 'master' file which will hold the content of all the other fragment files"
-        )
-    parser.add_option(
-        "-c",
-        "--comment-char",
-        dest = "commentChar",
-        default = "#",
-        help = "The type of the commenting character for the type of files at hand (this is an attempt at handling the largest possible use cases)"
-        )
-    parser.add_option(
-        "--do-merge",
-        dest = "doMerge",
-        action = "store_true",
-        default = True,
-        help = "Switch to actually carry on with the merging procedure"
-        )
-    parser.add_option(
-        "--un-merge",
-        dest = "unMerge",
-        action = "store_true",
-        default = False,
-        help = "Switch to remove our fragment file from the 'master' file"
-        )
-    parser.add_option(
-        "--stamp-dir",
-        dest = "stampDir",
-        action = "store",
-        default = None,
-        help = "Create the stamp file in the specified directory. If not specified"
-              +" the directory of the source file is used."
-        )
-    parser.add_option(
-        "--no-stamp",
-        action = "store_true",
-        help = "Do no create stamp files."
-        )
-    parser.add_option(
-        "--ignore-missing",
-        dest = "ignoreMissing",
-        action = "store_true",
-        help = "Print a warning if a fragment file is missing, but do not fail."
-        )
-
-    (options, args) = parser.parse_args()
-
-    # ensure consistency...
-    options.doMerge = not options.unMerge
-
-    # allow command line syntax as
-    #   merge_files.py [options] <fragment file1> [<fragment file2>...] <merged file>
-    if args:
-        options.mergedFileName = args[-1]
-        options.fragFileNames += args[:-1]
-
-    sc = 1
-    if not options.fragFileNames or \
-       not options.mergedFileName :
-        str(parser.print_help() or "")
-        print "*** ERROR ***",sys.argv
-        sys.exit(sc)
-        pass
-
-    if options.stampDir is None:
-        stampFileName = lambda x: x + ".stamp"
-    else:
-        stampFileName = lambda x: os.path.join(options.stampDir,
-                                               os.path.basename(x)
-                                               + ".stamp")
-    # Configure Python logging
-    import logging
-    logging.basicConfig(level = logging.INFO)
-
-    if "GAUDI_BUILD_LOCK" in os.environ:
-        globalLock = locker.LockFile(os.environ["GAUDI_BUILD_LOCK"], temporary =  True)
-    else:
-        globalLock = None
-
-    if True: #try:
-        sc = mergeFiles( options.fragFileNames, options.mergedFileName,
-                         options.commentChar,
-                         doMerge = options.doMerge,
-                         ignoreMissing = options.ignoreMissing)
-        if not options.no_stamp:
-            for stamp in map(stampFileName, options.fragFileNames):
-                open(stamp, 'w')
-    #except IOError, err:
-    #    print "ERROR:",err
-    #except Exception, err:
-    #    print "ERROR:",err
-    #except:
-    #    print "ERROR: unknown error !!"
-
-    del globalLock
-
-    sys.exit( sc )