CMakeModules/libbatchMacros.cmake

   1 # Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 #
   6 # This library is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU Lesser General Public
   8 # License as published by the Free Software Foundation; either
   9 # version 2.1 of the License, or (at your option) any later version.
  10 #
  11 # This library is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # Lesser General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU Lesser General Public
  17 # License along with this library; if not, write to the Free Software
  18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 #
  20 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 #
  22
  23 #
  24 # Set of macros to identify local shell commands for file deletion,
  25 # file copy, etc ... (under Windows and Unix).
  26 #
  27 MACRO(FIND_LOCAL_COMMAND VAR UNIX_COMMAND WIN32_COMMAND)
  28     IF (WIN32)
  29         FIND_PROGRAM(${VAR} ${WIN32_COMMAND})
  30     ELSE (WIN32)
  31         FIND_PROGRAM(${VAR} ${UNIX_COMMAND})
  32     ENDIF (WIN32)
  33     IF (${VAR})
  34         MESSAGE(STATUS "${VAR} found : ${${VAR}}")
  35     ELSE (${VAR})
  36         MESSAGE(STATUS "${VAR} not found, local submission might not work properly")
  37     ENDIF (${VAR})
  38 ENDMACRO(FIND_LOCAL_COMMAND)
  39
  40 MACRO(FIND_LOCAL_COMMAND_WIN32_DEF VAR UNIX_COMMAND WIN32_DEFAULT)
  41     IF (WIN32)
  42         SET(${VAR} ${WIN32_DEFAULT} CACHE STRING "${VAR}")
  43         MESSAGE(STATUS "${VAR} found : using '${${VAR}}' (Windows default)")
  44     ELSE (WIN32)
  45         FIND_LOCAL_COMMAND(${VAR} ${UNIX_COMMAND} ${WIN32_DEFAULT})
  46     ENDIF (WIN32)
  47 ENDMACRO(FIND_LOCAL_COMMAND_WIN32_DEF)
  48
  49 MACRO(EVAL VAR)
  50    IF(${ARGN})
  51      SET(${VAR} TRUE)
  52    ELSE(${ARGN})
  53      SET(${VAR} FALSE)
  54    ENDIF(${ARGN})
  55 ENDMACRO(EVAL)
  56
  57 MACRO(LIBBATCH_FIND_ALL_LOCAL_COMMANDS)
  58   MESSAGE(STATUS "Looking for commands needed for local submission...")
  59
  60   FIND_LOCAL_COMMAND_WIN32_DEF(LIBBATCH_RM_COMMAND rm del)
  61   FIND_LOCAL_COMMAND(LIBBATCH_SH_COMMAND sh cmd.exe)
  62   FIND_LOCAL_COMMAND_WIN32_DEF(LIBBATCH_CP_COMMAND cp copy)
  63   FIND_LOCAL_COMMAND_WIN32_DEF(LIBBATCH_MKDIR_COMMAND mkdir md)
  64   FIND_LOCAL_COMMAND(LIBBATCH_RSH_COMMAND rsh rsh)
  65   FIND_LOCAL_COMMAND(LIBBATCH_RCP_COMMAND rcp rcp)
  66   FIND_LOCAL_COMMAND(LIBBATCH_SSH_COMMAND ssh plink)
  67   FIND_LOCAL_COMMAND(LIBBATCH_SCP_COMMAND scp pscp)
  68   FIND_LOCAL_COMMAND(LIBBATCH_RSYNC_COMMAND rsync pscp)
  69
  70   # Mark shell commands as advanced options
  71   # and assign the names without the LIBBATCH_ in front:
  72   SET (_cmds "RM;SH;CP;MKDIR;RSH;RCP;SSH;SCP;RSYNC")
  73   FOREACH(_cmd ${_cmds})
  74     MARK_AS_ADVANCED(LIBBATCH_${_cmd}_COMMAND)
  75     SET(${_cmd}_COMMAND ${LIBBATCH_${_cmd}_COMMAND})
  76   ENDFOREACH()
  77 ENDMACRO()
  78
  79 #
  80 # Display configuration summary
  81 #
  82 MACRO(LIBBATCH_SUMMARY)
  83   MESSAGE(STATUS "")
  84   MESSAGE(STATUS "**************** Libbatch Summary *******")
  85   MESSAGE(STATUS "")
  86   IF (LIBBATCH_LOCAL_SUBMISSION)
  87     MESSAGE(STATUS "Local submission .................... Yes")
  88   ELSE()
  89     MESSAGE(STATUS "Local submission .......... Not requested")
  90   ENDIF()
  91
  92   IF (LIBBATCH_PYTHON_WRAPPING)
  93     IF (PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND AND SWIG_FOUND)
  94       MESSAGE(STATUS "Python wrapping ..................... Yes")
  95     ELSE()
  96       MESSAGE(STATUS "Python wrapping ............... Python libs (or Swig) not found")
  97     ENDIF()
  98   ELSE()
  99     MESSAGE(STATUS "Python wrapping ........... Not requested")
 100   ENDIF()
 101
 102   MESSAGE(STATUS "")
 103   MESSAGE(STATUS "************** End Summary **************")
 104   MESSAGE(STATUS "")
 105 ENDMACRO()
 106
 107 ###
 108 # SALOME_CHECK_EQUAL_PATHS(result path1 path2)
 109 #  Check if two paths are identical, resolving links. If the paths do not exist a simple
 110 #  text comparison is performed.
 111 #  result is a boolean.
 112 ###
 113 MACRO(SALOME_CHECK_EQUAL_PATHS varRes path1 path2)
 114   SET("${varRes}" OFF)
 115   IF(EXISTS "${path1}")
 116     GET_FILENAME_COMPONENT(_tmp1 "${path1}" REALPATH)
 117   ELSE()
 118     SET(_tmp1 "${path1}")
 119   ENDIF()
 120
 121   IF(EXISTS "${path2}")
 122     GET_FILENAME_COMPONENT(_tmp2 "${path2}" REALPATH)
 123   ELSE()
 124     SET(_tmp2 "${path2}")
 125   ENDIF()
 126
 127   IF("${_tmp1}" STREQUAL "${_tmp2}")
 128     SET("${varRes}" ON)
 129   ENDIF()
 130 #  MESSAGE(${${varRes}})
 131 ENDMACRO()
 132
 133
 134 ####
 135 # SALOME_FIND_PACKAGE(englobingPackageName standardPackageName modus)
 136 # Encapsulate the call to the standard FIND_PACKAGE(standardPackageName) passing all the options
 137 # given when calling the command FIND_PACKAGE(customPackageName)
 138 # Modus is either MODULE or CONFIG (cf standard FIND_PACKAGE() documentation).
 139 # This macro is to be called from within the FindCustomPackage.cmake file.
 140 ####
 141 MACRO(SALOME_FIND_PACKAGE englobPkg stdPkg mode)
 142   # Only bother if the package was not already found:
 143   # Some old packages use the lower case version - standard should be to always use
 144   # upper case:
 145   STRING(TOUPPER ${stdPkg} stdPkgUC)
 146   IF(NOT (${stdPkg}_FOUND OR ${stdPkgUC}_FOUND))
 147     IF(${englobPkg}_FIND_QUIETLY)
 148       SET(_tmp_quiet "QUIET")
 149     ELSE()
 150       SET(_tmp_quiet)
 151     ENDIF()
 152     IF(${englobPkg}_FIND_REQUIRED)
 153       SET(_tmp_req "REQUIRED")
 154     ELSE()
 155       SET(_tmp_req)
 156     ENDIF()
 157     IF(${englobPkg}_FIND_VERSION_EXACT)
 158       SET(_tmp_exact "EXACT")
 159     ELSE()
 160       SET(_tmp_exact)
 161     ENDIF()
 162     IF(${englobPkg}_FIND_COMPONENTS)
 163       STRING(REPLACE ";" " " _tmp_compo ${${englobPkg}_FIND_COMPONENTS})
 164     ELSE()
 165       SET(_tmp_compo)
 166     ENDIF()
 167
 168     # Call the root FIND_PACKAGE():
 169     #MESSAGE("blabla ${englobPkg} / ${${englobPkg}_FIND_VERSION_EXACT} / ${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode}")
 170     IF(_tmp_compo)
 171       FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode} ${_tmp_quiet} ${_tmp_req} COMPONENTS ${_tmp_compo})
 172     ELSE()
 173       FIND_PACKAGE(${stdPkg} ${${englobPkg}_FIND_VERSION} ${_tmp_exact} ${mode} ${_tmp_quiet} ${_tmp_req})
 174     ENDIF()
 175   ENDIF()
 176 ENDMACRO()
 177
 178 ####################################################################"
 179 # SALOME_FIND_PACKAGE_DETECT_CONFLICTS(pkg referenceVariable upCount)
 180 #    pkg              : name of the system package to be detected
 181 #    referenceVariable: variable containing a path that can be browsed up to
 182 # retrieve the package root directory (xxx_ROOT_DIR)
 183 #    upCount          : number of times we have to go up from the path <referenceVariable>
 184 # to obtain the package root directory.
 185 #
 186 # For example:  SALOME_FIND_PACKAGE_DETECT_CONFLICTS(SWIG SWIG_EXECUTABLE 2)
 187 #
 188 # Generic detection (and conflict check) procedure for package XYZ:
 189 # 1. Load a potential env variable XYZ_ROOT_DIR as a default choice for the cache entry XYZ_ROOT_DIR
 190 #    If empty, load a potential XYZ_ROOT_DIR_EXP as default value (path exposed by another package depending
 191 # directly on XYZ)
 192 # 2. Invoke FIND_PACKAGE() in this order:
 193 #    * in CONFIG mode first (if possible): priority is given to a potential
 194 #    "XYZ-config.cmake" file
 195 #    * then switch to the standard MODULE mode, appending on CMAKE_PREFIX_PATH
 196 # the above XYZ_ROOT_DIR variable
 197 # 3. Extract the path actually found into a temp variable _XYZ_TMP_DIR
 198 # 4. Warn if XYZ_ROOT_DIR is set and doesn't match what was found (e.g. when CMake found the system installation
 199 #    instead of what is pointed to by XYZ_ROOT_DIR - happens when a typo in the content of XYZ_ROOT_DIR).
 200 # 5. Conflict detection:
 201 #    * check the temp variable against a potentially existing XYZ_ROOT_DIR_EXP
 202 # 6. Finally expose what was *actually* found in XYZ_ROOT_DIR.
 203 # 7. Specific stuff: for example exposing a prerequisite of XYZ to the rest of the world for future
 204 # conflict detection. This is added after the call to the macro by the callee.
 205 #
 206 MACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS pkg referenceVariable upCount)
 207   STRING(TOUPPER ${pkg} pkg_UC)
 208
 209   # 1. Load environment or any previously detected root dir for the package
 210   IF(DEFINED ENV{${pkg_UC}_ROOT_DIR})
 211     FILE(TO_CMAKE_PATH "$ENV{${pkg_UC}_ROOT_DIR}" _${pkg_UC}_ROOT_DIR_ENV)
 212     SET(_dflt_value "${_${pkg_UC}_ROOT_DIR_ENV}")
 213   ELSE()
 214     # will be blank if no package was previously loaded
 215     SET(_dflt_value "${${pkg_UC}_ROOT_DIR_EXP}")
 216   ENDIF()
 217
 218   #   Make cache entry
 219   SET(${pkg_UC}_ROOT_DIR "${_dflt_value}" CACHE PATH "Path to ${pkg_UC} directory")
 220
 221   # 2. Find package - config mode first (i.e. looking for XYZ-config.cmake)
 222   IF(EXISTS "${${pkg_UC}_ROOT_DIR}")
 223     # Hope to find direclty a CMake config file there
 224     SET(_CONF_DIR "${${pkg_UC}_ROOT_DIR}/share/cmake")
 225
 226     # Try find_package in config mode with a hard-coded guess. This
 227     # has the priority.
 228     FIND_PACKAGE(${pkg} NO_MODULE QUIET PATHS "${_CONF_DIR}")
 229     MARK_AS_ADVANCED(${pkg}_DIR)
 230
 231     IF (NOT ${pkg_UC}_FOUND)
 232       SET(CMAKE_PREFIX_PATH "${${pkg_UC}_ROOT_DIR}")
 233     ELSE()
 234       MESSAGE(STATUS "Found ${pkg} in CONFIG mode!")
 235     ENDIF()
 236   ENDIF()
 237
 238   # Otherwise try the standard way (module mode, with the standard CMake Find*** macro):
 239   SALOME_FIND_PACKAGE("Salome${pkg}" ${pkg} MODULE)
 240   #MESSAGE("dbg ${pkg_UC} / ${PTHREAD_FOUND} / ${${pkg_UC}_FOUND}")
 241   # Set the "FOUND" variable for the SALOME wrapper:
 242   IF(${pkg_UC}_FOUND OR ${pkg}_FOUND)
 243     SET(SALOME${pkg_UC}_FOUND TRUE)
 244   ELSE()
 245     SET(SALOME${pkg_UC}_FOUND FALSE)
 246   ENDIF()
 247
 248   IF (${pkg_UC}_FOUND OR ${pkg}_FOUND)
 249     # 3. Set the root dir which was finally retained by going up "upDir" times
 250     # from the given reference path. The variable "referenceVariable" may be a list
 251     # - we take its first element.
 252     #   Note the double de-reference of "referenceVariable":
 253     LIST(LENGTH "${${referenceVariable}}" _tmp_len)
 254     IF(_tmp_len)
 255        LIST(GET "${${referenceVariable}}" 0 _tmp_ROOT_DIR)
 256     ELSE()
 257        SET(_tmp_ROOT_DIR "${${referenceVariable}}")
 258     ENDIF()
 259     IF(${upCount})
 260       MATH(EXPR _rge "${upCount}-1")
 261       FOREACH(_unused RANGE ${_rge})
 262         GET_FILENAME_COMPONENT(_tmp_ROOT_DIR "${_tmp_ROOT_DIR}" PATH)
 263       ENDFOREACH()
 264     ENDIF()
 265
 266     # 4. Warn if CMake found something not located under ENV(XYZ_ROOT_DIR)
 267     IF(DEFINED ENV{${pkg_UC}_ROOT_DIR})
 268       SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${_${pkg_UC}_ROOT_DIR_ENV}")
 269       IF(NOT _res)
 270         MESSAGE(WARNING "${pkg} was found, but not at the path given by the "
 271             "environment ${pkg_UC}_ROOT_DIR! Is the variable correctly set? "
 272             "The two paths are: ${_tmp_ROOT_DIR} and: ${_${pkg_UC}_ROOT_DIR_ENV}")
 273
 274       ELSE()
 275         MESSAGE(STATUS "${pkg} found directory matches what was specified in the ${pkg_UC}_ROOT_DIR variable, all good!")
 276       ENDIF()
 277     ELSE()
 278         MESSAGE(STATUS "Variable ${pkg_UC}_ROOT_DIR was not explicitly defined: "
 279           "an installation was found anyway: ${_tmp_ROOT_DIR}")
 280     ENDIF()
 281
 282     # 5. Conflict detection
 283     # 5.1  From another prerequisite using the package
 284     IF(${pkg_UC}_ROOT_DIR_EXP)
 285         SALOME_CHECK_EQUAL_PATHS(_res "${_tmp_ROOT_DIR}" "${${pkg_UC}_ROOT_DIR_EXP}")
 286         IF(NOT _res)
 287            MESSAGE(WARNING "Warning: ${pkg}: detected version conflicts with a previously found ${pkg}!"
 288                             "The two paths are " ${_tmp_ROOT_DIR} " vs " ${${pkg_UC}_ROOT_DIR_EXP})
 289         ELSE()
 290             MESSAGE(STATUS "${pkg} directory matches what was previously exposed by another prereq, all good!")
 291         ENDIF()
 292     ENDIF()
 293
 294     # 6. Save the found installation
 295     #
 296     SET(${pkg_UC}_ROOT_DIR "${_tmp_ROOT_DIR}")
 297
 298   ELSE()
 299     MESSAGE(STATUS "${pkg} was not found.")
 300   ENDIF()
 301 ENDMACRO(SALOME_FIND_PACKAGE_AND_DETECT_CONFLICTS)