git://git.exim.org / exim.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Testsuite: debug output changes resulting
[exim.git] / release-process / scripts / mk_exim_release
diff --git a/release-process/scripts/mk_exim_release b/release-process/scripts/mk_exim_release
index 2adcd3a83e804441c1b7e215ba5188f0589918de..ed075b42bde4906c976af28a096862353b1bbcf5 100755 (executable)
--- a/release-process/scripts/mk_exim_release
+++ b/release-process/scripts/mk_exim_release
@@ -1,5 +1,5 @@
 #!/usr/bin/env perl
 #!/usr/bin/env perl
-# Copyright (c) The Exim Maintainers 2016-2018
+# Copyright (c) The Exim Maintainers 2016 - 2023
 
 use strict;
 use warnings;
 
 use strict;
 use warnings;
@@ -12,26 +12,41 @@ use Getopt::Long;
 use IO::File;
 use Pod::Usage;
 use Digest::SHA;
 use IO::File;
 use Pod::Usage;
 use Digest::SHA;
+use feature 'state';
 use if $ENV{DEBUG} => 'Smart::Comments';
 
 my $ME = basename $0;
 
 
 use if $ENV{DEBUG} => 'Smart::Comments';
 
 my $ME = basename $0;
 
 
-my $debug   = 0;
+my $debug   = undef;
 my $verbose = 0;
 
 # MAJOR.MINOR[.SECURITY[.FIXES]][-RCX]
 # 4    .90    .0        .22      -RC1
 my $version_pattern = qr/
     (?<release>
 my $verbose = 0;
 
 # MAJOR.MINOR[.SECURITY[.FIXES]][-RCX]
 # 4    .90    .0        .22      -RC1
 my $version_pattern = qr/
     (?<release>
+    (?<target_release>
            (?<major>\d)         # 4
            (?<major>\d)         # 4
-         \.(?<minor>\d\d)       #  .90
+         \.(?<minor>\d+)        #  .90 or .105
       (?:\.(?<security>\d+)     #     .0
       (?:\.(?<fixes>)\d+)?)?    #       .22
       (?:\.(?<security>\d+)     #     .0
       (?:\.(?<fixes>)\d+)?)?    #       .22
+    )                           # target-release ->|
        (?:-(?<rc>RC\d+)?)?      #          -RC1
     )
 /x;
 
        (?:-(?<rc>RC\d+)?)?      #          -RC1
     )
 /x;
 
