pud: use the correct field for padding
[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 declare scriptDirRel="${scriptDir#$baseDir/}"
494
495 cd "${baseDir}"
496
497 declare -i masterWasUpdated=0
498
499 #
500 # Check the number of arguments
501 #
502 if [[ ${#} -lt 1 ]]; then
503   echo "* Need at least 1 argument:"
504   usage
505   exit 1
506 fi
507
508
509 #
510 # Get the mode and check it
511 #
512 declare mode="$(stringTrim "${1}")"
513 shift 1
514 if [[ ! "${mode}" == "${MODE_BRANCH}" ]] && \
515    [[ ! "${mode}" == "${MODE_RELEASE}" ]]; then
516   echo "* Wrong mode: ${mode}"
517   usage
518   exit 1
519 fi
520
521
522 #
523 # Further mode/argument parsing
524 #
525 declare branchVersion=""
526 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
527   MODE_TXT="${MODE_BRANCH_TXT}"
528   MODE_TXT_LOWER="${MODE_BRANCH_TXT_LOWER}"
529
530   #
531   # Get the branch version to create
532   #
533   if [[ ${#} -ne 1 ]]; then
534     echo "* Need the version to branch:"
535     usage
536     exit 1
537   fi
538   branchVersion="$(stringTrim "${1}")"
539   shift 1
540
541   #
542   # Check branch version
543   #
544   if [[ -z "$(echo "${branchVersion}" | grep -E "^${versionRegexDigitsBasic}\$")" ]]; then
545     echo "* Version to branch ${branchVersion} has invalid format"
546     echo "  Expected format is: 0.6.4"
547     exit 1
548   fi
549 else
550   MODE_TXT="${MODE_RELEASE_TXT}"
551   MODE_TXT_LOWER="${MODE_RELEASE_TXT_LOWER}"
552
553   if [[ ${#} -ne 0 ]]; then
554     echo "* Need no additional arguments."
555     usage
556     exit 1
557   fi
558 fi
559
560
561 checkIsOlsrdGitCheckout
562
563 if [[ "${mode}" == "${MODE_RELEASE}" ]]; then
564   checkGitSigningKeyIsConfigured
565 fi
566
567 getPrevRelTag
568 declare prevTagVersionDigits="$(getVersionDigitsFromReleaseTag "${prevRelTagVersion}")"
569
570
571 #
572 # Get the current branch and check that we're on a release branch (for the
573 # release mode) or on the master branch (for the branch mode)
574 #
575 declare relBranch="$(git rev-parse --abbrev-ref HEAD)"
576 declare relBranch="$(stringTrim "${relBranch}")"
577 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
578   if [[ -z "$(echo "${relBranch}" | grep -E "^master\$")" ]]; then
579     echo "* You are not on the master branch"
580     exit 1
581   fi
582   relBranch="release-${branchVersion}"
583
584   # check that the branch does not yet exist
585   declare -i branchTestResult=0
586   set +e
587   git rev-parse --abbrev-ref "${relBranch}" &> /dev/null
588   branchTestResult=${?}
589   set -e
590   if [[ ${branchTestResult} -eq 0 ]]; then
591     echo "* Branch ${relBranch} already exists"
592     exit 1
593   fi
594 else
595   if [[ -z "$(echo "${relBranch}" | grep -E "^${relBranchRegex}\$")" ]]; then
596     echo "* You are not on a release branch (format: release-0.6.4 or release-0.6.4.1)"
597     exit 1
598   fi
599 fi
600
601
602 #
603 # Get the version to release from the current branch
604 #
605 declare relBranchVersionDigits=""
606 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
607   relBranchVersionDigits="${branchVersion}"
608 else
609   relBranchVersionDigits="$(echo "${relBranch}" | \
610                             sed -r "s/${relBranchRegex}/\1/")"
611   adjustBranchName
612 fi
613
614 declare relTagVersion="v${relBranchVersionDigits}"
615 declare relBranchVersionDigitsNextMicro="$(getNextVersionDigitsMicro "${relBranchVersionDigits}")"
616 declare relBranchVersionDigitsNextPatchLevel="$(getNextVersionDigitsPatchLevel "${relBranchVersionDigits}")"
617
618
619 #
620 # Check that the version is incrementing
621 #
622 checkVersionIncrementing "${prevTagVersionDigits}" "${relBranchVersionDigits}" 0
623 if [[ ${checkVersionIncrementingResult} -ne 0 ]]; then
624   echo "* The new version ${relBranchVersionDigits} is not greater than the previous version ${prevTagVersionDigits}"
625   exit 1
626 fi
627
628
629 #
630 # When branching, check that the version is incrementing (allow equal versions),
631 # w.r.t. the version in the Makefile
632 #
633 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
634   declare currentMasterVersion="$(getVersionFromMakefile)"
635   checkVersionIncrementing "${currentMasterVersion}" "${relBranchVersionDigits}" 1
636   if [[ ${checkVersionIncrementingResult} -ne 0 ]]; then
637     echo "* The new version ${relBranchVersionDigits} is not greater than the current version ${currentMasterVersion}"
638     exit 1
639   fi
640 fi
641
642
643 #
644 # Confirm the branch/release
645 #
646 cat >&1 << EOF
647
648
649 * All checks pass, ready to ${MODE_TXT_LOWER} ${relBranchVersionDigits}.
650
651   * The previous version found is: ${prevTagVersionDigits}
652     Note: If this is not the version you were expecting, then maybe that
653           version wasn't merged into this branch.
654   * Continuing will DESTROY any modifications you currently have in your tree!
655
656 EOF
657 read -p "Press [enter] to continue or CTRL-C to exit..."
658 echo ""
659 echo ""
660
661
662 #
663 # Clean up the checkout
664 #
665 echo "Cleaning the git checkout..."
666 git clean -fdq
667 git reset -q --hard
668
669
670 if [[ "${mode}" == "${MODE_BRANCH}" ]]; then
671   #
672   # Update the versions for branch
673   #
674   echo "Updating the version to pre-${relBranchVersionDigits}..."
675   updateVersions "pre-${relBranchVersionDigits}"
676   commitChanges 1 "${MODE_TXT} ${relTagVersion}"
677   masterWasUpdated=1
678
679   # create release branch
680   echo "Creating the release branch ${relBranch}..."
681   git branch "${relBranch}"
682
683
684   #
685   # Update the version to the next release
686   #
687   echo "Updating the version to pre-${relBranchVersionDigitsNextMicro}..."
688   updateVersions "pre-${relBranchVersionDigitsNextMicro}"
689   commitChanges 0 "Update version after ${MODE_TXT_LOWER} of ${relTagVersion}"
690 else
691   #
692   # Update the versions for release
693   #
694   echo "Updating the version to ${relBranchVersionDigits}..."
695   updateVersions "${relBranchVersionDigits}"
696   commitChanges 1 "${MODE_TXT} ${relTagVersion}"
697
698
699   #
700   # Generate the changelog
701   #
702   echo "Generating the changelog..."
703   declare src="CHANGELOG"
704   declare dst="$(mktemp -q -p . -t "${src}.XXXXXXXXXX")"
705
706   declare separatorLineNr="$(
707     grep -nhE ' -------------------------------------------------------------------+$' "$src" | \
708     head -1 | \
709     awk -F ':' '{print $1}'
710     )"
711
712   if [ -z "$separatorLineNr" ]; then
713     separatorLineNr="1"
714   fi
715
716   cat > "${dst}" << EOF
717 ${relBranchVersionDigits} -------------------------------------------------------------------
718
719 EOF
720
721   declare -i insertLineNr=$(( $separatorLineNr - 1 ))
722   head -$insertLineNr "$src" >> "$dst"
723
724   git rev-list --pretty=short "${prevRelTagVersion}..HEAD" | \
725     git shortlog -w80 -- >> "${dst}"
726
727   tail -n +$separatorLineNr "$src" >> "$dst"
728
729   mv "${dst}" "${src}"
730
731   set +e
732   git add "${src}"
733   set -e
734   commitChanges 1 "${MODE_TXT} ${relTagVersion}"
735
736
737   #
738   # Tag the release
739   #
740   echo "Tagging ${relTagVersion}..."
741   set +e
742   git tag -d "${relTagVersion}" &> /dev/null
743   set -e
744   git tag -s -m "OLSRd release ${relBranchVersionDigits}" "${relTagVersion}"
745
746
747   #
748   # Update the version to the next release
749   #
750   echo "Updating the version to pre-${relBranchVersionDigitsNextPatchLevel}..."
751   updateVersions "pre-${relBranchVersionDigitsNextPatchLevel}"
752   commitChanges 1 "Update version after ${MODE_TXT_LOWER} of ${relTagVersion}"
753
754
755   #
756   # Update the version (on the master branch) to the next release
757   #
758   echo "Updating the version to pre-${relBranchVersionDigitsNextMicro} on the master branch..."
759   git checkout -q master
760   git clean -fdq
761   git reset -q --hard
762
763   declare oldMasterVersion="$(getVersionFromMakefile)"
764   declare newMasterVersion="${relBranchVersionDigitsNextMicro}"
765   checkVersionIncrementing "${oldMasterVersion}" "${newMasterVersion}" 0
766   if [[ ${checkVersionIncrementingResult} -ne 0 ]]; then
767     echo "* Skipped updating the version on the master branch:"
768     echo "  The new version ${newMasterVersion} is not greater than the previous version ${oldMasterVersion}"
769   else
770     updateVersions "pre-${relBranchVersionDigitsNextMicro}"
771     commitChanges 0 "Update version after ${MODE_TXT_LOWER} of ${relTagVersion}"
772     masterWasUpdated=1
773   fi
774
775   git checkout -q "${relBranch}"
776   git clean -fdq
777   git reset -q --hard
778
779
780   #
781   # Make the release tarballs
782   #
783   echo "Generating the release tarballs..."
784   declare tarFile="olsrd-$relBranchVersionDigits.tar"
785   declare tarFileJava="olsrd-$relBranchVersionDigits-java.tar"
786   declare tarFileFull="olsrd-$relBranchVersionDigits-full.tar"
787
788   declare tarGzFile="$tarFile.gz"
789   declare tarGzFileJava="$tarFileJava.gz"
790   declare tarGzFileFull="$tarFileFull.gz"
791
792   declare tarBz2File="$tarFile.bz2"
793   declare tarBz2FileJava="$tarFileJava.bz2"
794   declare tarBz2FileFull="$tarFileFull.bz2"
795
796   mkdir -p "$scriptDir/$relBranchVersionDigits"
797
798   git archive \
799       --format=tar \
800       --prefix="olsrd-$relBranchVersionDigits/" \
801       --output="$scriptDir/$relBranchVersionDigits/$tarFile" \
802       "$relTagVersion"
803
804   git archive \
805       --format=tar \
806       --prefix="olsrd-$relBranchVersionDigits/" \
807       --output="$scriptDir/$relBranchVersionDigits/$tarFileJava" \
808       "$relTagVersion" \
809       "lib/info.java" \
810       "lib/pud/wireformat-java"
811
812   cp "$scriptDir/$relBranchVersionDigits/$tarFile" "$scriptDir/$relBranchVersionDigits/$tarFileFull"
813
814   pushd "$scriptDir/$relBranchVersionDigits" &> /dev/null
815
816   tar f "$tarFile" \
817       --delete "olsrd-$relBranchVersionDigits/lib/info.java" \
818       --delete "olsrd-$relBranchVersionDigits/lib/pud/wireformat-java"
819
820   gzip   -c "$tarFile" > "$tarGzFile"
821   gzip   -c "$tarFileJava" > "$tarGzFileJava"
822   gzip   -c "$tarFileFull" > "$tarGzFileFull"
823
824   bzip2  -c "$tarFile" > "$tarBz2File"
825   bzip2  -c "$tarFileJava" > "$tarBz2FileJava"
826   bzip2  -c "$tarFileFull" > "$tarBz2FileFull"
827
828   rm -f "$tarFile" "$tarFileJava" "$tarFileFull"
829
830   echo "Generating the release tarball checksums..."
831   declare md5File="MD5SUM-$relBranchVersionDigits"
832   declare sha256File="SHA256SUM-$relBranchVersionDigits"
833   md5sum    "$tarGzFile" "$tarGzFileJava" "$tarGzFileFull" "$tarBz2File" "$tarBz2FileJava" "$tarBz2FileFull" > "$md5File"
834   sha256sum "$tarGzFile" "$tarGzFileJava" "$tarGzFileFull" "$tarBz2File" "$tarBz2FileJava" "$tarBz2FileFull" > "$sha256File"
835
836   echo "Signing the release tarball checksums..."
837   signTextFile "$md5File"
838   signTextFile "$sha256File"
839
840   popd &> /dev/null
841 fi
842
843
844 echo "Done."
845
846
847 echo ""
848 echo ""
849 echo "==================="
850 echo "=   Git Updates   ="
851 echo "==================="
852 if [[ ${masterWasUpdated} -ne 0 ]]; then
853   echo "Branch : master"
854 fi
855 echo "Branch : ${relBranch}"
856 if [[ "${mode}" == "${MODE_RELEASE}" ]]; then
857   echo "Tag    : ${relTagVersion}"
858   echo ""
859   echo ""
860
861
862   echo "==================="
863   echo "= Generated Files ="
864   echo "==================="
865   cat >&1 << EOF
866 $scriptDirRel/$relBranchVersionDigits/$tarGzFile
867 $scriptDirRel/$relBranchVersionDigits/$tarGzFileJava
868 $scriptDirRel/$relBranchVersionDigits/$tarGzFileFull
869 $scriptDirRel/$relBranchVersionDigits/$tarBz2File
870 $scriptDirRel/$relBranchVersionDigits/$tarBz2FileJava
871 $scriptDirRel/$relBranchVersionDigits/$tarBz2FileFull
872 $scriptDirRel/$relBranchVersionDigits/$md5File
873 $scriptDirRel/$relBranchVersionDigits/$sha256File
874 EOF
875 fi
876
877
878 echo ""
879 echo ""
880 echo "==================="
881 echo "= Manual Actions  ="
882 echo "==================="
883 if [[ "${mode}" == "${MODE_RELEASE}" ]]; then
884   echo "1. Check that everything is in order. For example, run:"
885   if [[ ${masterWasUpdated} -ne 0 ]]; then
886     echo "     gitk master ${relBranch} ${relTagVersion}"
887   else
888     echo "     gitk ${relBranch} ${relTagVersion}"
889   fi
890   echo "2. Push. For example, run:"
891   if [[ ${masterWasUpdated} -ne 0 ]]; then
892     echo "     git push origin master ${relBranch} ${relTagVersion}"
893   else
894     echo "     git push origin ${relBranch} ${relTagVersion}"
895   fi
896   echo "3. Upload the generated files to"
897   echo "     http://www.olsr.org/releases/${relBranchVersionDigits}"
898   echo "4. Add a release article on olsr.org."
899   echo "5. Announce the release on the olsr-dev and olsr-users mailing lists."
900   echo ""
901 else
902   echo "1. Check that everything is in order. For example, run:"
903   if [[ ${masterWasUpdated} -ne 0 ]]; then
904     echo "     gitk master ${relBranch}"
905   else
906     echo "     gitk ${relBranch}"
907   fi
908   echo "2. Push. For example, run:"
909   if [[ ${masterWasUpdated} -ne 0 ]]; then
910     echo "     git push origin master ${relBranch}"
911   else
912     echo "     git push origin ${relBranch}"
913   fi
914   echo "3. Send a 'release branch created' email to olsr-dev@lists.olsr.org."
915   echo ""
916 fi
917