cmake/CheckGitVersion.cmake

   1 # 1. Extracts versioning information from the Git repository
   2 # 2. Enables rerun of cmake configuration on each pull: GetGitRevisionDescription
   3 #  - ALIROOT_VERSION - branch/tag name or short hash if detached at randon hash
   4 #  - ALIROOT_REVISION - short sha1
   5 #  - ALIROOT_SERIAL - number of commits
   6 #  - ALIROOT_VERSION_RPM - name of the branch/tag in rpm format, - replaced with .
   7 #  - ALIROOT_GITREFTYPE - BRANCH/TAG/DETACHED
   8
   9 # Setting default values
  10 set(ALIROOT_VERSION "")
  11 set(ALIROOT_REVISION "")
  12 set(ALIROOT_SERIAL 0)
  13 set(ALIROOT_GITREFTYPE "")
  14
  15 # Checks if the sources where cloned as a full git repository
  16 if(EXISTS ${AliRoot_SOURCE_DIR}/.git/)
  17   # Git installation mandatory
  18   find_package(Git REQUIRED)
  19
  20   # The simple include will not trigger the reconfiguration
  21   # get_git_head_revision has to be called at least once
  22   include(GetGitRevisionDescription)
  23   # GIT_SHA1 - current long hash
  24   # GIT_REFSPEC
  25   #     1. branches: refs/heads/master
  26   #     2. detached mode(tags or hashes) empty string
  27   get_git_head_revision(GIT_REFSPEC GIT_SHA1)
  28
  29   if(CMAKEDEBUG)
  30     message(STATUS "DEBUG: GIT_REFSPEC = \"${GIT_REFSPEC}\", GIT_SHA1 = \"${GIT_SHA1}\"")
  31   endif(CMAKEDEBUG)
  32
  33   # Setting ALIROOT_REVISION as the long hash
  34   set(ALIROOT_REVISION ${GIT_SHA1})
  35
  36   # Generate the short version of the revision hash
  37   execute_process(COMMAND git rev-parse --short ${GIT_SHA1}
  38                   WORKING_DIRECTORY ${AliRoot_SOURCE_DIR}
  39                   OUTPUT_VARIABLE GIT_SHORT_SHA1
  40                   RESULT_VARIABLE process_result
  41                   ERROR_VARIABLE process_error
  42                   OUTPUT_STRIP_TRAILING_WHITESPACE
  43                   ERROR_STRIP_TRAILING_WHITESPACE
  44                 )
  45   # Set ALIROOT_REVISION to short hash if no error
  46   if(process_result EQUAL 0)
  47     if(CMAKEDEBUG)
  48       message(STATUS "DEBUG: Short SHA1 = \"${GIT_SHORT_SHA1}\"")
  49     endif(CMAKEDEBUG)
  50
  51     set(ALIROOT_REVISION ${GIT_SHORT_SHA1})
  52   else()
  53     if(CMAKEDEBUG)
  54       message(STATUS "DEBUG: result = \"${process_result}\",  parse-rev error : ${ERROR_VARIABLE}")
  55     endif()
  56
  57     message(WARNING "Could not retrieve the short hash, using the long version : \"${ALIROOT_REVISION}\"")
  58   endif()
  59
  60   # Generate ALIROOT_VERSION
  61   # 1. Branch -> Branch name
  62   # 2. Detached mode
  63   #    2.1 Tags -> Tag name
  64   #    2.2 Detached hash -> Short hash
  65
  66   # Check if dettached mode
  67   # rev-parse will return:
  68   # 1. Branch -> Branch name, ex: master
  69   # 2. Detached mode: "HEAD" for both tags and random hashes
  70   execute_process(COMMAND git rev-parse --abbrev-ref HEAD
  71                   WORKING_DIRECTORY ${AliRoot_SOURCE_DIR}
  72                   OUTPUT_VARIABLE ref_output
  73                   RESULT_VARIABLE ref_result
  74                   ERROR_VARIABLE ref_error
  75                   OUTPUT_STRIP_TRAILING_WHITESPACE
  76                   ERROR_STRIP_TRAILING_WHITESPACE
  77                 )
  78
  79   if(ref_result EQUAL 0)
  80     if(CMAKEDEBUG)
  81       message(STATUS "DEBUG: rev-parse HEAD result = \"${ref_output}\"")
  82     endif()
  83
  84     # detached mode
  85     if(ref_output STREQUAL "HEAD")
  86       # Checking if this is a tag in detached mode
  87       #  1. If tag the OUTPUT_VARIABLE will contain the tag name
  88       #  2. If random hash the RESULT_VARIABLE is 128 and ERROR_VARIABLE contains the error message
  89       execute_process(COMMAND git describe --exact-match
  90                       WORKING_DIRECTORY ${AliRoot_SOURCE_DIR}
  91                       OUTPUT_VARIABLE tag_output
  92                       RESULT_VARIABLE tag_result
  93                       ERROR_VARIABLE tag_error
  94                       OUTPUT_STRIP_TRAILING_WHITESPACE
  95                       ERROR_STRIP_TRAILING_WHITESPACE
  96                     )
  97
  98       if(tag_result EQUAL 0)
  99
 100         if(CMAKEDEBUG)
 101           message(STATUS "DEBUG: git describe tag_result = ${tag_output}")
 102         endif()
 103
 104         set(ALIROOT_VERSION ${tag_output})
 105         set(ALIROOT_GITREFTYPE "TAG")
 106       else()
 107         # Detached at a random hash, the version is the short SHA1
 108         if(CMAKEDEBUG)
 109           message(STATUS "DEBUG: git describe tar_error = ${tag_error}")
 110         endif()
 111
 112         set(ALIROOT_VERSION ${ALIROOT_REVISION})
 113         set(ALIROOT_GITREFTYPE "DETACHED")
 114       endif()
 115     else()
 116       # Branch
 117       set(ALIROOT_VERSION ${ref_output})
 118       set(ALIROOT_GITREFTYPE "BRANCH")
 119     endif()
 120   else(ref_result EQUAL 0)
 121     message(FATAL_ERROR "Could not retreive information about the current git hash: ${ref_error}")
 122   endif(ref_result EQUAL 0)
 123
 124   # Generating the ALIROOT_SERIAL using git rev-list
 125   # Older Git version < 1.7.3 do not have --count option for rev-list
 126   # We use simple rev-list and count the lines of the output
 127
 128   # extract major minor and patch from Git version
 129   string(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" GIT_VERSION_MAJOR "${GIT_VERSION_STRING}")
 130   string(REGEX REPLACE "^[0-9]+\\.([0-9]+)\\.[0-9]+" "\\1" GIT_VERSION_MINOR "${GIT_VERSION_STRING}")
 131   string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" GIT_VERSION_PATCH "${GIT_VERSION_STRING}")
 132
 133   if(${GIT_VERSION_MAJOR} EQUAL 1 AND ${GIT_VERSION_MINOR} LESS 3)
 134     if(CMAKEDEBUG)
 135       message(STATUS "DEBUG: cmake version less that 1.7.3!")
 136     endif()
 137
 138     execute_process(COMMAND git rev-list ${GIT_SHA1}
 139                     COMMAND wc -l
 140                     WORKING_DIRECTORY ${AliRoot_SOURCE_DIR}
 141                     RESULT_VARIABLE serial_result
 142                     ERROR_VARIABLE serial_error
 143                     OUTPUT_VARIABLE serial_output
 144                     OUTPUT_STRIP_TRAILING_WHITESPACE
 145                     ERROR_STRIP_TRAILING_WHITESPACE
 146                   )
 147   else()
 148     execute_process(COMMAND git rev-list --count ${GIT_SHA1}
 149                     WORKING_DIRECTORY ${AliRoot_SOURCE_DIR}
 150                     RESULT_VARIABLE serial_result
 151                     ERROR_VARIABLE serial_error
 152                     OUTPUT_VARIABLE serial_output
 153                     OUTPUT_STRIP_TRAILING_WHITESPACE
 154                     ERROR_STRIP_TRAILING_WHITESPACE
 155       )
 156
 157   endif()
 158
 159   if(serial_result EQUAL 0)
 160     if(CMAKEDEBUG)
 161       message(STATUS "DEBUG: AliRoot serial: ${serial_output}")
 162     endif()
 163
 164     set(ALIROOT_SERIAL ${serial_output})
 165   else()
 166     message(FATAL_ERROR "Could not retrieve serial number: ${serial_error}")
 167   endif()
 168
 169   if(${ALIROOT_GITREFTYPE} STREQUAL "DETACHED")
 170     message(STATUS "Found AliRoot in detached mode, hash \"${ALIROOT_REVISION}\", serial \"${ALIROOT_SERIAL}\"")
 171   elseif(${ALIROOT_GITREFTYPE} STREQUAL "BRANCH")
 172     message(STATUS "Found AliRoot branch \"${ALIROOT_VERSION}\", hash \"${ALIROOT_REVISION}\", serial \"${ALIROOT_SERIAL}\"")
 173   elseif(${ALIROOT_GITREFTYPE} STREQUAL "TAG")
 174     message(STATUS "Found AliRoot tag \"${ALIROOT_VERSION}\", hash \"${ALIROOT_REVISION}\", serial \"${ALIROOT_SERIAL}\"")
 175   else()
 176     # it does not get here
 177     message(FATAL_ERROR "Git type error")
 178   endif()
 179 else(EXISTS ${AliRoot_SOURCE_DIR}/.git/)
 180     message(WARNING "AliRoot sources not downloaded from a Version Control System. I can't tell which revision you are using!")
 181 endif(EXISTS ${AliRoot_SOURCE_DIR}/.git/)
 182
 183 # ALIROOT_VERSION_RPM
 184 # Replacing -/ with . , normally it should not contain /
 185 # - and / are forbidden characters in rpm creation
 186 string(REPLACE "-" "." ALIROOT_VERSION_RPM ${ALIROOT_VERSION})
 187 string(REPLACE "/" "." ALIROOT_VERSION_RPM ${ALIROOT_VERSION_RPM})
 188 if(CMAKEDEBUG)
 189   message(STATUS "DEBUG: ALIROOT_VERSION_RPM = ${ALIROOT_VERSION_RPM}")
 190 endif()
 191
 192 # Generating ARVersion.h from ARVersion.h.tmp
 193 set(ALIROOT_AR_VERSION ${ALIROOT_VERSION})
 194 if(${ALIROOT_GITREFTYPE} STREQUAL "BRANCH")
 195   set(ALIROOT_AR_REVISION "")
 196   set(ALIROOT_AR_SERIAL 0)
 197 else()
 198   set(ALIROOT_AR_REVISION ${ALIROOT_REVISION})
 199   set(ALIROOT_AR_SERIAL ${ALIROOT_SERIAL})
 200 endif()
 201 configure_file(${PROJECT_SOURCE_DIR}/cmake/ARVersion.h.tmp ${CMAKE_BINARY_DIR}/version/ARVersion.h @ONLY)
 202 install(FILES ${PROJECT_BINARY_DIR}/version/ARVersion.h DESTINATION include)