release/release.bash

   1 #!/bin/bash
   2
   3 set -e
   4 set -u
   5
   6
   7 # ##############################################################################
   8 # # Settings
   9 # ##############################################################################
  10
  11 declare MODE_BRANCH="branch"
  12 declare MODE_RELEASE="release"
  13
  14 declare MODE_BRANCH_TXT="Branch"
  15 declare MODE_BRANCH_TXT_LOWER="branch"
  16 declare MODE_RELEASE_TXT="Release"
  17 declare MODE_RELEASE_TXT_LOWER="release"
  18
  19 declare MODE_TXT=""
  20 declare MODE_TXT_LOWER=""
  21
  22
  23 # The digit representation of a basic version can be in the format 0.6.4
  24 declare versionRegexDigitsBasic="([[:digit:]]+\.[[:digit:]]+\.[[:digit:]]+)"
  25
  26 # The digit representation of a release branch version can be in the format
  27 # 0.6.4 or 0.6.4.1
  28 declare versionRegexDigits="${versionRegexDigitsBasic}(\.[[:digit:]]+)?"
  29
  30 # The version for source code can be in the format:
  31 # - 0.6.4 or 0.6.4.1 or pre-0.6.4 or pre-0.6.4.1
  32 declare versionRegexSources="(|pre-)(${versionRegexDigits})"
  33
  34 # The version for a release tag is in the format v0.6.4 or v0.6.4.1
  35 declare versionRegexReleaseTag="v(${versionRegexDigits})"
  36
  37 # A release branch is in the format release-0.6.4 or release-0.6.4.1
  38 declare relBranchRegex="release-(${versionRegexDigits})"
  39
  40
  41
  42
  43 # ##############################################################################
  44 # # Functions
  45 # ##############################################################################
  46
  47 #
  48 # Print script usage
  49 #
  50 function usage() {
  51   echo ""
  52   echo "  $(basename "${script}") ${MODE_BRANCH} 0.6.4"
  53   echo "    - create the release branch for version 0.6.4"
  54   echo "  $(basename "${script}") ${MODE_RELEASE}"
  55   echo "    - release the (checked-out) release branch"
  56 }
  57
  58
  59 #
  60 # Trim a string: remove spaces from the beginning and end of the string
  61 #
  62 # 1=string to trim
  63 # return=trimmed string
  64 function stringTrim() {
  65   if [[ -z "${1}" ]]; then
  66     return
  67   fi
  68
  69   # remove leading whitespace characters
  70   local var="${1#${1%%[![:space:]]*}}"
  71
  72   # remove trailing whitespace characters
  73   echo "${var%${var##*[![:space:]]}}"
  74 }
  75
  76
  77 #
  78 # Get the canonical path of a file or directory
  79 # This is the physical path without any links
  80 #
  81 # 1=the file or directory
  82 function pathCanonicalPath() {
  83   local src="$(stringTrim "${1}")"
  84
  85   if [[ -h "${src}" ]] && [[ -d "${src}" ]]; then
  86     # src is a link to a directory
  87     pushd . &> /dev/null
  88     cd -P "${src}" &> /dev/null
  89     pwd -P
  90     popd &> /dev/null
  91     return
  92   fi
  93
  94   # we're not dealing with a directory here
  95   while [[ -h "${src}" ]]; do
  96     # keep getting the link target while src is a link
  97     src="$(ls -la "${src}" | \
  98            sed -r 's#^.*?[[:space:]]+->[[:space:]]+(.*)$#\1#')"
  99   done
 100   # src is no longer a link here
 101
 102   pushd . &> /dev/null
 103   cd -P "$(dirname "${src}")" &> /dev/null
 104   echo "$(pwd -P)/$(basename "${src}")"
 105   popd &> /dev/null
 106 }
 107
 108
 109 #
 110 # Determine whether a given directory is a git repository directory
 111 #
 112 # 1=directory
 113 # return=0 not a git dir, 1 a git dir
 114 function gitIsGitDirectory() {
 115   local place="$(stringTrim "${1}")"
 116
 117   local -i result=1
 118   if [[ -d "${place}" ]]; then
 119     pushd "${place}" &> /dev/null
 120     set +e
 121     git rev-parse --git-dir &> /dev/null
 122     result=${?}
 123     set -e
 124     popd &> /dev/null
 125   fi
 126
 127   if [[ ${result} -ne 0 ]]; then
 128     echo "0"
 129   else
 130     echo "1"
 131   fi
 132 }
 133
 134
 135 #
 136 # Go into the root of the checkout and check some key files
 137 #
 138 function checkIsOlsrdGitCheckout() {
 139   if [[ "$(gitIsGitDirectory ".")" == "0" ]] || \
 140      [[ ! -r ./Makefile.inc ]] || \
 141      [[ ! -r ./files/olsrd.conf.default.full ]]; then
 142     echo "* You do not appear to be running the script from an olsrd git checkout"
 143     exit 1
 144   fi
 145 }
 146
 147
 148 #
 149 # Check that a signing key is configured
 150 #
 151 function checkGitSigningKeyIsConfigured() {
 152   local gpgKeyId="$(git config --get user.signingkey)"
 153   if [[ -z "${gpgKeyId}" ]]; then
 154     cat >&1 << EOF
 155 * No signing key is setup for git, please run
 156     git config --global user.signingkey <key ID>
 157
 158   You can get keys and IDs by running 'gpg --list-keys'
 159 EOF
 160     exit 1
 161   fi
 162
 163   #
 164   # Check that the signing key is present
 165   #
 166         set +e
 167         gpg --list-key "${gpgKeyId}" &> /dev/null
 168         local -i gpgKeyIdPresentResult=${?}
 169         set -e
 170         if [[ ${gpgKeyIdPresentResult} -ne 0 ]]; then
 171           cat >&1 << EOF
 172 * Your signing key with ID ${gpgKeyId} is not found, please run
 173     git config --global user.signingkey <key ID>
 174   to setup a valid key ID.
 175
 176   You can get keys and IDs by running 'gpg --list-keys'
 177 EOF
 178           exit 1
 179         fi
 180 }
 181
 182
 183 #
 184 # Get the version digits from a release tag version
 185 #
 186 # 1=release tag version
 187 # return=version digits
 188 function getVersionDigitsFromReleaseTag() {
 189   echo "$(stringTrim "${1}")" | sed -r "s/${versionRegexReleaseTag}/\1/"
 190 }
 191
 192
 193 #
 194 # Get the previous release tag and check
 195 #
 196 declare prevRelTagVersion=""
 197 function getPrevRelTag() {
 198   set +e
 199   prevRelTagVersion="$(git describe --abbrev=0 --match 'v[0-9].[0-9].[0-9]' | \
 200                        grep -E "^${versionRegexReleaseTag}$")"
 201   set -e
 202   if [[ -z "${prevRelTagVersion}" ]]; then
 203     echo "* Could not find the previous release tag"
 204     exit 1
 205   fi
 206 }
 207
 208
 209 #
 210 # Get the next version digits by incrementing the micro digit
 211 #
 212 # 1=version in format 0.6.4 or 0.6.4.1
 213 # return=incremented version in format 0.6.5
 214 function getNextVersionDigitsMicro() {
 215   local version="$(stringTrim "${1}")"
 216   local -a versionDigits=( ${version//\./ } )
 217   local -i versionMicroNext=$(( ${versionDigits[2]} + 1 ))
 218   echo "${versionDigits[0]}.${versionDigits[1]}.${versionMicroNext}"
 219 }
 220
 221
 222 #
 223 # Get the next version digits by incrementing the patchlevel digit
 224 #
 225 # 1=version in format 0.6.4 or 0.6.4.0
 226 # return=incremented version in format 0.6.4.1
 227 function getNextVersionDigitsPatchLevel() {
 228   local version="$(stringTrim "${1}")"
 229   local -a versionDigits=( ${version//\./ } )
 230   local -i versionPatchLevelNext=1
 231   if [[ ${#versionDigits[*]} -ne 3 ]]; then
 232     versionPatchLevelNext=$(( ${versionDigits[3]} + 1 ))
 233   fi
 234   echo "${versionDigits[0]}.${versionDigits[1]}.${versionDigits[2]}.${versionPatchLevelNext}"
 235 }
 236
 237
 238 #
 239 # Adjust the branch name so that we can release 0.6.4.x from the
 240 # release-0.6.4 branch
 241 #
 242 # prevTagVersionDigits  relBranchVersionDigits  relBranchVersionDigits (adjusted)
 243 #       0.6.4                   0.6.4                   0.6.4.1
 244 #       0.6.4                   0.6.5                   -
 245 #       0.6.4                   0.6.4.5                 -
 246 #       0.6.4                   0.6.5.5                 -
 247 #       0.6.4.5                 0.6.4                   0.6.4.6
 248 #       0.6.4.5                 0.6.5                   -
 249 #       0.6.4.5                 0.6.4.6                 -
 250 #       0.6.4.5                 0.6.5.6                 -
 251 function adjustBranchName() {
 252   local -a prevTagVersionDigitsArray=( ${prevTagVersionDigits//\./ } )
 253   local -a relBranchVersionDigitsArray=( ${relBranchVersionDigits//\./ } )
 254   local -i prevTagVersionDigitsCount=${#prevTagVersionDigitsArray[*]}
 255   local -i relBranchVersionDigitsCount=${#relBranchVersionDigitsArray[*]}
 256   local prevTagVersionTrain="$(echo "$(stringTrim "${prevTagVersionDigits}")" | \
 257                                sed -r "s/${versionRegexDigits}/\1/")"
 258
 259   if  [[ "${prevTagVersionDigits}" == "${relBranchVersionDigits}" ]] || \
 260      ([[ "${prevTagVersionTrain}"  == "${relBranchVersionDigits}" ]] && \
 261       [[ ${prevTagVersionDigitsCount}   -eq 4 ]] && \
 262       [[ ${relBranchVersionDigitsCount} -eq 3 ]]); then
 263     relBranchVersionDigits="$(getNextVersionDigitsPatchLevel "${prevTagVersionDigits}")"
 264   fi
 265 }
 266
 267
 268 #
 269 # Check that the new version is incrementing
 270 #
 271 # 1=last version
 272 # 2=new version
 273 # 3= 0 to disallow equal versions as ok
 274 # return (in checkVersionIncrementingResult) = 0 when new version > last version,
 275 #                                              1 otherwise
 276 declare -i checkVersionIncrementingResult=0
 277 function checkVersionIncrementing() {
 278   checkVersionIncrementingResult=0
 279   local lastVersion="$(stringTrim "${1}")"
 280   local newVersion="$(stringTrim "${2}")"
 281   local -i allowEqualVersions=${3}
 282
 283   local -a lastVersionDigits=( ${lastVersion//\./ } )
 284   local -a newVersionDigits=( ${newVersion//\./ } )
 285
 286   # if the last version is in the format 0.6.4 then assume 0.6.4.0
 287   if [[ ${#lastVersionDigits[*]} -ne 4 ]]; then
 288     lastVersionDigits[3]=0
 289   fi
 290
 291   # if the new version is in the format 0.6.4 then assume 0.6.4.0
 292   if [[ ${#newVersionDigits[*]} -ne 4 ]]; then
 293     newVersionDigits[3]=0
 294   fi
 295
 296   # major
 297   if [[ ${newVersionDigits[0]} -lt ${lastVersionDigits[0]} ]]; then
 298     checkVersionIncrementingResult=1
 299     return
 300   fi
 301   if [[ ${newVersionDigits[0]} -gt ${lastVersionDigits[0]} ]]; then
 302     return
 303   fi
 304
 305   # minor
 306   if [[ ${newVersionDigits[1]} -lt ${lastVersionDigits[1]} ]]; then
 307     checkVersionIncrementingResult=1
 308     return
 309   fi
 310   if [[ ${newVersionDigits[1]} -gt ${lastVersionDigits[1]} ]]; then
 311     return
 312   fi
 313
 314   # micro
 315   if [[ ${newVersionDigits[2]} -lt ${lastVersionDigits[2]} ]]; then
 316     checkVersionIncrementingResult=1
 317     return
 318   fi
 319   if [[ ${newVersionDigits[2]} -gt ${lastVersionDigits[2]} ]]; then
 320     return
 321   fi
 322
 323   # patch level
 324   if [[ ${newVersionDigits[3]} -lt ${lastVersionDigits[3]} ]]; then
 325     checkVersionIncrementingResult=1
 326     return
 327   fi
 328   if [[ ${newVersionDigits[3]} -gt ${lastVersionDigits[3]} ]]; then
 329     return
 330   fi
 331
 332   # everything is equal
 333   if [[ ${allowEqualVersions} -eq 0 ]]; then
 334     checkVersionIncrementingResult=1
 335   fi
 336   return
 337 }
 338
 339
 340 #
 341 # Commit the current changes, allow an empty commit, or amend (when the commit
 342 # message is the same as that of the last commit)
 343 #
 344 # 1=non-zero to allow an empty commit
 345 # 2=commit message
 346 function commitChanges() {
 347   local -i allowEmpty=${1}
 348   local msg="$(stringTrim "${2}")"
 349
 350   local lastMsg="$(git log -1 --format="%s")"
 351   lastMsg="$(stringTrim "${lastMsg}")"
 352   local extra=""
 353   if [[ ${allowEmpty} -ne 0 ]]; then
 354     extra="${extra} --allow-empty"
 355   fi
 356   if [[ "${msg}" == "${lastMsg}" ]]; then
 357     extra="${extra} --amend"
 358   fi
 359   set +e
 360   git commit -s -q ${extra} -m "${msg}" &> /dev/null
 361   set -e
 362 }
 363
 364
 365 #
 366 # Get the version from the Makefile
 367 #
 368 function getVersionFromMakefile() {
 369   local src="Makefile"
 370   local regex="([[:space:]]*VERS[[:space:]]*=[[:space:]]*)${versionRegexSources}[[:space:]]*"
 371   grep -E "^${regex}\$" "${src}" | sed -r "s/^${regex}\$/\3/"
 372 }
 373
 374
 375 #
 376 # Update the version in all relevant files
 377 #
 378 # 1=the new version (in the format of versionRegexSources)
 379 function updateVersions() {
 380   local newVersion="$(stringTrim "${1}")"
 381
 382   #
 383   # Adjust debug settings in Makefile.inc
 384   #
 385   local src="Makefile.inc"
 386   sed -ri \
 387    -e 's/^[[:space:]]*DEBUG[[:space:]]*?=.*$/DEBUG ?= 1/' \
 388    -e 's/^[[:space:]]*NO_DEBUG_MESSAGES[[:space:]]*?=.*$/NO_DEBUG_MESSAGES ?= 0/' \
 389    "${src}"
 390   set +e
 391   git add "${src}"
 392   set -e
 393
 394
 395   #
 396   # Adjust version in Makefile
 397   #
 398   local src="Makefile"
 399   sed -ri "s/^([[:space:]]*VERS[[:space:]]*=[[:space:]]*)${versionRegexSources}[[:space:]]*\$/\1${newVersion}/" "${src}"
 400   set +e
 401   git add "${src}"
 402   set -e
 403
 404
 405   #
 406   # Adjust version in win32 gui installer
 407   #
 408   local src="gui/win32/Inst/installer.nsi"
 409   local grepStr="^([[:space:]]*MessageBox[[:space:]]+MB_YESNO[[:space:]]+\".+?[[:space:]]+olsr\.org[[:space:]]+)${versionRegexSources}([[:space:]]+.+?\"[[:space:]]+IDYES[[:space:]]+NoAbort)[[:space:]]*$"
 410   local replStr="\1${newVersion}\6"
 411   sed -ri "s/${grepStr}/${replStr}/" "${src}"
 412   set +e
 413   git add "${src}"
 414   set -e
 415
 416
 417   #
 418   # Adjust version in win32 gui front-end
 419   #
 420   local src="gui/win32/Main/Frontend.rc"
 421   local grepStr="^([[:space:]]*CAPTION[[:space:]]+\"olsr\.org[[:space:]]+Switch[[:space:]]+)${versionRegexSources}([[:space:]]*\")[[:space:]]*\$"
 422   local replStr="\1${newVersion}\6"
 423   sed -ri "s/${grepStr}/${replStr}/" "${src}"
 424   set +e
 425   git add "${src}"
 426   set -e
 427 }
 428
 429
 430 #
 431 # Sign a text file
 432 #
 433 # 1=the text file
 434 function signTextFile() {
 435   local txtFile="$(stringTrim "${1}")"
 436   gpg -u "$(git config --get user.name)" --clearsign "${txtFile}"
 437   mv "${txtFile}.asc" "${txtFile}"
 438 }
 439
 440
 441
 442
 443 # ##############################################################################
 444 # # Main
 445 # ##############################################################################
 446
 447 declare script="$(pathCanonicalPath "${0}")"
 448 declare scriptDir="$(dirname "${script}")"
 449 declare baseDir="$(dirname "${scriptDir}")"
 450
 451 cd "${baseDir}"
 452
 453 declare -i masterWasUpdated=0
 454
 455 #
 456 # Check the number of arguments
 457 #
 458 if [[ ${#} -lt 1 ]]; then
 459   echo "* Need at least 1 argument:"
 460   usage
 461   exit 1
 462 fi
 463
 464
 465 #
 466 # Get the mode and check it
 467 #
 468 declare mode="$(stringTrim "${1}")"
 469 shift 1
 470 if [[ ! "${mode}" == "${MODE_BRANCH}" ]] && \
 471    [[ ! "${mode}" == "${MODE_RELEASE}" ]]; then
 472   echo "* Wrong mode: ${mode}"
 473   usage
 474   exit 1
 475 fi
 476
 477
 478 #
 479 # Further mode/argument parsing
 480 #
 481 declare branchVersion=""
 482 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
 483   MODE_TXT="${MODE_BRANCH_TXT}"
 484   MODE_TXT_LOWER="${MODE_BRANCH_TXT_LOWER}"
 485
 486   #
 487   # Get the branch version to create
 488   #
 489   if [[ ${#} -ne 1 ]]; then
 490     echo "* Need the version to branch:"
 491     usage
 492     exit 1
 493   fi
 494   branchVersion="$(stringTrim "${1}")"
 495   shift 1
 496
 497   #
 498   # Check branch version
 499   #
 500   if [[ -z "$(echo "${branchVersion}" | grep -E "^${versionRegexDigitsBasic}\$")" ]]; then
 501     echo "* Version to branch ${branchVersion} has invalid format"
 502     echo "  Expected format is: 0.6.4"
 503     exit 1
 504   fi
 505 else
 506   MODE_TXT="${MODE_RELEASE_TXT}"
 507   MODE_TXT_LOWER="${MODE_RELEASE_TXT_LOWER}"
 508
 509   if [[ ${#} -ne 0 ]]; then
 510     echo "* Need no additional arguments."
 511     usage
 512     exit 1
 513   fi
 514 fi
 515
 516
 517 checkIsOlsrdGitCheckout
 518
 519 if [[ "${mode}" == "${MODE_RELEASE}" ]]; then
 520   checkGitSigningKeyIsConfigured
 521 fi
 522
 523 getPrevRelTag
 524 declare prevTagVersionDigits="$(getVersionDigitsFromReleaseTag "${prevRelTagVersion}")"
 525
 526
 527 #
 528 # Get the current branch and check that we're on a release branch (for the
 529 # release mode) or on the master branch (for the branch mode)
 530 #
 531 declare relBranch="$(git rev-parse --abbrev-ref HEAD)"
 532 declare relBranch="$(stringTrim "${relBranch}")"
 533 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
 534   if [[ -z "$(echo "${relBranch}" | grep -E "^master\$")" ]]; then
 535     echo "* You are not on the master branch"
 536     exit 1
 537   fi
 538   relBranch="release-${branchVersion}"
 539
 540   # check that the branch does not yet exist
 541   declare -i branchTestResult=0
 542   set +e
 543   git rev-parse --abbrev-ref "${relBranch}" &> /dev/null
 544   branchTestResult=${?}
 545   set -e
 546   if [[ ${branchTestResult} -eq 0 ]]; then
 547     echo "* Branch ${relBranch} already exists"
 548     exit 1
 549   fi
 550 else
 551   if [[ -z "$(echo "${relBranch}" | grep -E "^${relBranchRegex}\$")" ]]; then
 552     echo "* You are not on a release branch (format: release-0.6.4 or release-0.6.4.1)"
 553     exit 1
 554   fi
 555 fi
 556
 557
 558 #
 559 # Get the version to release from the current branch
 560 #
 561 declare relBranchVersionDigits=""
 562 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
 563   relBranchVersionDigits="${branchVersion}"
 564 else
 565   relBranchVersionDigits="$(echo "${relBranch}" | \
 566                             sed -r "s/${relBranchRegex}/\1/")"
 567   adjustBranchName
 568 fi
 569
 570 declare relTagVersion="v${relBranchVersionDigits}"
 571 declare relBranchVersionDigitsNextMicro="$(getNextVersionDigitsMicro "${relBranchVersionDigits}")"
 572 declare relBranchVersionDigitsNextPatchLevel="$(getNextVersionDigitsPatchLevel "${relBranchVersionDigits}")"
 573
 574
 575 #
 576 # Check that the version is incrementing
 577 #
 578 checkVersionIncrementing "${prevTagVersionDigits}" "${relBranchVersionDigits}" 0
 579 if [[ ${checkVersionIncrementingResult} -ne 0 ]]; then
 580   echo "* The new version ${relBranchVersionDigits} is not greater than the previous version ${prevTagVersionDigits}"
 581   exit 1
 582 fi
 583
 584
 585 #
 586 # When branching, check that the version is incrementing (allow equal versions),
 587 # w.r.t. the version in the Makefile
 588 #
 589 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
 590   declare currentMasterVersion="$(getVersionFromMakefile)"
 591   checkVersionIncrementing "${currentMasterVersion}" "${relBranchVersionDigits}" 1
 592   if [[ ${checkVersionIncrementingResult} -ne 0 ]]; then
 593     echo "* The new version ${relBranchVersionDigits} is not greater than the current version ${currentMasterVersion}"
 594     exit 1
 595   fi
 596 fi
 597
 598
 599 #
 600 # Confirm the branch/release
 601 #
 602 cat >&1 << EOF
 603
 604
 605 * All checks pass, ready to ${MODE_TXT_LOWER} ${relBranchVersionDigits}.
 606
 607   * The previous version found is: ${prevTagVersionDigits}
 608     Note: If this is not the version you were expecting, then maybe that
 609           version wasn't merged into this branch.
 610   * Continuing will DESTROY any modifications you currently have in your tree!
 611
 612 EOF
 613 read -p "Press [enter] to continue or CTRL-C to exit..."
 614 echo ""
 615 echo ""
 616
 617
 618 #
 619 # Clean up the checkout
 620 #
 621 echo "Cleaning the git checkout..."
 622 git clean -fdq
 623 git reset -q --hard
 624
 625
 626 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
 627   #
 628   # Update the versions for branch
 629   #
 630   echo "Updating the version to pre-${relBranchVersionDigits}..."
 631   updateVersions "pre-${relBranchVersionDigits}"
 632   commitChanges 1 "${MODE_TXT} ${relTagVersion}"
 633   masterWasUpdated=1
 634
 635   # create release branch
 636   echo "Creating the release branch ${relBranch}..."
 637   git branch "${relBranch}"
 638
 639
 640   #
 641   # Update the version to the next release
 642   #
 643   echo "Updating the version to pre-${relBranchVersionDigitsNextMicro}..."
 644   updateVersions "pre-${relBranchVersionDigitsNextMicro}"
 645   commitChanges 0 "Update version after ${MODE_TXT_LOWER} of ${relTagVersion}"
 646 else
 647   #
 648   # Update the versions for release
 649   #
 650   echo "Updating the version to ${relBranchVersionDigits}..."
 651   updateVersions "${relBranchVersionDigits}"
 652   commitChanges 1 "${MODE_TXT} ${relTagVersion}"
 653
 654
 655   #
 656   # Generate the changelog
 657   #
 658   echo "Generating the changelog..."
 659   declare src="CHANGELOG"
 660   declare dst="mktemp -q -p . -t "${src}.XXXXXXXXXX""
 661   cat > "${dst}" << EOF
 662 ${relBranchVersionDigits} -------------------------------------------------------------------
 663
 664 EOF
 665   git rev-list --pretty=short "${prevRelTagVersion}..HEAD" | \
 666     git shortlog -w80 -- >> "${dst}"
 667   cat "${src}" >> "${dst}"
 668   mv "${dst}" "${src}"
 669   set +e
 670   git add "${src}"
 671   set -e
 672   commitChanges 1 "${MODE_TXT} ${relTagVersion}"
 673
 674
 675   #
 676   # Tag the release
 677   #
 678   echo "Tagging ${relTagVersion}..."
 679   set +e
 680   git tag -d "${relTagVersion}" &> /dev/null
 681   set -e
 682   git tag -s -m "OLSRd release ${relBranchVersionDigits}" "${relTagVersion}"
 683
 684
 685   #
 686   # Update the version to the next release
 687   #
 688   echo "Updating the version to pre-${relBranchVersionDigitsNextPatchLevel}..."
 689   updateVersions "pre-${relBranchVersionDigitsNextPatchLevel}"
 690   commitChanges 1 "Update version after ${MODE_TXT_LOWER} of ${relTagVersion}"
 691
 692
 693   #
 694   # Update the version (on the master branch) to the next release
 695   #
 696   echo "Updating the version to pre-${relBranchVersionDigitsNextMicro} on the master branch..."
 697   git checkout -q master
 698   git clean -fdq
 699   git reset -q --hard
 700
 701   declare oldMasterVersion="$(getVersionFromMakefile)"
 702   declare newMasterVersion="${relBranchVersionDigitsNextMicro}"
 703   checkVersionIncrementing "${oldMasterVersion}" "${newMasterVersion}" 0
 704   if [[ ${checkVersionIncrementingResult} -ne 0 ]]; then
 705     echo "* Skipped updating the version on the master branch:"
 706     echo "  The new version ${newMasterVersion} is not greater than the previous version ${oldMasterVersion}"
 707   else
 708     updateVersions "pre-${relBranchVersionDigitsNextMicro}"
 709     commitChanges 0 "Update version after ${MODE_TXT_LOWER} of ${relTagVersion}"
 710     masterWasUpdated=1
 711   fi
 712
 713   git checkout -q "${relBranch}"
 714   git clean -fdq
 715   git reset -q --hard
 716
 717
 718   #
 719   # Make the release tarballs
 720   #
 721   echo "Generating the release tarballs..."
 722   declare tarFile="${scriptDir}/olsrd-${relBranchVersionDigits}.tar"
 723   declare tarGzFile="${tarFile}.gz"
 724   declare tarBz2File="${tarFile}.bz2"
 725   git archive --format=tar --prefix="olsrd-${relBranchVersionDigits}/" --output="${tarFile}" "${relTagVersion}"
 726   gzip   -c "${tarFile}" > "${tarGzFile}"
 727   bzip2  -c "${tarFile}" > "${tarBz2File}"
 728   rm -f "${tarFile}"
 729   echo "Generating the release tarball checksums..."
 730   declare md5File="${scriptDir}/MD5SUM-${relBranchVersionDigits}"
 731   declare sha256File="${scriptDir}/SHA256SUM-${relBranchVersionDigits}"
 732   md5sum    "${tarGzFile}" "${tarBz2File}" > "${md5File}"
 733   sha256sum "${tarGzFile}" "${tarBz2File}" > "${sha256File}"
 734   echo "Signing the release tarball checksums..."
 735   signTextFile "${md5File}"
 736   signTextFile "${sha256File}"
 737 fi
 738
 739
 740 echo "Done."
 741
 742
 743 echo ""
 744 echo ""
 745 echo "==================="
 746 echo "=   Git Updates   ="
 747 echo "==================="
 748 if [[ ${masterWasUpdated} -ne 0 ]]; then
 749   echo "Branch : master"
 750 fi
 751 echo "Branch : ${relBranch}"
 752 if [[ "${mode}" == "${MODE_RELEASE}" ]]; then
 753   echo "Tag    : ${relTagVersion}"
 754   echo ""
 755   echo ""
 756
 757
 758   echo "==================="
 759   echo "= Generated Files ="
 760   echo "==================="
 761   cat >&1 << EOF
 762 ${tarGzFile}
 763 ${tarBz2File}
 764 ${md5File}
 765 ${sha256File}"
 766 EOF
 767 fi
 768
 769
 770 echo ""
 771 echo ""
 772 echo "==================="
 773 echo "= Manual Actions  ="
 774 echo "==================="
 775 if [[ "${mode}" == "${MODE_RELEASE}" ]]; then
 776   echo "1. Check that everything is in order. For example, run:"
 777   if [[ ${masterWasUpdated} -ne 0 ]]; then
 778     echo "     gitk master ${relBranch} ${relTagVersion}"
 779   else
 780     echo "     gitk ${relBranch} ${relTagVersion}"
 781   fi
 782   echo "2. Push. For example, run:"
 783   if [[ ${masterWasUpdated} -ne 0 ]]; then
 784     echo "     git push origin master ${relBranch} ${relTagVersion}"
 785   else
 786     echo "     git push origin ${relBranch} ${relTagVersion}"
 787   fi
 788   echo "3. Upload the generated files to"
 789   echo "     http://www.olsr.org/releases/${relBranchVersionDigits}"
 790   echo "4. Add a release article on olsr.org."
 791   echo ""
 792 else
 793   echo "1. Check that everything is in order. For example, run:"
 794   if [[ ${masterWasUpdated} -ne 0 ]]; then
 795     echo "     gitk master ${relBranch}"
 796   else
 797     echo "     gitk ${relBranch}"
 798   fi
 799   echo "2. Push. For example, run:"
 800   if [[ ${masterWasUpdated} -ne 0 ]]; then
 801     echo "     git push origin master ${relBranch}"
 802   else
 803     echo "     git push origin ${relBranch}"
 804   fi
 805   echo "3. Send a 'release branch created' email to olsr-dev@lists.olsr.org."
 806   echo ""
 807 fi
 808