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