+my $quick_version_pattern = qr/
+   (?<release>
+   (?<last_tag>
+           (?<major>\d)         # 4
+         \.(?<minor>\d+)        #  .90 or .105
+      (?:\.(?<security>\d+)     #     .0
+      (?:\.(?<fixes>)\d+)?)?    #       .22
+   )                            # last-tag ->|
+       (?:-(?<quick>\d+-g[[:xdigit:]]+))?     #  -3-gdeadbef
+    )
+/x;
+
 # ------------------------------------------------------------------
 
 package Context {
 # ------------------------------------------------------------------
 
 package Context {
@@ -49,7 +64,7 @@ package Context {
         sub FETCH { cwd }
     }
 
         sub FETCH { cwd }
     }
 
-    tie my $cwd => 'PWD' or die;
+    tie my $cwd => 'PWD' or die;    # this returns the current dir now, dynamically
 
     sub new {
         my $class = shift;
 
     sub new {
         my $class = shift;
@@ -58,35 +73,70 @@ package Context {
 
     sub check_version {
         my $context = shift;
 
     sub check_version {
         my $context = shift;
-        my $version = shift;
+        my $version = shift // 'HEAD';
+
+        #
+        # v => {
+        #   release =>                   4.92-RC4 |    4.92-27-gabcdef
+        #   target_release|last_tag =>   4.92     |    4.92
+        #
+        #   major    =>  4
+        #   minor    =>  92
+        #   security =>
+        #   fixes    =>
+        #
+        #   rc|quick =>   RC4 | 27-gabcdef
+        #   }
+
+        #
+        # v => {
+        #   release =>                   4.92-RC4 |    4.92-27-gabcdef-dirty
+        #   target_release|last_tag =>   4.92     |    4.92
+        #
+        #   major    =>  4
+        #   minor    =>  92
+        #   security =>
+        #   fixes    =>
+        #
+        #   rc|quick =>   RC4 | 27-gabcdef-dirty
+        #   }
+
+        if ($context->{quick}) {
+            # Try to find suitable version description
+            chomp(my $describe = do {   # we wrap it into a open() to avoid hassle with
+                open(my $fh, '-|',      # strange version descriptions
+                    'git', describe => $version) or die;
+                <$fh>
+                } // exit 1);
+            $describe =~ /$quick_version_pattern/;
+
+            %{$context->{v}} = %+;
+            ($context->{commit}) = $version // ($context->{v}{quick} =~ /g([[:xdigit:]]+)/);
+        }
+        else {
+            croak "The given version number does not look right - $version"
+                if not $version =~ /$version_pattern/;
+            %{$context->{v}} = %+;
 
 
-        croak "The given version number does not look right - $version"
-            if not $version =~ /$version_pattern/;
+            # find a valid vcs tag matching the version
+            my $pattern = "$context->{pkgname}-$context->{v}{release}" =~ s/[-_.]/[-_.]/gr;
+            chomp(my @tags = qx{git tag --list '$pattern'});
 
 
-        $context->{v}{release}  = $+{release};
-        $context->{v}{major} = $+{major};
-        $context->{v}{minor} = $+{minor};
-        $context->{v}{security} = $+{security};
-        $context->{v}{rc} = $+{rc};
+            croak "The given version is ambigous, tags: @tags\n" if @tags > 1;
+            croak "The given version does not exist (no such tag: exim-$version)\n" if @tags == 0;
+
+            $context->{commit} = $tags[0];
+            # target_release: the release we aim to reach with release candidates
+            # FIXME: re-construct from the parsed version number
+        }
 
 
-        die "$ME: This script doesn't work for versions prior 4.92-RCx. Please checkout an older version.\n"
+        die "$ME: This script doesn't work for versions prior 4.92-RCx. "
+           ."Please checkout an older version.\n"
             if $context->{v}{major} < 4
             or $context->{v}{major} == 4 && $context->{v}{minor} < 92;
 
         ### v: $context->{v}
 
             if $context->{v}{major} < 4
             or $context->{v}{major} == 4 && $context->{v}{minor} < 92;
 
         ### v: $context->{v}
 
-        # find a valid vcs tag matching the version
-        my $pattern = "$context->{pkgname}-$context->{v}{release}" =~ s/[-_.]/[-_.]/gr;
-        chomp(my @tags = qx{git tag --list '$pattern'});
-
-        croak "The given version is ambigous, tags: @tags\n" if @tags > 1;
-        croak "The given version does not exist (no such tag: exim-$version)\n" if @tags == 0;
-
-        $context->{git_tag} = $tags[0];
-
-        # target_release: the release we aim to reach with release candidates
-        # FIXME: re-construct from the parsed version number
-        ($context->{v}{target_release} = $context->{v}{release}) =~ s/-RC\d+//;
     }
 
 
     }
 
 
@@ -112,7 +162,9 @@ package Context {
         my $workspace = $context->{workspace};
 
         if (not defined $workspace) {
         my $workspace = $context->{workspace};
 
         if (not defined $workspace) {
-            $workspace = $context->{workspace} = File::Temp->newdir(File::Spec->tmpdir . '/exim-packaging-XXXX');
+            $workspace = $context->{workspace} = File::Temp->newdir(
+                TEMPLATE => File::Spec->tmpdir . '/exim-packaging-XXXX',
+                CLEANUP  => $context->{cleanup});
         }
         else {
             # ensure the working directory is not in place
         }
         else {
             # ensure the working directory is not in place
@@ -144,7 +196,7 @@ package Context {
         # build git command
         my $archive_file = $context->{tmp_archive_file} = sprintf'%s/%s-%s.tar', $context->{d}{tmp}, $context->{pkgname}, $context->{v}{release};
         ### $archive_file
         # build git command
         my $archive_file = $context->{tmp_archive_file} = sprintf'%s/%s-%s.tar', $context->{d}{tmp}, $context->{pkgname}, $context->{v}{release};
         ### $archive_file
-        my @cmd = ( 'git', 'archive', '--format=tar', "--output=$archive_file", $context->{git_tag} );
+        my @cmd = ( 'git', 'archive', '--format=tar', "--output=$archive_file", $context->{commit} );
         ### @cmd
         # run git command
         print "[$cwd] Running: @cmd\n" if $verbose;
         ### @cmd
         # run git command
         print "[$cwd] Running: @cmd\n" if $verbose;
@@ -185,7 +237,6 @@ package Context {
 
             chdir $source_tree or die "chdir $source_tree: $!\n";
 
 
             chdir $source_tree or die "chdir $source_tree: $!\n";
 
-
             croak "WARNING: version.sh already exists - leaving it in place\n"
                 if -f 'version.sh';
 
             croak "WARNING: version.sh already exists - leaving it in place\n"
                 if -f 'version.sh';
 
@@ -207,13 +258,19 @@ package Context {
 
             #my $stamp = $context->{minor} ? '_'.$context->{minor} : '';
             #$stamp .= $context->{rc} if $context->{rc};
 
             #my $stamp = $context->{minor} ? '_'.$context->{minor} : '';
             #$stamp .= $context->{rc} if $context->{rc};
-            my $variant = $context->{v}{rc} // '';
+            my $release = $context->{quick} ? $context->{v}{last_tag}
+                                            : $context->{v}{target_release};
+
+            my $variant =
+                  $context->{v}{rc} ? $context->{v}{rc}
+                : $context->{v}{quick} ? $context->{v}{quick}
+                : '';
 
             print "[$cwd] create version.sh\n" if $verbose;
             open(my $v, '>', 'version.sh') or die "Can't open version.sh for writing: $!\n";
             print {$v} <<__;
 # initial version automatically generated by $0
 
             print "[$cwd] create version.sh\n" if $verbose;
             open(my $v, '>', 'version.sh') or die "Can't open version.sh for writing: $!\n";
             print {$v} <<__;
 # initial version automatically generated by $0
-EXIM_RELEASE_VERSION=$context->{v}{target_release}
+EXIM_RELEASE_VERSION=$release
 EXIM_VARIANT_VERSION=$variant
 EXIM_COMPILE_NUMBER=0
 # echo "[[[ \$EXIM_RELEASE_VERSION | \$EXIM_VARIANT_VERSION | \$EXIM_COMPILE_NUMBER ]]]"
 EXIM_VARIANT_VERSION=$variant
 EXIM_COMPILE_NUMBER=0
 # echo "[[[ \$EXIM_RELEASE_VERSION | \$EXIM_VARIANT_VERSION | \$EXIM_COMPILE_NUMBER ]]]"
@@ -224,7 +281,7 @@ __
 
             # Later, if we get the reversion script fixed, we can call it again.
             # For now (25. Feb. 2016) we'll leave it unused.
 
             # Later, if we get the reversion script fixed, we can call it again.
             # For now (25. Feb. 2016) we'll leave it unused.
-            #my @cmd = ('../scripts/reversion', 'release', $context->{git_tag});
+            #my @cmd = ('../scripts/reversion', 'release', $context->{commit});
 
             my @cmd = ('../scripts/reversion', 'release');
             print "[$cwd] Running: @cmd\n" if $verbose;
 
             my @cmd = ('../scripts/reversion', 'release');
             print "[$cwd] Running: @cmd\n" if $verbose;
@@ -251,10 +308,8 @@ __
             chdir $docdir or die "$ME: Can't chdir to $docdir: $!\n";
             system('./OS-Fixups') == 0 or exit $?;
             exec $context->{make_cmd},
             chdir $docdir or die "$ME: Can't chdir to $docdir: $!\n";
             system('./OS-Fixups') == 0 or exit $?;
             exec $context->{make_cmd},
-                "EXIM_VER=$context->{v}{target_release}" .
-                    ($context->{v}{rc} ? "-$context->{v}{rc}" : ''),
-                    'everything';
-            die "$ME: [$cwd] Cannot exec $context->{make_cmd}: $!\n";
+                "EXIM_VER=$context->{v}{release}", 'everything'
+                or die "$ME: [$cwd] Cannot exec $context->{make_cmd}: $!\n";
         }
         else {
             waitpid($pid, 0);
         }
         else {
             waitpid($pid, 0);
@@ -262,7 +317,6 @@ __
         }
 
         $context->copy_docbook_files;
         }
 
         $context->copy_docbook_files;
-        $context->build_html_documentation if $context->{web};
     }
 
     sub copy_docbook_files {
     }
 
     sub copy_docbook_files {
@@ -285,7 +339,7 @@ __
         # files there
         {
             my $webdir = catdir $context->{website_base}, 'docbook', $context->{v}{target_release};
         # files there
         {
             my $webdir = catdir $context->{website_base}, 'docbook', $context->{v}{target_release};
-            make_path $webdir, { verbose => $verbose + $debug };
+            make_path $webdir, { verbose => $verbose || $debug };
             copy catfile($context->{d}{vcs_export}, 'doc', 'doc-docbook', $_)
                 => $webdir or die $@
                 for 'spec.xml', 'filter.xml';
             copy catfile($context->{d}{vcs_export}, 'doc', 'doc-docbook', $_)
                 => $webdir or die $@
                 for 'spec.xml', 'filter.xml';
@@ -425,64 +479,82 @@ __
         # those are artifacts of use of tar for backups and have no place in
         # software release packaging; if someone extracts as root, then they should
         # get sane file ownerships.
         # those are artifacts of use of tar for backups and have no place in
         # software release packaging; if someone extracts as root, then they should
         # get sane file ownerships.
-        my $ownership = "";
-        if (`tar --help 2>&1` =~ /^\s*--owner=/m) {
-            $ownership .= " --owner=$context->{tar_perms}{user} --group=$context->{tar_perms}{group}";
+        my @ownership = (
+            '--owner' => $context->{tar_perms}{user},
+            '--group' => $context->{tar_perms}{group},
             # on this GNU tar, --numeric-owner works during creation too
             # on this GNU tar, --numeric-owner works during creation too
-            $ownership .= " --numeric-owner";
-        }
+            '--numeric-owner'
+        ) if qx/tar --help 2>&1/ =~ /^\s*--owner=/m;
 
         # See also environment variables set in main, tuning compression levels
 
         # See also environment variables set in main, tuning compression levels
-        my @COMPRESSIONS = (
-            # compressors-dict-key, file-extension, flags-as-string
-            [ "gzip", "gz", "--gzip" ],
-            [ "bzip2", "bz2", "--bzip2" ],
-            [ "lzip", "lz", "--lzip" ],
-            [ "xz", "xz", "--xz" ],
-        );
 
 
-        my (%size, %sha256);
+        my (%size, %sha256, %sha512);
+
         foreach my $dir ( glob( catdir( $pkg_trees, ( 'exim*-' . $context->{v}{release} ) ) ) ) {
             my $dirname = ( splitdir($dir) )[-1];
         foreach my $dir ( glob( catdir( $pkg_trees, ( 'exim*-' . $context->{v}{release} ) ) ) ) {
             my $dirname = ( splitdir($dir) )[-1];
-            foreach my $comp (@COMPRESSIONS) {
-                my ($compkey, $extension, $flags) = @{$comp};
-                next unless $context->{compressors}{$compkey};
+            foreach my $comp (keys %{$context->{compressors}}) {
+                my %compressor = %{$context->{compressors}{$comp}};
+                next unless $compressor{use};
 
 
-                my $basename = "$dirname.tar.$extension";
+                my $basename = "$dirname.tar.$compressor{extension}";
                 my $outfile = catfile $pkg_tars, $basename;
 
                 print "Creating: $outfile\n" if $verbose || $debug;
                 my $outfile = catfile $pkg_tars, $basename;
 
                 print "Creating: $outfile\n" if $verbose || $debug;
-                0 == system("$tar cf $outfile ${flags} ${ownership} -C ${pkg_trees} ${dirname}")
+                0 == system($tar,
+                    cf => $outfile,
+                        $compressor{flags},
+                        @ownership, -C => $pkg_trees, $dirname)
                     or exit $? >> 8;
 
                 # calculate size and md5sum
                 $size{$basename} = -s $outfile;
                     or exit $? >> 8;
 
                 # calculate size and md5sum
                 $size{$basename} = -s $outfile;
-                $sha256{$basename} = do {
-                    my $sha = Digest::SHA->new(256);
-                    $sha->addfile($outfile);
-                    $sha->hexdigest;
-                };
+                $sha256{$basename} = Digest::SHA->new(256)->addfile($outfile)->hexdigest;
+                $sha512{$basename} = Digest::SHA->new(512)->addfile($outfile)->hexdigest;
             }
         }
 
         # write the sizes file
             }
         }
 
         # write the sizes file
-        open my $sizes, '>', $_ = catfile $pkg_tars, 'sizes.txt'
-            or die "$ME: Can't open `$_': $!\n";
-        print $sizes "SIZE($_) = $size{$_}\n" foreach sort keys %size;
-        print $sizes "\n";
-        print $sizes "SHA256($_) = $sha256{$_}\n" foreach sort keys %sha256;
-        close($sizes) or die "$ME: Can't close $_: $!\n";
+        if ($context->{sizes}) {
+            for ([ sizes => 'SIZE' => \%size ],
+                 [ sha256sums => 'SHA256' => \%sha256 ],
+                 [ sha512sums => 'SHA512' => \%sha512 ]) {
+
+                my $outfile = catfile $pkg_tars, "00-$_->[0].txt";
+                my $tag = $_->[1];
+                my $sizes = $_->[2];
+
+                open my $out, '>', $outfile
+                    or die "$ME: Can't open `$outfile': $!\n";
+
+                print $out join "\n",
+                    (map { "$tag ($_) = $sizes->{$_}" } sort keys %$sizes),
+                    '';
+
+                close($out) or die "$ME: Can't close $outfile: $!\n";
+            }
+        }
     }
 
     sub do_cleanup {
         my $context = shift;
 
         print "Cleaning up\n" if $verbose;
     }
 
     sub do_cleanup {
         my $context = shift;
 
         print "Cleaning up\n" if $verbose;
-        remove_tree $context->{d}{tmp}, { verbose => $debug + $verbose };
+        remove_tree $context->{d}{tmp}, { verbose => $verbose || $debug };
     }
 
 }
 
     }
 
 }
 
+# Check, if tar understands --use-compress-program and use this, as
+# at least gzip deprecated passing options via the environment.
+sub compressor {
+    my ($compressor, $fallback) = @_;
+    state $use_compress_option  =
+        0 == system("tar c -f /dev/null -C / --use-compress-program=cat dev/null 2>/dev/null");
+    return $use_compress_option
+        ? "--use-compress-program=$compressor"
+        : ref $fallback eq ref sub {} ? $fallback->() : $fallback;
+}
+
 MAIN: {
 
     # some of these settings are useful only if we're in the
 MAIN: {
 
     # some of these settings are useful only if we're in the
@@ -495,12 +567,13 @@ MAIN: {
                 user    => '0',
                 group   => '0',
         },
                 user    => '0',
                 group   => '0',
         },
-        make_cmd    => 'make',
+        make_cmd    => 'make',  # for 'make'ing the docs
+        sizes       => 1,
         compressors => {
         compressors => {
-                gzip    => 1,
-                bzip2   => 1,
-                xz      => 1,
-                lzip    => 0,
+            gzip  => { use => 1, extension => 'gz',  flags => compressor('gzip -9', sub { $ENV{GZIP} = '-9'; '--gzip' }) },
+            bzip2 => { use => 1, extension => 'bz2', flags => compressor('bzip2 -9', sub { $ENV{BZIP2} = '-9'; '--bzip2' }) },
+            xz    => { use => 1, extension => 'xz',  flags => compressor('xz -9', sub { $ENV{XZ_OPT} = '-9'; '--xz' }) },
+            lzip  => { use => 0, extension => 'lz',  flags => compressor('lzip -9', '--lzip') },
         },
         docs         => 1,
         web          => 1,
         },
         docs         => 1,
         web          => 1,
@@ -510,29 +583,39 @@ MAIN: {
             sign         => 1,
             key          => undef,
         },
             sign         => 1,
             key          => undef,
         },
+        quick => 0,
     );
 
     ##$ENV{'PATH'} = '/opt/local/bin:' . $ENV{'PATH'};
     );
 
     ##$ENV{'PATH'} = '/opt/local/bin:' . $ENV{'PATH'};
-    # We are creating files for mass distribution, so work harder to make smaller files.
-    $ENV{GZIP} = -9;
-    $ENV{BZIP2} = -9;
-    # xz documents minimum file sizes for levels higher than -6 to be useful and each
-    # requires more RAM on the decompressing system.  Exim tarball currently 24MiB so
-    # using -8.
-    $ENV{XZ_DEFAULTS} = -8;
 
     GetOptions(
         $context,
 
     GetOptions(
         $context,
-        qw(workspace|tmp=s outdir=s website_base|webgen_base=s tar_cmd=s make_cmd=s docs|build-docs! web|build-web!
-           delete! cleanup!),
+        qw(workspace|tmp=s website_base|webgen_base=s tar_cmd|tar-cmd=s make_cmd|make-cmd=s
+           docs|build-docs! web|build-web! sizes!
+           delete! cleanup! quick|quick-release! minimal),
         'sign!'         => \$context->{gpg}{sign},
         'key=s'         => \$context->{gpg}{key},
         'sign!'         => \$context->{gpg}{sign},
         'key=s'         => \$context->{gpg}{key},
-        'lzip!'         => \$context->{compressors}{lzip},
         'verbose!'      => \$verbose,
         'verbose!'      => \$verbose,
-        'debug!'        => \$debug,
+        'compressors=s@' => sub {
+            die "$0: can't parse compressors string `$_[1]'\n" unless $_[1] =~ /^[+=-]?\w+(?:[+=-]\w+)*$/;
+            while ($_[1] =~ /(?<act>[+=-])?(?<name>\w+)\b/g) {
+                die "$0: Unknown compressor $+{name}"
+                    unless $context->{compressors}{$+{name}};
+                if (not defined $+{act} or $+{act} eq '=') {
+                    $_->{use} = 0
+                        for values %{$context->{compressors}};
+                    $context->{compressors}{$+{name}}{use}++;
+                }
+                elsif ($+{act} eq '+') { $context->{compressors}{$+{name}}{use}++; }
+                elsif ($+{act} eq '-') { $context->{compressors}{$+{name}}{use}--; }
+            }
+        },
+        'debug:s'       => \$debug,
+        'quick'         => sub { $context->{web}--; $context->{quick} = 1 },
         'help|?'        => sub { pod2usage(-verbose => 1, -exit => 0) },
         'man!'          => sub { pod2usage(-verbose => 2, -exit => 0, -noperldoc => system('perldoc -V >/dev/null 2>&1')) },
         'help|?'        => sub { pod2usage(-verbose => 1, -exit => 0) },
         'man!'          => sub { pod2usage(-verbose => 2, -exit => 0, -noperldoc => system('perldoc -V >/dev/null 2>&1')) },
-    ) and @ARGV == 2 or pod2usage;
+    ) and (@ARGV == 2 or ($context->{quick} and @ARGV >= 1))
+        or pod2usage;
 
     -f '.exim-project-root'
         or die "$ME: please call this script from the root of the Exim project sources\n";
 
     -f '.exim-project-root'
         or die "$ME: please call this script from the root of the Exim project sources\n";
@@ -551,13 +634,23 @@ MAIN: {
 
     warn "$ME: changed umask to 022\n" if umask(022) != 022;
 
 
     warn "$ME: changed umask to 022\n" if umask(022) != 022;
 
-    $context->check_version(shift);
+    $context->check_version(shift); # may be undef for a quick release
+
+    if ($debug//'' eq 'version') {
+        for (sort keys %{$context->{v}}) {
+            print "version $_: $context->{v}{$_}\n";
+        }
+        print "git commit: $context->{commit}\n";
+        exit 0;
+    }
     $context->override_tar_cmd;
     $context->prepare_working_directory;
     $context->export_git_tree;
     $context->unpack_tree;
     $context->make_version_script;
     $context->override_tar_cmd;
     $context->prepare_working_directory;
     $context->export_git_tree;
     $context->unpack_tree;
     $context->make_version_script;
+
     $context->build_documentation if $context->{docs};
     $context->build_documentation if $context->{docs};
+    $context->build_html_documentation if $context->{docs} && $context->{web};
 
     $context->build_src_package_directory;
     $context->build_doc_packages_directory if $context->{docs};
 
     $context->build_src_package_directory;
     $context->build_doc_packages_directory if $context->{docs};
@@ -581,6 +674,7 @@ mk_exim_release - Build an exim release
 =head1 SYNOPSIS
 
  mk_exim_release [options] version PKG-DIRECTORY
 =head1 SYNOPSIS
 
  mk_exim_release [options] version PKG-DIRECTORY
+ mk_exim_release [options] --quick [version] PKG-DIRECTORY
 
 =head1 DESCRIPTION
 
 
 =head1 DESCRIPTION
 
@@ -609,71 +703,102 @@ Call B<mk_exim_release> about like this:
 
 Do (or do not) cleanup the tmp directory at exit (default: do cleanup)
 
 
 Do (or do not) cleanup the tmp directory at exit (default: do cleanup)
 
-=item B<--[no]debug>
+=item B<--compressors> [I<action>]I<compressor[I<action>$<compressor>]...
+
+A list of compressors to use. Currently the default list is
+B<gzip>, B<xz>, and B<bzip2>, with B<lzip> optionally to be enabled.
+
+I<action> can be "+" (add), "-" (remove), and "=" (set).
+
+=item B<--debug[=I<item>]>
+
+Forces debug mode. If (default: no debug info)
 
 
-Forces debug mode. (default: no debug info)
+=over 4
+
+=item item: B<version>
+
+Output the parsed/found version number and exit.
+
+=back
 
 =item B<--[no]delete>
 
 Delete a pre-existing tmp- and package-directory at start. (default: don't delete)
 
 
 =item B<--[no]delete>
 
 Delete a pre-existing tmp- and package-directory at start. (default: don't delete)
 
-=item B<--tmpdir> I<dir>
+=item B<--[no]doc>
 
 
-Change the name of the tmp directory (default: temporary directory)
+Do (not) build the documentation. This needs C<gnu-make> (default: build the docs)
 
 =item B<--[no]help>
 
 Display short help and exit cleanly. (default: don't do that)
 
 
 =item B<--[no]help>
 
 Display short help and exit cleanly. (default: don't do that)
 
-=item B<--[no]lzip>
+=item B<--key> I<GPG key>
 
 
-Control the creation of B<lzip> tarballs. (default: do not use lzip)
+Use this GPG key for signing. If nothing is specified the first one of this list
+is used:
 
 
-=item B<--make> I<cmd>
+=over 8
+
+=item - git config user.signingkey
+
+=item - environment C<EXIM_KEY>
+
+=item - default GPG key
+
+=back
+
+=item B<--make-cmd> I<cmd>
 
 Force the use of a specific C<make> command. This may be necessary if C<make> is not
 
 Force the use of a specific C<make> command. This may be necessary if C<make> is not
-C<gmake> (default: C<make>)
+C<gmake>. This is necessary to build the docs. (default: C<make>)
 
 =item B<--[no]man>
 
 Display man page and exit cleanly. (default: don't do that)
 
 
 =item B<--[no]man>
 
 Display man page and exit cleanly. (default: don't do that)
 
-=item B<--tar> I<cmd>
+=item B<--quick>
 
 
-Use to override the path to the C<tar> command.  Need GNU tar in case
-I<lzip> is selected. (default: C<gtar>, if not found, use C<tar>)
+Create a quick release. The I<version> mandatory argument needs to be a git commit-ish.
+(try I<master> or I<HEAD> or similar). This mode switches off the
+website creation (which can be enabled by B<--web> again).
 
 =item B<--[no]sign>
 
 Sign the created archive files (and the sizes.txt). (default: sign)
 
 
 =item B<--[no]sign>
 
 Sign the created archive files (and the sizes.txt). (default: sign)
 
-=item B<--key> I<GPG key>
+=item B<--[no]sizes>
 
 
-Use this GPG key for signing. If nothing is specified the first one of this list
-is used:
+Write the sizes information to F<sizes.txt>. (default: write sizes)
 
 
-=over 8
+=item B<--tar-cmd> I<cmd>
 
 
-=item - git config user.signingkey
+Use to override the path to the C<tar> command.  Need GNU tar in case
+I<lzip> is selected. (default: C<gtar>, if not found, use C<tar>).
 
 
-=item - environment C<EXIM_KEY>
+=item B<--tmpdir> I<dir>
 
 
-=item - default GPG key
+Change the name of the tmp directory (default: temporary directory)
 
 
-=back
+=item B<--verbose>
+
+Force verbose mode. (default: no verbosity)
 
 =item B<--[no]web>
 
 Control the creation of the website. For creation of the website, the F<../exim-website>
 
 =item B<--[no]web>
 
 Control the creation of the website. For creation of the website, the F<../exim-website>
-(but see the B<website-base> option) directory must exist. (default: create the website)
+(but see the B<website-base> option) directory must exist. (default: create the website, except when
+in B<quick> mode)
 
 =item B<--website-base> I<dir>
 
 Base directory for the web site generation (default: F<../exim-website>)
 
 
 =item B<--website-base> I<dir>
 
 Base directory for the web site generation (default: F<../exim-website>)
 
-=item B<--verbose>
+=item B<-workspace>|B<--tmp> I<directory>
 
 
-Force verbose mode. (default: no verbosity)
+During release gerneration temporary storage is necessary. (default: F<exim-packaging-XXXX>
+under your system's default temporary directory (typically this is F</tmp>)).
 
 =back
 
 
 =back
 
Master Exim source repository