#!/usr/bin/env perl
-# Copyright (c) The Exim Maintainers 2016
+# Copyright (c) The Exim Maintainers 2016-2018
use strict;
use warnings;
use Carp;
-use File::Copy;
-use File::Spec;
-use File::Path;
+use Cwd qw'abs_path';
+use File::Basename;
+use File::Path qw(make_path remove_tree);
use File::Temp;
-use FindBin;
use Getopt::Long;
use IO::File;
use Pod::Usage;
+use Digest::SHA;
+use if $ENV{DEBUG} => 'Smart::Comments';
-my $debug = 0;
-my $verbose = 0;
+my $ME = basename $0;
-# ------------------------------------------------------------------
-sub get_and_check_version {
- my $release = shift;
- my $context = shift;
+my $debug = undef;
+my $verbose = 0;
- # make sure this looks like a real release version
- # which should (currently) be 4.xx[.y] or 4.xx[.y]_RCx
- unless ( $release =~ /^(?<release>(?<major>4\.\d\d)(?:\.(?<minor>\d+))?(?:_RC\d+)?)$/ ) {
- croak "The given version number does not look right - $release";
- }
- $context->{release} = $+{release};
- $context->{major} = $+{major};
- $context->{minor} = $+{minor};
-
- ($context->{trelease} = $+{release}) =~ s/_RC\d+//;
-}
+# MAJOR.MINOR[.SECURITY[.FIXES]][-RCX]
+# 4 .90 .0 .22 -RC1
+my $version_pattern = qr/
+ (?<release>
+ (?<target_release>
+ (?<major>\d) # 4
+ \.(?<minor>\d\d) # .90
+ (?:\.(?<security>\d+) # .0
+ (?:\.(?<fixes>)\d+)?)? # .22
+ ) # target-release ->|
+ (?:-(?<rc>RC\d+)?)? # -RC1
+ )
+/x;
+
+my $quick_version_pattern = qr/
+ (?<release>
+ (?<last_tag>
+ (?<major>\d) # 4
+ \.(?<minor>\d\d) # .90
+ (?:\.(?<security>\d+) # .0
+ (?:\.(?<fixes>)\d+)?)? # .22
+ ) # last-tag ->|
+ (?:-(?<quick>\d+-g[[:xdigit:]]+))? # -3-gdeadbef
+ )
+/x;
# ------------------------------------------------------------------
-sub build_tag {
- my $context = shift;
+package Context {
+ use strict; # not strictly necessary yet, until in an own package
+ use warnings; # not strictly necessary yet, ...
+ use File::Spec::Functions qw'splitpath catfile catdir splitdir';
+ use File::Path qw'make_path remove_tree';
+ use File::Copy;
+ use Cwd qw'abs_path';
+ use Carp;
+
+ package PWD {
+ use Cwd;
+ sub TIESCALAR { bless do {\my $x} }
+ sub FETCH { cwd }
+ }
- # The CVS tag consists of exim-$version where $version
- # is the version number with . replaced with _
- my $modversion = $context->{release};
- $modversion =~ tr/0-9RC/_/cs;
+ tie my $cwd => 'PWD' or die; # this returns the current dir now, dynamically
- return sprintf( 'exim-%s', $modversion );
-}
+ sub new {
+ my $class = shift;
+ return bless { @_ } => $class;
+ }
-# ------------------------------------------------------------------
+ sub check_version {
+ my $context = 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}} = %+;
-sub deal_with_working_directory {
- my $context = shift;
- my $delete = shift;
+ # 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'});
- # Set default directory
- $context->{directory} ||= File::Spec->rel2abs( sprintf( 'exim-packaging-%s', $context->{release} ) );
- my $directory = $context->{directory};
+ 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;
- # ensure the working directory is not in place
- if ( -d $directory ) {
- if ($delete) {
- print "Deleting existing $directory\n" if ($verbose);
- rmtree( $directory, { verbose => $debug } );
- }
- if ( -d $directory ) {
- croak "Working directory $directory exists";
+ $context->{commit} = $tags[0];
+ # target_release: the release we aim to reach with release candidates
+ # FIXME: re-construct from the parsed version number
}
- }
- # create base directory
- mkpath( $context->{directory}, { verbose => ( $verbose || $debug ) } );
+ 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}
- # set and create subdirectories
- foreach (qw(release_tree pkgs pkgdirs docbook tmp)) {
- $context->{$_} = File::Spec->catdir( $context->{directory}, $_ );
- mkpath( $context->{$_}, { verbose => ( $verbose || $debug ) } );
}
-}
-# ------------------------------------------------------------------
-sub export_git_tree {
- my $context = shift;
+ # We prefer gtar to tar if gtar exists in $PATH
+ sub override_tar_cmd {
+ my $context = shift;
+ my $tar = $context->{tar_cmd};
- # build git command
- my $archive_file = sprintf( '%s/%s-%s.tar', $context->{tmp}, $context->{pkgname}, $context->{release} );
- $context->{tmp_archive_file} = $archive_file;
- my @cmd = ( 'git', 'archive', '--format=tar', "--output=$archive_file", $context->{tag} );
- # run git command
- print( "Running: ", join( ' ', @cmd ), "\n" ) if ($verbose);
- system(@cmd) == 0 || croak "Export failed";
-}
+ return unless $tar eq 'tar';
-# ------------------------------------------------------------------
+ foreach my $d (File::Spec->path()) {
+ my $p = catfile($d, 'gtar');
+ if (-x $p) {
+ $context->{tar_cmd} = $p;
+ print "Switched tar command to: $p\n" if $verbose;
+ return;
+ }
+ }
+ }
-sub unpack_tree {
- my $context = shift;
+ sub prepare_working_directory {
+ my $context = shift;
+ my $workspace = $context->{workspace};
- die "Cannot see archive file\n" unless ( -f $context->{tmp_archive_file} );
- my @cmd = ( 'tar', 'xf', $context->{tmp_archive_file}, '-C', $context->{release_tree} );
+ if (not defined $workspace) {
+ $workspace = $context->{workspace} = File::Temp->newdir(File::Spec->tmpdir . '/exim-packaging-XXXX');
+ }
+ else {
+ # ensure the working directory is not in place
+ if (-e $workspace) {
+ if ($context->{delete}) {
+ print "Deleting existing $workspace\n" if $verbose;
+ remove_tree $workspace, { verbose => $verbose || $debug };
+ }
+ else {
+ croak "Working directory $workspace exists" if -e $workspace;
+ }
+ }
+
+ # create base directory
+ make_path( $context->{directory}, { verbose => $verbose || $debug } );
+ }
- # run command
- print( "Running: ", join( ' ', @cmd ), "\n" ) if ($verbose);
- system(@cmd) == 0 || croak "Unpack failed";
-}
+ # Set(!) and create subdirectories
+ foreach (qw(vcs_export pkg_tars pkg_trees tmp)) { # {dookbook}
+ make_path(
+ $context->{d}{$_} = catdir($workspace, $_),
+ { verbose => $verbose || $debug });
+ }
+ }
-# ------------------------------------------------------------------
+ sub export_git_tree {
+ my $context = shift;
+
+ # 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->{commit} );
+ ### @cmd
+ # run git command
+ print "[$cwd] Running: @cmd\n" if $verbose;
+ 0 == system @cmd or croak "Export failed";
+ }
-sub make_version_script {
- my $context = shift;
+ sub unpack_tree {
+ # TODO: Why can't we combine the export_git_tree with the
+ # unpack_tree function?
+ my $context = shift;
- my $variant = substr( $context->{release}, length($context->{trelease}) );
- if ( $context->{release} ne $context->{trelease} . $variant ) {
- die "Broken version numbering, I'm buggy";
- }
+ ### $context
+ die "Cannot see archive file\n" unless -f $context->{tmp_archive_file};
+ my @cmd = ('tar',
+ xf => $context->{tmp_archive_file},
+ -C => $context->{d}{vcs_export} );
- my $srcdir = File::Spec->catdir( $context->{release_tree}, 'src', 'src' );
- chdir $srcdir or die "chdir $srcdir: $!\n";
+ # run command
+ print "[$cwd] Running: @cmd\n" if $verbose;
+ system @cmd and croak "Unpack failed\n";
- if ( -f "version.sh" ) {
- print( "WARNING: version.sh already exists - leaving it in place\n" );
- return;
}
- # Currently (25. Feb. 2016) the mk_exim_release.pl up to now can't
- # deal with security releases.!? So we need a current
- # mk_exim_release.pl. But if we use a current (master), the
- # reversion script returns wrong version info (it's running inside
- # the Git tree and uses git --describe, which always returns the
- # current version of master.) I do not want to change the old
- # reversion scripts (in 4.86.1, 4.85.1).
- #
- # Thus we've to provide the version.sh, based on the info we have
- # about the release. If reversion finds this, it doesn't try to find
- # it's own way to get a valid version number from the git.
- open(my $v, '>', 'version.sh') or die "Can't open '>version.sh' $!\n";
- print {$v} <<__;
-# initial version automatically generated from $0
-EXIM_RELEASE_VERSION=$context->{major}
-EXIM_VARIANT_VERSION=@{[$context->{minor}?'_'.$context->{minor}:'']}
+ sub make_version_script {
+ my $context = shift;
+
+ #my $variant = substr( $context->{v}{release}, length($context->{v}{target_release}) );
+ #if ( $context->{v}{release} ne $context->{v}{target_release} . $variant ) {
+ # die "Broken version numbering, I'm buggy";
+ #}
+
+
+ # Work
+ if (not my $pid = fork // die "$ME: Cannot fork: $!\n") {
+
+ my $source_tree = catdir($context->{d}{vcs_export}, 'src', 'src');
+ ### $source_tree
+
+ chdir $source_tree or die "chdir $source_tree: $!\n";
+
+ croak "WARNING: version.sh already exists - leaving it in place\n"
+ if -f 'version.sh';
+
+ # Currently (25. Feb. 2016) the mk_exim_release.pl up to now can't
+ # deal with security releases.!? So we need a current
+ # mk_exim_release.pl. But if we use a current (master), the
+ # reversion script returns wrong version info (it's running inside
+ # the Git tree and uses git --describe, which always returns the
+ # current version of master.) I do not want to change the old
+ # reversion scripts (in 4.86.1, 4.85.1).
+ #
+ # Thus we've to provide the version.sh, based on the info we have
+ # about the release. If reversion finds this, it doesn't try to find
+ # it's own way to get a valid version number from the git.
+ #
+ # 4.89 series: the logic here did not handle _RC<N> thus breaking RC
+ # status in versions. nb: rc in context should be same as $variant
+ # in local context.
+
+ #my $stamp = $context->{minor} ? '_'.$context->{minor} : '';
+ #$stamp .= $context->{rc} if $context->{rc};
+ my $release = $context->{v}{rc} ? $context->{v}{target_release}
+ : $context->{v}{last_tag};
+
+ 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
+EXIM_RELEASE_VERSION=$release
+EXIM_VARIANT_VERSION=$variant
EXIM_COMPILE_NUMBER=0
+# echo "[[[ \$EXIM_RELEASE_VERSION | \$EXIM_VARIANT_VERSION | \$EXIM_COMPILE_NUMBER ]]]"
__
- close($v);
- unlink 'version.h';
- return;
+ close $v or die "$0: Can not close $source_tree/version.h: $!\n";
+ unlink 'version.h' or die "$ME: Can not unlink $source_tree/version.h: $!\n"
+ if -f 'version.h';
- # 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->{tag});
- print( "Running: ", join( ' ', @cmd ), "\n" ) if ($verbose);
- system(@cmd) == 0 || croak "reversion failed";
+ # 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->{commit});
- unlink "version.h";
+ my @cmd = ('../scripts/reversion', 'release');
+ print "[$cwd] Running: @cmd\n" if $verbose;
+ system(@cmd) and croak "reversion failed";
- -f "version.sh" or die "failed to create version.sh";
-}
+ die "$ME: failed to create version.sh"
+ unless -f 'version.sh';
-# ------------------------------------------------------------------
+ exit 0;
+ }
+ else {
+ $pid == waitpid($pid, 0) or die "$0: waidpid: $!\n";
+ exit $? >> 8 if $?;
+ }
+ }
-sub build_html_documentation {
- my $context = shift;
+ sub build_documentation {
+ my $context = shift;
+ my $docdir = catdir $context->{d}{vcs_export}, 'doc', 'doc-docbook';
+
+ # documentation building does a chdir, so we'll do it in a
+ # subprocess
+ if (not my $pid = fork // die "$ME: Can't fork: $!\n") {
+ 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}{release}", 'everything'
+ or die "$ME: [$cwd] Cannot exec $context->{make_cmd}: $!\n";
+ }
+ else {
+ waitpid($pid, 0);
+ exit $? >> 8 if $?;
+ }
- my $genpath = $context->{webgen_base} . '/script/gen.pl';
- my $templates = $context->{webgen_base} . '/templates';
- my $dir = File::Spec->catdir( $context->{release_tree}, 'html' );
- my $spec = File::Spec->catfile( $context->{docbook}, 'spec.xml' );
- my $filter = File::Spec->catfile( $context->{docbook}, 'filter.xml' );
+ $context->copy_docbook_files;
+ }
- mkdir($dir);
+ sub copy_docbook_files {
+ my $context = shift;
- my @cmd = (
- $genpath, '--spec', $spec, '--filter',
- $filter, '--latest', $context->{trelease}, '--tmpl',
- $templates, '--docroot', $dir, '--localstatic'
- );
- push @cmd, '--verbose' if $verbose or $debug;
+ # where the generated docbook files can be found
+ my $docdir = catdir $context->{d}{vcs_export}, 'doc', 'doc-docbook';
- print "Executing ", join( ' ', @cmd ), "\n";
- system(@cmd);
+ foreach ('spec.xml', 'filter.xml') {
+ my $from = catfile $docdir, $_;
+ my $to = catdir $context->{d}{tmp}; # {dookbook}
+ copy $from => $to or die $@;
+ }
+ }
- # move directory into right place
- my $sourcedir = File::Spec->catdir( $context->{docbook}, 'filter.xml' );
+ sub build_html_documentation {
+ my $context = shift;
- rename(
- File::Spec->catdir( $dir, sprintf( 'exim-html-%s', $context->{trelease} ) ),
- File::Spec->catdir( $context->{pkgdirs}, sprintf( 'exim-html-%s', $context->{release} ) )
- );
-}
+ # where the website docbook source dir is - push the generated
+ # files there
+ {
+ my $webdir = catdir $context->{website_base}, 'docbook', $context->{v}{target_release};
+ make_path $webdir, { verbose => $verbose || $debug };
+ copy catfile($context->{d}{vcs_export}, 'doc', 'doc-docbook', $_)
+ => $webdir or die $@
+ for 'spec.xml', 'filter.xml';
+ }
-# ------------------------------------------------------------------
+ my $gen = catfile $context->{website_base}, 'script/gen';
+ my $outdir = catdir $context->{d}{pkg_trees}, "exim-html-$context->{v}{release}";
-sub copy_docbook_files {
- my $context = shift;
+ make_path $outdir, { verbose => $verbose || $debug };
- # where the generated docbook files can be found
- my $docdir = File::Spec->catdir( $context->{release_tree}, 'doc', 'doc-docbook' );
+ my @cmd = (
+ $gen,
+ '--spec' => catfile($context->{d}{tmp}, 'spec.xml'), # {dookbook}
+ '--filter' => catfile($context->{d}{tmp}, 'filter.xml'), # {dookbok}
+ '--latest' => $context->{v}{target_release},
+ '--docroot' => $outdir,
+ '--localstatic',
+ ($verbose || $debug ? '--verbose' : ()),
+ );
- # where the website docbook source dir is - push files to here
- my $webdir = File::Spec->catdir( $context->{webgen_base}, 'docbook', $context->{trelease} );
- mkpath( $webdir, { verbose => ( $verbose || $debug ) } );
+ print "[$cwd] Executing @cmd\n";
+ 0 == system @cmd or exit $? >> 8;
- foreach my $file ( 'spec.xml', 'filter.xml' ) {
- my $from = File::Spec->catfile( $docdir, $file );
- my $to = File::Spec->catfile( $context->{docbook}, $file );
- my $webto = File::Spec->catfile( $webdir, $file );
- copy( $from, $to );
- copy( $from, $webto );
}
-}
-# ------------------------------------------------------------------
+ sub sign {
+ my $context = shift;
+ foreach my $tar (glob "$context->{d}{pkg_tars}/*") {
+ system gpg =>
+ '--quiet', '--batch',
+ defined $context->{gpg}{key}
+ ? ('--local-user' => $context->{gpg}{key})
+ : (),
+ '--detach-sig', '--armor', $tar;
+ }
+ }
-sub build_documentation {
- my $context = shift;
+ sub move_to_outdir {
+ my $context = shift;
+ make_path $context->{OUTDIR}, { verbose => $verbose || $debug };
+ move $_ => $context->{OUTDIR} or die $@
+ for glob "$context->{d}{pkg_tars}/*";
+ }
- my $docdir = File::Spec->catdir( $context->{release_tree}, 'doc', 'doc-docbook' );
- # documentation building gets the truncated release, without RC
- system("cd '$docdir' && ./OS-Fixups && $context->{make_cmd} EXIM_VER=$context->{trelease} everything") == 0
- || croak "Doc build failed";
+ sub build_src_package_directory {
+ my $context = shift;
- copy_docbook_files($context);
- build_html_documentation($context) if $context->{web};
-}
+ # build the exim package directory path
+ $context->{d}{src} = catdir $context->{d}{pkg_trees}, "exim-$context->{v}{release}";
-# ------------------------------------------------------------------
-
-sub move_text_docs_into_pkg {
- my $context = shift;
+ # initially we move the exim-src directory to the new directory name
+ move
+ catdir( $context->{d}{vcs_export}, 'src')
+ => $context->{d}{src}
+ or croak "Move of src dir failed - $!";
- my $old_docdir = File::Spec->catdir( $context->{release_tree}, 'doc', 'doc-docbook' );
- my $old_txtdir = File::Spec->catdir( $context->{release_tree}, 'doc', 'doc-txt' );
- my $new_docdir = File::Spec->catdir( $context->{eximpkgdir}, 'doc' );
- mkpath( $new_docdir, { verbose => ( $verbose || $debug ) } );
+ # add Local subdirectory
+ make_path( catdir( $context->{d}{src}, 'Local' ), { verbose => $verbose || $debug } );
- # move generated documents from docbook stuff
- foreach my $file (qw/exim.8 spec.txt filter.txt/) {
- move( File::Spec->catfile( $old_docdir, $file ), File::Spec->catfile( $new_docdir, $file ) );
+ # now add the text docs
+ $context->move_text_docs_into_pkg;
}
- # move text documents across
- foreach my $file ( glob( File::Spec->catfile( $old_txtdir, '*' ) ) ) {
-
- # skip a few we dont want
- my $fn = ( File::Spec->splitpath($file) )[2];
- next
- if ( ( $fn eq 'ABOUT' )
- || ( $fn eq 'ChangeLog.0' )
- || ( $fn eq 'test-harness.txt' )
- # Debian issue re licensing of RFCs
- || ( $fn =~ /^draft-ietf-.*/ )
- || ( $fn =~ /^rfc.*/ )
- );
- move( $file, File::Spec->catfile( $new_docdir, $fn ) );
- }
-}
-
-# ------------------------------------------------------------------
-
-sub build_pspdfinfo_directory {
- my $context = shift;
-
- ##foreach my $format (qw/pdf postscript texinfo info/) {
- foreach my $format (qw/pdf postscript/) {
- my $target = File::Spec->catdir( $context->{pkgdirs}, sprintf( 'exim-%s-%s', $format, $context->{release} ), 'doc' );
- mkpath( $target, { verbose => ( $verbose || $debug ) } );
-
- # move documents across
- foreach my $file (
- glob(
- File::Spec->catfile(
- $context->{release_tree},
- 'doc',
- 'doc-docbook',
- (
- ( $format eq 'postscript' )
- ? '*.ps'
- : ( '*.' . $format )
+ sub build_doc_packages_directory {
+ my $context = shift;
+
+ ##foreach my $format (qw/pdf postscript texinfo info/) {
+ foreach my $format (qw/pdf postscript/) {
+ my $target = catdir $context->{d}{pkg_trees}, "exim-$format-$context->{v}{release}", 'doc';
+ make_path( $target, { verbose => $verbose || $debug } );
+
+ # move documents across
+ foreach my $file (
+ glob(
+ catfile(
+ $context->{d}{vcs_export},
+ 'doc',
+ 'doc-docbook',
+ (
+ ( $format eq 'postscript' )
+ ? '*.ps'
+ : ( '*.' . $format )
+ )
)
)
)
- )
- {
- move( $file, File::Spec->catfile( $target, ( File::Spec->splitpath($file) )[2] ) );
+ {
+ move( $file, catfile( $target, ( splitpath($file) )[2] ) );
+ }
}
}
-}
-
-# ------------------------------------------------------------------
-
-sub build_main_package_directory {
- my $context = shift;
-
- # build the exim package directory path
- $context->{eximpkgdir} = File::Spec->catdir( $context->{pkgdirs}, sprintf( 'exim-%s', $context->{release} ) );
- # initially we move the exim-src directory to the new directory name
- rename( File::Spec->catdir( $context->{release_tree}, 'src' ), $context->{eximpkgdir} )
- || croak "Rename of src dir failed - $!";
+ sub move_text_docs_into_pkg {
+ my $context = shift;
- # add Local subdirectory
- mkpath( File::Spec->catdir( $context->{eximpkgdir}, 'Local' ), { verbose => ( $verbose || $debug ) } );
+ my $old_docdir = catdir( $context->{d}{vcs_export}, 'doc', 'doc-docbook' );
+ my $old_txtdir = catdir( $context->{d}{vcs_export}, 'doc', 'doc-txt' );
+ my $new_docdir = catdir( $context->{d}{src}, 'doc' );
+ make_path( $new_docdir, { verbose => $verbose || $debug } );
- # now add the text docs
- move_text_docs_into_pkg($context);
-}
-
-# ------------------------------------------------------------------
-
-sub build_package_directories {
- my $context = shift;
-
- build_main_package_directory($context);
- build_pspdfinfo_directory($context) if $context->{build_docs};
-}
-
-# ------------------------------------------------------------------
+ # move generated documents from docbook stuff
+ foreach my $file (qw/exim.8 spec.txt filter.txt/) {
+ die "Empty file \"$file\"\n" if -z catfile( $old_docdir, $file );
+ move( catfile( $old_docdir, $file ), catfile( $new_docdir, $file ) );
+ }
-sub do_cleanup {
- my $context = shift;
+ # move text documents across
+ foreach my $file ( glob( catfile( $old_txtdir, '*' ) ) ) {
+
+ # skip a few we dont want
+ my $fn = ( splitpath($file) )[2];
+ next
+ if ( ( $fn eq 'ABOUT' )
+ || ( $fn eq 'ChangeLog.0' )
+ || ( $fn eq 'test-harness.txt' )
+ # Debian issue re licensing of RFCs
+ || ( $fn =~ /^draft-ietf-.*/ )
+ || ( $fn =~ /^rfc.*/ )
+ );
+ move( $file, catfile( $new_docdir, $fn ) );
+ }
+ }
- print "Cleaning up\n" if ($verbose);
- chdir( $context->{directory} ) || die;
- rmtree( $context->{release_tree}, { verbose => $debug } );
- rmtree( $context->{docbook}, { verbose => $debug } );
- rmtree( $context->{pkgdirs}, { verbose => $debug } );
-}
+ sub create_tar_files {
+ my $context = shift;
-# ------------------------------------------------------------------
+ my $pkg_tars = $context->{d}{pkg_tars};
+ my $pkg_trees = $context->{d}{pkg_trees};
+ my $tar = $context->{tar_cmd};
+ if ($verbose) {
+ foreach my $c (keys %{ $context->{compressors} }) {
+ print "Compression: $c\t$context->{compressors}{$c}\n";
+ }
+ }
-# We prefer gtar to tar if gtar exists in $PATH
+ # We ideally do not want local system user information in release tarballs;
+ # 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 = (
+ '--owner' => $context->{tar_perms}{user},
+ '--group' => $context->{tar_perms}{group},
+ # on this GNU tar, --numeric-owner works during creation too
+ '--numeric-owner'
+ ) if qx/tar --help 2>&1/ =~ /^\s*--owner=/m;
+
+ # See also environment variables set in main, tuning compression levels
+
+ my (%size, %sha256);
+
+ foreach my $dir ( glob( catdir( $pkg_trees, ( 'exim*-' . $context->{v}{release} ) ) ) ) {
+ my $dirname = ( splitdir($dir) )[-1];
+ foreach my $comp (keys %{$context->{compressors}}) {
+ my %compressor = %{$context->{compressors}{$comp}};
+ next unless $compressor{use};
+
+ my $basename = "$dirname.tar.$compressor{extension}";
+ my $outfile = catfile $pkg_tars, $basename;
+
+ print "Creating: $outfile\n" if $verbose || $debug;
+ 0 == system($tar,
+ cf => $outfile,
+ $compressor{flags},
+ @ownership, -C => $pkg_trees, $dirname)
+ 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;
+ };
+ }
+ }
-sub fix_paths_tar {
- my $context = shift;
- my $tar = $context->{tar_cmd};
+ # write the sizes file
+ if ($context->{sizes}) {
+ open my $sizes, '>', $_ = catfile $pkg_tars, 'sizes.txt'
+ or die "$ME: Can't open `$_': $!\n";
- return unless $tar eq 'tar';
+ print $sizes join "\n",
+ (map { "SIZE($_) = $size{$_}" } sort keys %size),
+ (map { "SHA256($_) = $sha256{$_}" } sort keys %sha256);
- foreach my $d (File::Spec->path()) {
- my $p = File::Spec->catfile($d, 'gtar');
- if (-x $p) {
- $context->{tar_cmd} = $p;
- print "Switched tar command to: $p\n" if ($verbose);
- return;
+ close($sizes) or die "$ME: Can't close $_: $!\n";
}
}
-}
-
-# ------------------------------------------------------------------
-sub create_tar_files {
- my $context = shift;
+ sub do_cleanup {
+ my $context = shift;
- my $pkgs = $context->{pkgs};
- my $pkgdirs = $context->{pkgdirs};
- my $tar = $context->{tar_cmd};
- if ($verbose) {
- foreach my $c (keys %{ $context->{compressors} }) {
- print "Compression: $c\t$context->{compressors}{$c}\n";
- }
+ print "Cleaning up\n" if $verbose;
+ remove_tree $context->{d}{tmp}, { verbose => $verbose || $debug };
}
- foreach my $dir ( glob( File::Spec->catdir( $pkgdirs, ( 'exim*-' . $context->{release} ) ) ) ) {
- my $dirname = ( File::Spec->splitdir($dir) )[-1];
- if ($context->{compressors}{gzip}) {
- print "Creating: ${pkgs}/${dirname}.tar.gz\n" if ($verbose || $debug);
- system("$tar cf ${pkgs}/${dirname}.tar.gz --gzip -C ${pkgdirs} ${dirname}")
- }
- if ($context->{compressors}{bzip2}) {
- print "Creating: ${pkgs}/${dirname}.tar.bz2\n" if ($verbose || $debug);
- system("$tar cf ${pkgs}/${dirname}.tar.bz2 --bzip2 -C ${pkgdirs} ${dirname}")
- }
- if ($context->{compressors}{lzip}) {
- print "Creating: ${pkgs}/${dirname}.tar.lz\n" if ($verbose || $debug);
- system("$tar cf ${pkgs}/${dirname}.tar.lz --lzip -C ${pkgdirs} ${dirname}")
- }
- }
}
-# ------------------------------------------------------------------
MAIN: {
- $0 =~ m|^(?:\./)?release-process/scripts/|
- or die "$0: please call this script from the root of the Exim project sources\n";
-
- my $context = {
+ # some of these settings are useful only if we're in the
+ # exim-projekt-root, but the check, if we're, is deferred
+ my $context = Context->new(
pkgname => 'exim',
- orig_dir => File::Spec->curdir(),
- tmp_dir => File::Temp->newdir(),
- webgen_base => "$FindBin::Bin/../../../exim-website",
+ website_base => abs_path('../exim-website'),
tar_cmd => 'tar',
- make_cmd => 'make',
+ tar_perms => {
+ user => '0',
+ group => '0',
+ },
+ make_cmd => 'make', # for 'make'ing the docs
+ sizes => 1,
compressors => {
- gzip => 1,
- bzip2 => 1,
- lzip => 0,
+ gzip => { use => 1, extension => 'gz', flags => '--gzip' },
+ bzip2 => { use => 1, extension => 'bz2', flags => '--bzip2' },
+ xz => { use => 1, extension => 'xz', flags => '--xz' },
+ lzip => { use => 0, extension => 'lz', flags => '--lzip' },
},
- build_docs => 1,
+ docs => 1,
web => 1,
- };
- my $delete;
- my $cleanup = 1;
+ delete => 0,
+ cleanup => 1,
+ gpg => {
+ sign => 1,
+ key => undef,
+ },
+ quick => 0,
+ );
+
##$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(
- 'directory=s' => \$context->{directory},
- 'webgen_base=s' => \$context->{webgen_base},
- 'tar=s' => \$context->{tar_cmd},
- 'make=s' => \$context->{make_cmd},
- 'lzip!' => \$context->{compressors}{lzip},
+ $context,
+ 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},
'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')) },
- 'delete!' => \$delete,
- 'cleanup!' => \$cleanup,
- 'build-docs!' => \$context->{build_docs},
- 'web!' => \$context->{web},
- ) and @ARGV == 1 or pod2usage;
-
- get_and_check_version( shift, $context );
- fix_paths_tar($context);
- $context->{tag} = build_tag($context);
- deal_with_working_directory( $context, $delete );
- export_git_tree($context);
- chdir( $context->{directory} ) || die;
- unpack_tree($context);
- make_version_script($context);
- build_documentation($context) if $context->{build_docs};
- build_package_directories($context);
- create_tar_files($context);
- do_cleanup($context) if ($cleanup);
+ ) 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";
+
+ $context->{OUTDIR} = pop @ARGV;
+
+ if ($context->{gpg}{sign}) {
+ $context->{gpg}{key} //= do { chomp($_ = qx/git config user.signingkey/); $_ }
+ || $ENV{EXIM_KEY}
+ || do {
+ warn "$ME: No GPG key, using default\n";
+ undef;
+ }
+ }
+
+
+ warn "$ME: changed umask to 022\n" if umask(022) != 022;
+
+ $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->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->create_tar_files;
+ $context->sign if $context->{gpg}{sign};
+ $context->move_to_outdir;
+ $context->do_cleanup if $context->{cleanup};
+
+ ### $context
}
1;
=head1 SYNOPSIS
- mk_exim_release [options] version
+ mk_exim_release [options] version PKG-DIRECTORY
+ mk_exim_release [options] --quick [version] PKG-DIRECTORY
=head1 DESCRIPTION
Starting in a populated git repo that has already been tagged for
release it builds docs, packages etc. Parameter is the version number
-to build as - ie 4.72 4.72RC1, 4.86.1, etc
+to build as - ie 4.72 4.72-RC1, 4.86.1, etc, without any prefix.
+
+This scripts expects to find a tag "exim-<version>".
After creating the release files, they should be signed. There is another
helper for creating the signatures:
Call B<mk_exim_release> about like this:
- release-process/scripts/mk_exim_release 4.99
+ release-process/scripts/mk_exim_release 4.99 OUT-DIR
=head1 OPTIONS
=over 4
-=item B<--[no]debug>
+=item B<--[no]cleanup>
+
+Do (or do not) cleanup the tmp directory at exit (default: do cleanup)
+
+=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)
+
+=over 4
+
+=item item: B<version>
-Forces debug mode. (default: no debug info)
+Output the parsed/found version number and exit.
+
+=back
=item B<--[no]delete>
-Delete a pre-existing package directory at start. (default: don't delete)
+Delete a pre-existing tmp- and package-directory at start. (default: don't delete)
-=item B<--directory> I<dir>
+=item B<--[no]doc>
-Change the name of the package directory (default: F<< exim-packaging-<version> >>)
+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]lzip>
+=item B<--key> I<GPG key>
+
+Use this GPG key for signing. If nothing is specified the first one of this list
+is used:
-Control the creation of B<lzip> tarballs. (default: do not use lzip)
+=over 8
-=item B<--make> I<cmd>
+=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
-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<--tar> I<cmd>
+=item B<--quick>
+
+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]sizes>
+
+Write the sizes information to F<sizes.txt>. (default: write sizes)
+
+=item B<--tar-cmd> I<cmd>
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 B<--[no]web>
+=item B<--tmpdir> I<dir>
-Control the creation of the website. For creation of the website, the F<../exim-website>
-directory must exist. (default: create the website)
+Change the name of the tmp directory (default: temporary directory)
=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>
+(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<-workspace>|B<--tmp> I<directory>
+
+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
=head1 AUTHOR
git://git.exim.org / users / jgh / exim.git / blobdiff