release-process/scripts/mk_exim_release

   1 #!/usr/bin/env perl
   2 # Copyright (c) The Exim Maintainers 2016-2018
   3
   4 use strict;
   5 use warnings;
   6 use Carp;
   7 use Cwd qw'abs_path';
   8 use File::Basename;
   9 use File::Path qw(make_path remove_tree);
  10 use File::Temp;
  11 use Getopt::Long;
  12 use IO::File;
  13 use Pod::Usage;
  14 use Digest::SHA;
  15 use if $ENV{DEBUG} => 'Smart::Comments';
  16
  17 my $ME = basename $0;
  18
  19
  20 my $debug   = undef;
  21 my $verbose = 0;
  22
  23 # MAJOR.MINOR[.SECURITY[.FIXES]][-RCX]
  24 # 4    .90    .0        .22      -RC1
  25 my $version_pattern = qr/
  26     (?<release>
  27     (?<target_release>
  28            (?<major>\d)         # 4
  29          \.(?<minor>\d\d)       #  .90
  30       (?:\.(?<security>\d+)     #     .0
  31       (?:\.(?<fixes>)\d+)?)?    #       .22
  32     )                           # target-release ->|
  33        (?:-(?<rc>RC\d+)?)?      #          -RC1
  34     )
  35 /x;
  36
  37 my $quick_version_pattern = qr/
  38    (?<release>
  39    (?<last_tag>
  40            (?<major>\d)         # 4
  41          \.(?<minor>\d\d)       #  .90
  42       (?:\.(?<security>\d+)     #     .0
  43       (?:\.(?<fixes>)\d+)?)?    #       .22
  44    )                            # last-tag ->|
  45        (?:-(?<quick>\d+-g[[:xdigit:]]+))?     #  -3-gdeadbef
  46     )
  47 /x;
  48
  49 # ------------------------------------------------------------------
  50
  51 package Context {
  52     use strict;     # not strictly necessary yet, until in an own package
  53     use warnings;   # not strictly necessary yet, ...
  54     use File::Spec::Functions qw'splitpath catfile catdir splitdir';
  55     use File::Path qw'make_path remove_tree';
  56     use File::Copy;
  57     use Cwd qw'abs_path';
  58     use Carp;
  59
  60     package PWD {
  61         use Cwd;
  62         sub TIESCALAR { bless do {\my $x} }
  63         sub FETCH { cwd }
  64     }
  65
  66     tie my $cwd => 'PWD' or die;    # this returns the current dir now, dynamically
  67
  68     sub new {
  69         my $class = shift;
  70         return bless { @_ } => $class;
  71     }
  72
  73     sub check_version {
  74         my $context = shift;
  75         my $version = shift // 'HEAD';
  76
  77         #
  78         # v => {
  79         #   release =>                   4.92-RC4 |    4.92-27-gabcdef
  80         #   target_release|last_tag =>   4.92     |    4.92
  81         #
  82         #   major    =>  4
  83         #   minor    =>  92
  84         #   security =>
  85         #   fixes    =>
  86         #
  87         #   rc|quick =>   RC4 | 27-gabcdef
  88         #   }
  89
  90         if ($context->{quick}) {
  91             # Try to find suitable version description
  92             chomp(my $describe = do {   # we wrap it into a open() to avoid hassle with
  93                 open(my $fh, '-|',      # strange version descriptions
  94                     'git', describe => $version) or die;
  95                 <$fh>
  96                 } // exit 1);
  97             $describe =~ /$quick_version_pattern/;
  98
  99             %{$context->{v}} = %+;
 100             ($context->{commit}) = $version // ($context->{v}{quick} =~ /g([[:xdigit:]]+)/);
 101         }
 102         else {
 103             croak "The given version number does not look right - $version"
 104                 if not $version =~ /$version_pattern/;
 105             %{$context->{v}} = %+;
 106
 107             # find a valid vcs tag matching the version
 108             my $pattern = "$context->{pkgname}-$context->{v}{release}" =~ s/[-_.]/[-_.]/gr;
 109             chomp(my @tags = qx{git tag --list '$pattern'});
 110
 111             croak "The given version is ambigous, tags: @tags\n" if @tags > 1;
 112             croak "The given version does not exist (no such tag: exim-$version)\n" if @tags == 0;
 113
 114             $context->{commit} = $tags[0];
 115             # target_release: the release we aim to reach with release candidates
 116             # FIXME: re-construct from the parsed version number
 117         }
 118
 119         die "$ME: This script doesn't work for versions prior 4.92-RCx. "
 120            ."Please checkout an older version.\n"
 121             if $context->{v}{major} < 4
 122             or $context->{v}{major} == 4 && $context->{v}{minor} < 92;
 123
 124         ### v: $context->{v}
 125
 126     }
 127
 128
 129     # We prefer gtar to tar if gtar exists in $PATH
 130     sub override_tar_cmd {
 131         my $context = shift;
 132         my $tar = $context->{tar_cmd};
 133
 134         return unless $tar eq 'tar';
 135
 136         foreach my $d (File::Spec->path()) {
 137             my $p = catfile($d, 'gtar');
 138             if (-x $p) {
 139                 $context->{tar_cmd} = $p;
 140                 print "Switched tar command to: $p\n" if $verbose;
 141                 return;
 142             }
 143         }
 144     }
 145
 146     sub prepare_working_directory {
 147         my $context = shift;
 148         my $workspace = $context->{workspace};
 149
 150         if (not defined $workspace) {
 151             $workspace = $context->{workspace} = File::Temp->newdir(File::Spec->tmpdir . '/exim-packaging-XXXX');
 152         }
 153         else {
 154             # ensure the working directory is not in place
 155             if (-e $workspace) {
 156                 if ($context->{delete}) {
 157                     print "Deleting existing $workspace\n" if $verbose;
 158                     remove_tree $workspace, { verbose => $verbose || $debug };
 159                 }
 160                 else {
 161                     croak "Working directory $workspace exists" if -e $workspace;
 162                 }
 163             }
 164
 165             # create base directory
 166             make_path( $context->{directory}, { verbose => $verbose || $debug } );
 167         }
 168
 169         # Set(!) and create subdirectories
 170         foreach (qw(vcs_export pkg_tars pkg_trees tmp)) {   # {dookbook}
 171             make_path(
 172                 $context->{d}{$_} = catdir($workspace, $_),
 173                 { verbose => $verbose || $debug });
 174         }
 175     }
 176
 177     sub export_git_tree {
 178         my $context = shift;
 179
 180         # build git command
 181         my $archive_file = $context->{tmp_archive_file} = sprintf'%s/%s-%s.tar', $context->{d}{tmp}, $context->{pkgname}, $context->{v}{release};
 182         ### $archive_file
 183         my @cmd = ( 'git', 'archive', '--format=tar', "--output=$archive_file", $context->{commit} );
 184         ### @cmd
 185         # run git command
 186         print "[$cwd] Running: @cmd\n" if $verbose;
 187         0 == system @cmd or croak "Export failed";
 188     }
 189
 190     sub unpack_tree {
 191         # TODO: Why can't we combine the export_git_tree with the
 192         # unpack_tree function?
 193         my $context = shift;
 194
 195         ### $context
 196         die "Cannot see archive file\n" unless -f $context->{tmp_archive_file};
 197         my @cmd = ('tar',
 198             xf => $context->{tmp_archive_file},
 199             -C => $context->{d}{vcs_export} );
 200
 201         # run  command
 202         print "[$cwd] Running: @cmd\n" if $verbose;
 203         system @cmd and croak "Unpack failed\n";
 204
 205     }
 206
 207     sub make_version_script {
 208         my $context = shift;
 209
 210         #my $variant = substr( $context->{v}{release}, length($context->{v}{target_release}) );
 211         #if ( $context->{v}{release} ne $context->{v}{target_release} . $variant ) {
 212         #    die "Broken version numbering, I'm buggy";
 213         #}
 214
 215
 216         # Work
 217         if (not my $pid = fork // die "$ME: Cannot fork: $!\n") {
 218
 219             my $source_tree    = catdir($context->{d}{vcs_export}, 'src', 'src');
 220             ### $source_tree
 221
 222             chdir $source_tree or die "chdir $source_tree: $!\n";
 223
 224             croak "WARNING: version.sh already exists - leaving it in place\n"
 225                 if -f 'version.sh';
 226
 227             # Currently (25. Feb. 2016) the mk_exim_release.pl up to now can't
 228             # deal with security releases.!? So we need a current
 229             # mk_exim_release.pl. But if we use a current (master), the
 230             # reversion script returns wrong version info (it's running inside
 231             # the Git tree and uses git --describe, which always returns the
 232             # current version of master.) I do not want to change the old
 233             # reversion scripts (in 4.86.1, 4.85.1).
 234             #
 235             # Thus we've to provide the version.sh, based on the info we have
 236             # about the release. If reversion finds this, it doesn't try to find
 237             # it's own way to get a valid version number from the git.
 238             #
 239             # 4.89 series: the logic here did not handle _RC<N> thus breaking RC
 240             # status in versions.  nb: rc in context should be same as $variant
 241             # in local context.
 242
 243             #my $stamp = $context->{minor} ? '_'.$context->{minor} : '';
 244             #$stamp .= $context->{rc} if $context->{rc};
 245             my $release = $context->{v}{rc} ? $context->{v}{target_release}
 246                                             : $context->{v}{last_tag};
 247
 248             my $variant =
 249                   $context->{v}{rc} ? $context->{v}{rc}
 250                 : $context->{v}{quick} ? $context->{v}{quick}
 251                 : '';
 252
 253             print "[$cwd] create version.sh\n" if $verbose;
 254             open(my $v, '>', 'version.sh') or die "Can't open version.sh for writing: $!\n";
 255             print {$v} <<__;
 256 # initial version automatically generated by $0
 257 EXIM_RELEASE_VERSION=$release
 258 EXIM_VARIANT_VERSION=$variant
 259 EXIM_COMPILE_NUMBER=0
 260 # echo "[[[ \$EXIM_RELEASE_VERSION | \$EXIM_VARIANT_VERSION | \$EXIM_COMPILE_NUMBER ]]]"
 261 __
 262             close $v  or die "$0: Can not close $source_tree/version.h: $!\n";
 263             unlink 'version.h' or die "$ME: Can not unlink $source_tree/version.h: $!\n"
 264                 if -f 'version.h';
 265
 266             # Later, if we get the reversion script fixed, we can call it again.
 267             # For now (25. Feb. 2016) we'll leave it unused.
 268             #my @cmd = ('../scripts/reversion', 'release', $context->{commit});
 269
 270             my @cmd = ('../scripts/reversion', 'release');
 271             print "[$cwd] Running: @cmd\n" if $verbose;
 272             system(@cmd) and croak "reversion failed";
 273
 274             die "$ME: failed to create version.sh"
 275                 unless -f 'version.sh';
 276
 277             exit 0;
 278         }
 279         else {
 280             $pid == waitpid($pid, 0) or die "$0: waidpid: $!\n";
 281             exit $? >> 8 if $?;
 282         }
 283     }
 284
 285     sub build_documentation {
 286         my $context = shift;
 287         my $docdir = catdir $context->{d}{vcs_export}, 'doc', 'doc-docbook';
 288
 289         # documentation building does a chdir, so we'll do it in a
 290         # subprocess
 291         if (not my $pid = fork // die "$ME: Can't fork: $!\n") {
 292             chdir $docdir or die "$ME: Can't chdir to $docdir: $!\n";
 293             system('./OS-Fixups') == 0 or exit $?;
 294             exec $context->{make_cmd},
 295                 "EXIM_VER=$context->{v}{target_release}" .
 296                     ($context->{v}{rc} ? "-$context->{v}{rc}"
 297                         : $context->{v}{quick} ? "-$context->{v}{quick}"
 298                         : ''),
 299                     'everything';
 300             die "$ME: [$cwd] Cannot exec $context->{make_cmd}: $!\n";
 301         }
 302         else {
 303             waitpid($pid, 0);
 304             exit $? >> 8 if $?;
 305         }
 306
 307         $context->copy_docbook_files;
 308     }
 309
 310     sub copy_docbook_files {
 311         my $context = shift;
 312
 313         # where the generated docbook files can be found
 314         my $docdir = catdir $context->{d}{vcs_export}, 'doc', 'doc-docbook';
 315
 316         foreach ('spec.xml', 'filter.xml') {
 317             my $from = catfile $docdir, $_;
 318             my $to = catdir $context->{d}{tmp}; # {dookbook}
 319             copy $from => $to    or die $@;
 320         }
 321     }
 322
 323     sub build_html_documentation {
 324         my $context = shift;
 325
 326         # where the website docbook source dir is - push the generated
 327         # files there
 328         {
 329             my $webdir = catdir $context->{website_base}, 'docbook', $context->{v}{target_release};
 330             make_path $webdir, { verbose => $verbose || $debug };
 331             copy catfile($context->{d}{vcs_export}, 'doc', 'doc-docbook', $_)
 332                 => $webdir or die $@
 333                 for 'spec.xml', 'filter.xml';
 334         }
 335
 336         my $gen    = catfile $context->{website_base}, 'script/gen';
 337         my $outdir = catdir $context->{d}{pkg_trees}, "exim-html-$context->{v}{release}";
 338
 339         make_path $outdir, { verbose => $verbose || $debug };
 340
 341         my @cmd = (
 342             $gen,
 343             '--spec'    => catfile($context->{d}{tmp}, 'spec.xml'),     # {dookbook}
 344             '--filter'  => catfile($context->{d}{tmp}, 'filter.xml'),   # {dookbok}
 345             '--latest'  => $context->{v}{target_release},
 346             '--docroot' => $outdir,
 347             '--localstatic',
 348             ($verbose || $debug ? '--verbose' : ()),
 349         );
 350
 351         print "[$cwd] Executing @cmd\n";
 352         0 == system @cmd or exit $? >> 8;
 353
 354     }
 355
 356     sub sign {
 357         my $context = shift;
 358         foreach my $tar (glob "$context->{d}{pkg_tars}/*") {
 359             system gpg =>
 360             '--quiet', '--batch',
 361             defined $context->{gpg}{key}
 362                 ? ('--local-user' => $context->{gpg}{key})
 363                 : (),
 364             '--detach-sig', '--armor', $tar;
 365         }
 366     }
 367
 368     sub move_to_outdir {
 369         my $context = shift;
 370         make_path $context->{OUTDIR}, { verbose => $verbose || $debug };
 371         move $_ => $context->{OUTDIR} or die $@
 372             for glob "$context->{d}{pkg_tars}/*";
 373     }
 374
 375     sub build_src_package_directory {
 376         my $context = shift;
 377
 378         # build the exim package directory path
 379         $context->{d}{src} = catdir $context->{d}{pkg_trees}, "exim-$context->{v}{release}";
 380
 381         # initially we move the exim-src directory to the new directory name
 382         move
 383             catdir( $context->{d}{vcs_export}, 'src')
 384             => $context->{d}{src}
 385         or croak "Move of src dir failed - $!";
 386
 387         # add Local subdirectory
 388         make_path( catdir( $context->{d}{src}, 'Local' ), { verbose => $verbose || $debug } );
 389
 390         # now add the text docs
 391         $context->move_text_docs_into_pkg;
 392     }
 393
 394     sub build_doc_packages_directory {
 395         my $context = shift;
 396
 397         ##foreach my $format (qw/pdf postscript texinfo info/) {
 398         foreach my $format (qw/pdf postscript/) {
 399             my $target = catdir $context->{d}{pkg_trees}, "exim-$format-$context->{v}{release}", 'doc';
 400             make_path( $target, { verbose => $verbose || $debug } );
 401
 402             # move documents across
 403             foreach my $file (
 404                 glob(
 405                     catfile(
 406                         $context->{d}{vcs_export},
 407                         'doc',
 408                         'doc-docbook',
 409                         (
 410                             ( $format eq 'postscript' )
 411                             ? '*.ps'
 412                             : ( '*.' . $format )
 413                         )
 414                     )
 415                 )
 416             )
 417             {
 418                 move( $file, catfile( $target, ( splitpath($file) )[2] ) );
 419             }
 420         }
 421     }
 422
 423     sub move_text_docs_into_pkg {
 424         my $context = shift;
 425
 426         my $old_docdir = catdir( $context->{d}{vcs_export}, 'doc', 'doc-docbook' );
 427         my $old_txtdir = catdir( $context->{d}{vcs_export}, 'doc', 'doc-txt' );
 428         my $new_docdir = catdir( $context->{d}{src}, 'doc' );
 429         make_path( $new_docdir, { verbose => $verbose || $debug } );
 430
 431         # move generated documents from docbook stuff
 432         foreach my $file (qw/exim.8 spec.txt filter.txt/) {
 433             die "Empty file \"$file\"\n" if -z catfile( $old_docdir, $file );
 434             move( catfile( $old_docdir, $file ), catfile( $new_docdir, $file ) );
 435         }
 436
 437         # move text documents across
 438         foreach my $file ( glob( catfile( $old_txtdir, '*' ) ) ) {
 439
 440             # skip a few we dont want
 441             my $fn = ( splitpath($file) )[2];
 442             next
 443             if ( ( $fn eq 'ABOUT' )
 444                 || ( $fn eq 'ChangeLog.0' )
 445                 || ( $fn eq 'test-harness.txt' )
 446                 # Debian issue re licensing of RFCs
 447                 || ( $fn =~ /^draft-ietf-.*/ )
 448                 || ( $fn =~ /^rfc.*/ )
 449                 );
 450             move( $file, catfile( $new_docdir, $fn ) );
 451         }
 452     }
 453
 454     sub create_tar_files {
 455         my $context = shift;
 456
 457         my $pkg_tars    = $context->{d}{pkg_tars};
 458         my $pkg_trees = $context->{d}{pkg_trees};
 459         my $tar     = $context->{tar_cmd};
 460         if ($verbose) {
 461             foreach my $c (keys %{ $context->{compressors} }) {
 462                 print "Compression: $c\t$context->{compressors}{$c}\n";
 463             }
 464         }
 465
 466         # We ideally do not want local system user information in release tarballs;
 467         # those are artifacts of use of tar for backups and have no place in
 468         # software release packaging; if someone extracts as root, then they should
 469         # get sane file ownerships.
 470         my @ownership = (
 471             '--owner' => $context->{tar_perms}{user},
 472             '--group' => $context->{tar_perms}{group},
 473             # on this GNU tar, --numeric-owner works during creation too
 474             '--numeric-owner'
 475         ) if qx/tar --help 2>&1/ =~ /^\s*--owner=/m;
 476
 477         # See also environment variables set in main, tuning compression levels
 478         my %COMPRESSION = (
 479             gzip  => { extension => 'gz',  flags => '--gzip' },
 480             bzip2 => { extension => 'bz2', flags => '--bzip2' },
 481             lzip  => { extension => 'lz',  flags => '--lzip' },
 482             xz    => { extension => 'xz',  flags => '--xz' },
 483         );
 484
 485
 486         my (%size, %sha256);
 487
 488         foreach my $dir ( glob( catdir( $pkg_trees, ( 'exim*-' . $context->{v}{release} ) ) ) ) {
 489             my $dirname = ( splitdir($dir) )[-1];
 490             foreach my $comp (keys %COMPRESSION) {
 491                 next unless $context->{compressors}{$comp};
 492
 493                 my $basename = "$dirname.tar.$COMPRESSION{$comp}{extension}";
 494                 my $outfile = catfile $pkg_tars, $basename;
 495
 496                 print "Creating: $outfile\n" if $verbose || $debug;
 497                 0 == system($tar,
 498                     cf => $outfile,
 499                         $COMPRESSION{$comp}{flags},
 500                         @ownership, -C => $pkg_trees, $dirname)
 501                     or exit $? >> 8;
 502
 503                 # calculate size and md5sum
 504                 $size{$basename} = -s $outfile;
 505                 $sha256{$basename} = do {
 506                     my $sha = Digest::SHA->new(256);
 507                     $sha->addfile($outfile);
 508                     $sha->hexdigest;
 509                 };
 510             }
 511         }
 512
 513         # write the sizes file
 514         if ($context->{sizes}) {
 515             open my $sizes, '>', $_ = catfile $pkg_tars, 'sizes.txt'
 516                 or die "$ME: Can't open `$_': $!\n";
 517
 518             print $sizes join "\n",
 519                 (map { "SIZE($_) = $size{$_}" } sort keys %size),
 520                 (map { "SHA256($_) = $sha256{$_}" } sort keys %sha256);
 521
 522             close($sizes) or die "$ME: Can't close $_: $!\n";
 523         }
 524     }
 525
 526     sub do_cleanup {
 527         my $context = shift;
 528
 529         print "Cleaning up\n" if $verbose;
 530         remove_tree $context->{d}{tmp}, { verbose => $verbose || $debug };
 531     }
 532
 533 }
 534
 535 MAIN: {
 536
 537     # some of these settings are useful only if we're in the
 538     # exim-projekt-root, but the check, if we're, is deferred
 539     my $context = Context->new(
 540         pkgname     => 'exim',
 541         website_base => abs_path('../exim-website'),
 542         tar_cmd     => 'tar',
 543         tar_perms   => {
 544                 user    => '0',
 545                 group   => '0',
 546         },
 547         make_cmd    => 'make',  # for 'make'ing the docs
 548         sizes       => 1,
 549         compressors => {
 550                 gzip    => 1,
 551                 bzip2   => 1,
 552                 xz      => 1,
 553                 lzip    => 0,
 554         },
 555         docs         => 1,
 556         web          => 1,
 557         delete       => 0,
 558         cleanup      => 1,
 559         gpg => {
 560             sign         => 1,
 561             key          => undef,
 562         },
 563         quick => 0,
 564     );
 565
 566     ##$ENV{'PATH'} = '/opt/local/bin:' . $ENV{'PATH'};
 567     # We are creating files for mass distribution, so work harder to make smaller files.
 568     $ENV{GZIP} = -9;
 569     $ENV{BZIP2} = -9;
 570     # xz documents minimum file sizes for levels higher than -6 to be useful and each
 571     # requires more RAM on the decompressing system.  Exim tarball currently 24MiB so
 572     # using -8.
 573     $ENV{XZ_DEFAULTS} = -8;
 574
 575     GetOptions(
 576         $context,
 577         qw(workspace|tmp=s website_base|webgen_base=s tar_cmd|tar-cmd=s make_cmd|make-cmd=s
 578            docs|build-docs! web|build-web! sizes!
 579            delete! cleanup! quick|quick-release! minimal),
 580         'sign!'         => \$context->{gpg}{sign},
 581         'key=s'         => \$context->{gpg}{key},
 582         'lzip!'         => \$context->{compressors}{lzip},
 583         'verbose!'      => \$verbose,
 584         'debug:s'       => \$debug,
 585         'quick'         => sub { $context->{web}--; $context->{quick} = 1 },
 586         'help|?'        => sub { pod2usage(-verbose => 1, -exit => 0) },
 587         'man!'          => sub { pod2usage(-verbose => 2, -exit => 0, -noperldoc => system('perldoc -V >/dev/null 2>&1')) },
 588     ) and (@ARGV == 2 or ($context->{quick} and @ARGV >= 1))
 589         or pod2usage;
 590
 591     -f '.exim-project-root'
 592         or die "$ME: please call this script from the root of the Exim project sources\n";
 593
 594     $context->{OUTDIR} = pop @ARGV;
 595
 596     if ($context->{gpg}{sign}) {
 597         $context->{gpg}{key} //= do { chomp($_ = qx/git config user.signingkey/); $_ }
 598             || $ENV{EXIM_KEY}
 599             || do {
 600                 warn "$ME: No GPG key, using default\n";
 601                 undef;
 602             }
 603     }
 604
 605
 606     warn "$ME: changed umask to 022\n" if umask(022) != 022;
 607
 608     $context->check_version(shift); # may be undef for a quick release
 609
 610     if ($debug//'' eq 'version') {
 611         for (sort keys %{$context->{v}}) {
 612             print "version $_: $context->{v}{$_}\n";
 613         }
 614         print "git commit: $context->{commit}\n";
 615         exit 0;
 616     }
 617     $context->override_tar_cmd;
 618     $context->prepare_working_directory;
 619     $context->export_git_tree;
 620     $context->unpack_tree;
 621     $context->make_version_script;
 622
 623     $context->build_documentation if $context->{docs};
 624     $context->build_html_documentation if $context->{docs} && $context->{web};
 625
 626     $context->build_src_package_directory;
 627     $context->build_doc_packages_directory if $context->{docs};
 628
 629     $context->create_tar_files;
 630     $context->sign if $context->{gpg}{sign};
 631     $context->move_to_outdir;
 632     $context->do_cleanup if $context->{cleanup};
 633
 634     ### $context
 635 }
 636
 637 1;
 638
 639 __END__
 640
 641 =head1 NAME
 642
 643 mk_exim_release - Build an exim release
 644
 645 =head1 SYNOPSIS
 646
 647  mk_exim_release [options] version PKG-DIRECTORY
 648  mk_exim_release [options] --quick [version] PKG-DIRECTORY
 649
 650 =head1 DESCRIPTION
 651
 652 B<mk_exim_release> builds an exim release.
 653
 654 Starting in a populated git repo that has already been tagged for
 655 release it builds docs, packages etc.  Parameter is the version number
 656 to build as - ie 4.72 4.72-RC1, 4.86.1, etc, without any prefix.
 657
 658 This scripts expects to find a tag "exim-<version>".
 659
 660 After creating the release files, they should be signed. There is another
 661 helper for creating the signatures:
 662 F<release-process/scripts/sign_exim_packages>.
 663
 664 Call B<mk_exim_release> about like this:
 665
 666     release-process/scripts/mk_exim_release 4.99 OUT-DIR
 667
 668
 669 =head1 OPTIONS
 670
 671 =over 4
 672
 673 =item B<--[no]cleanup>
 674
 675 Do (or do not) cleanup the tmp directory at exit (default: do cleanup)
 676
 677 =item B<--debug[=I<item>]>
 678
 679 Forces debug mode. If (default: no debug info)
 680
 681 =over 4
 682
 683 =item item: B<version>
 684
 685 Output the parsed/found version number and exit.
 686
 687 =back
 688
 689 =item B<--[no]delete>
 690
 691 Delete a pre-existing tmp- and package-directory at start. (default: don't delete)
 692
 693 =item B<--[no]doc>
 694
 695 Do (not) build the documentation. This needs C<gnu-make> (default: build the docs)
 696
 697 =item B<--[no]help>
 698
 699 Display short help and exit cleanly. (default: don't do that)
 700
 701 =item B<--key> I<GPG key>
 702
 703 Use this GPG key for signing. If nothing is specified the first one of this list
 704 is used:
 705
 706 =over 8
 707
 708 =item - git config user.signingkey
 709
 710 =item - environment C<EXIM_KEY>
 711
 712 =item - default GPG key
 713
 714 =back
 715
 716 =item B<--[no]lzip>
 717
 718 Control the creation of B<lzip> tarballs. (default: do not use lzip)
 719
 720 =item B<--make-cmd> I<cmd>
 721
 722 Force the use of a specific C<make> command. This may be necessary if C<make> is not
 723 C<gmake>. This is necessary to build the docs. (default: C<make>)
 724
 725 =item B<--[no]man>
 726
 727 Display man page and exit cleanly. (default: don't do that)
 728
 729 =item B<--quick>
 730
 731 Create a quick release. The I<version> mandatory argument needs to be a git commit-ish.
 732 (try I<master> or I<HEAD> or similar). This mode switches off the
 733 website creation (which can be enabled by B<--web> again).
 734
 735 =item B<--[no]sign>
 736
 737 Sign the created archive files (and the sizes.txt). (default: sign)
 738
 739 =item B<--[no]sizes>
 740
 741 Write the sizes information to F<sizes.txt>. (default: write sizes)
 742
 743 =item B<--tar-cmd> I<cmd>
 744
 745 Use to override the path to the C<tar> command.  Need GNU tar in case
 746 I<lzip> is selected. (default: C<gtar>, if not found, use C<tar>)
 747
 748 =item B<--tmpdir> I<dir>
 749
 750 Change the name of the tmp directory (default: temporary directory)
 751
 752 =item B<--verbose>
 753
 754 Force verbose mode. (default: no verbosity)
 755
 756 =item B<--[no]web>
 757
 758 Control the creation of the website. For creation of the website, the F<../exim-website>
 759 (but see the B<website-base> option) directory must exist. (default: create the website, except when
 760 in B<quick> mode)
 761
 762 =item B<--website-base> I<dir>
 763
 764 Base directory for the web site generation (default: F<../exim-website>)
 765
 766 =item B<-workspace>|B<--tmp> I<directory>
 767
 768 During release gerneration temporary storage is necessary. (default: F<exim-packaging-XXXX>
 769 under your system's default temporary directory (typically this is F</tmp>)).
 770
 771 =back
 772
 773 =head1 AUTHOR
 774
 775 Nigel Metheringham <Nigel.Metheringham@dev.intechnology.co.uk>,
 776 some changes by Heiko Schlittermann <hs@schlittermann.de>
 777
 778 =head1 COPYRIGHT
 779
 780 Copyright 2010-2016 Exim Maintainers. All rights reserved.
 781
 782 =cut
 783 # vim: set sw=4 et :