af41ead01c80025cdc417dca97895a8345858da3
[users/jgh/exim.git] / 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 :