ae9a98b436
The file "core.ver" was removed in configure together with other "core.*" files. It was ugly name. Better to use "sources.ver" and the variable "lo_sources_ver=..." The source version is not used in "unpack-sources", so do not source the .ver file at all. The source tarballs are put into "major.minor.micro" version subdirectory on the download site now.
475 lines
15 KiB
Perl
Executable file
475 lines
15 KiB
Perl
Executable file
#!/usr/bin/perl
|
|
eval 'exec /usr/bin/perl -S $0 ${1+"$@"}'
|
|
if $running_under_some_shell;
|
|
#!/usr/bin/perl
|
|
|
|
use strict;
|
|
use File::Copy;
|
|
use File::Temp qw/ tempfile tempdir /;
|
|
|
|
# get libreoffice-build version from the given libreoffice-build sources
|
|
sub get_config_version($)
|
|
{
|
|
my ($lo_core_dir) = @_;
|
|
my $version;
|
|
|
|
open (CONFIGURE, "$lo_core_dir/configure.in") ||
|
|
die "can't open \"$lo_core_dir/configure.in\" for reading: $!\n";
|
|
|
|
while (my $line = <CONFIGURE>) {
|
|
chomp $line;
|
|
|
|
if ($line =~ /AC_INIT\s*\(\s*libreoffice-build\s*,\s*([\w\.]*)\)/) {
|
|
$version="$1";
|
|
}
|
|
}
|
|
close (CONFIGURE);
|
|
return $version;
|
|
}
|
|
|
|
# increment the version for a test build:
|
|
# + add 'a' if the version ended with a number
|
|
# + bump the letter otherwise
|
|
sub inc_test_version($)
|
|
{
|
|
my ($version) = @_;
|
|
|
|
my $lastchar = chop $version;
|
|
my $new_version;
|
|
|
|
if ($lastchar =~ /\d/) {
|
|
return "$version" . "$lastchar" . "a";
|
|
} elsif ($lastchar =~ /\w/) {
|
|
# select next letter alhabeticaly: a->b, b->c, ...
|
|
$lastchar =~ tr/0a-zA-Z/a-zA-Z0/;
|
|
return "$version" . "$lastchar";
|
|
} else {
|
|
die "Can't generate test version from \"$version$lastchar\n";
|
|
}
|
|
}
|
|
|
|
sub get_release_version($$$$)
|
|
{
|
|
my ($config_version, $state_config_version, $state_release_version, $inc_version) = @_;
|
|
my $release_version;
|
|
|
|
if (defined $state_config_version &&
|
|
defined $state_release_version &&
|
|
"$state_config_version" eq "$config_version") {
|
|
$release_version = "$state_release_version";
|
|
} else {
|
|
$release_version = "$config_version";
|
|
}
|
|
|
|
if ( defined $inc_version ) {
|
|
$release_version = inc_test_version($release_version);
|
|
}
|
|
|
|
return $release_version;
|
|
}
|
|
|
|
# copy files to temp dir; showing a progress; using a black list
|
|
sub copy_dir_filter_and_show_progress($$)
|
|
{
|
|
my ($source_dir, $target_dir) = @_;
|
|
|
|
print "Copying \"$source_dir\" -> \"$target_dir\"...";
|
|
# copy sources from git and show progress
|
|
system ("cd $source_dir && " .
|
|
"git archive --format=tar HEAD | " .
|
|
" tar -xf - -C $target_dir --checkpoint=500 --checkpoint-action=exec=\"echo -n .\"") &&
|
|
die "Error: copying failed: $!\n";
|
|
print "\n";
|
|
}
|
|
|
|
# copy the piece lo source directory into a tmp directory
|
|
# omit the .git subdirectories
|
|
sub copy_lo_piece_to_tempdir($$$)
|
|
{
|
|
my ($piece_dir, $piece, $piece_tarball_name) = @_;
|
|
my $tempdir = tempdir( 'libreoffice-XXXXXX', DIR => File::Spec->tmpdir );
|
|
|
|
mkdir "$tempdir/$piece_tarball_name" || die "Can't create directory \"$tempdir/$piece_tarball_name\": $!\n";
|
|
copy_dir_filter_and_show_progress("$piece_dir", "$tempdir/$piece_tarball_name");
|
|
|
|
return $tempdir;
|
|
}
|
|
|
|
sub generate_lo_piece_changelog($$$)
|
|
{
|
|
my ($lo_piece_clone, $lo_piece_release_dir, $piece) = @_;
|
|
print "Generating changelog for $piece...\n";
|
|
# print "1:$lo_piece_clone, 2:$lo_piece_release_dir, 3:$piece\n";
|
|
system ("cd $lo_piece_clone && " .
|
|
"git log --date=short --pretty='format:@%cd %an <%ae> [%H]%n%n%s%n%n%e%b' | " .
|
|
" sed -e 's|^\([^@]\)|\t\1|' -e 's|^@||' >$lo_piece_release_dir/ChangeLog" ) &&
|
|
die "Error: generating failed: $!\n";
|
|
}
|
|
|
|
sub run_autoreconf($$)
|
|
{
|
|
my ($dir, $piece) = @_;
|
|
|
|
print "Running autoreconf for $piece...\n";
|
|
system ("cd $dir && " .
|
|
"autoreconf -f -i && " .
|
|
"rm -rf autom4te.cache && " .
|
|
"cd - >/dev/null 2>&1") && die "Error: autoreconf failed: $!\n";
|
|
}
|
|
|
|
sub generate_sources_version_file($$)
|
|
{
|
|
my ($dir, $release_version) = @_;
|
|
|
|
open (VERFILE, ">$dir/sources.ver") || die "Can't open $dir/sources.ver: $!\n";
|
|
|
|
print VERFILE "lo_sources_ver=$release_version\n";
|
|
|
|
close VERFILE;
|
|
}
|
|
|
|
sub generate_tarball($$$)
|
|
{
|
|
my ($dir, $tarball, $tar_compress_option) = @_;
|
|
|
|
print "Creating $tarball...";
|
|
# generate the tarball in the current directory; avoid "./" prefix in the stored paths; show progress
|
|
system ("tar -c $tar_compress_option -f $tarball -C $dir --checkpoint=500 --checkpoint-action=exec=\"echo -n .\" --transform=\"s|^\./||\" .") &&
|
|
die "Error: releasing failed: $!\n";
|
|
print "\n";
|
|
}
|
|
|
|
sub generate_md5($)
|
|
{
|
|
my ($filename) = @_;
|
|
|
|
print "Generating MD5...\n";
|
|
system ("md5sum $filename >$filename.md5") &&
|
|
die "Error: releasing failed: $!\n";
|
|
}
|
|
|
|
sub default_releases_state_file($)
|
|
{
|
|
my ($lo_core_dir) = @_;
|
|
|
|
my $rootdir = $lo_core_dir;
|
|
$rootdir =~ s/^(.*?)\/?[^\/]+\/?$/$1/;
|
|
|
|
my $releases_state_file;
|
|
if ($rootdir) {
|
|
$releases_state_file = "$rootdir/.releases";
|
|
} else {
|
|
$releases_state_file = ".releases";
|
|
}
|
|
|
|
return "$releases_state_file";
|
|
}
|
|
|
|
sub load_releases_state($)
|
|
{
|
|
my ($releases_state_file) = @_;
|
|
|
|
my $state_config_version;
|
|
my $state_release_version;
|
|
|
|
if (open (STATE, "$releases_state_file")) {
|
|
|
|
while (my $line = <STATE>) {
|
|
chomp $line;
|
|
|
|
if ($line =~ /^\s*configure_version\s*=\s*(.*)$/) {
|
|
$state_config_version = "$1";
|
|
} elsif ($line =~ /^\s*released_version\s*=\s*(.*)$/) {
|
|
$state_release_version = "$1";
|
|
}
|
|
}
|
|
close (STATE);
|
|
}
|
|
|
|
return $state_config_version, $state_release_version;
|
|
}
|
|
|
|
sub save_releases_state($$$)
|
|
{
|
|
my ($releases_state_file, $config_version, $release_version) = @_;
|
|
|
|
open (STATE, '>', "$releases_state_file") ||
|
|
die "Can't open \"$releases_state_file\" for writing: $!\n";
|
|
|
|
print STATE "configure_version = $config_version\n";
|
|
print STATE "released_version = $release_version\n";
|
|
|
|
close (STATE);
|
|
}
|
|
|
|
sub remove_tempdir($)
|
|
{
|
|
my ($tempdir) = @_;
|
|
|
|
# print "Cleaning $tempdir...\n";
|
|
system ("rm -rf $tempdir") && die "Error: rm failed: $!\n";
|
|
}
|
|
|
|
sub check_if_file_exists($$)
|
|
{
|
|
my ($file, $force) = @_;
|
|
|
|
if (-e $file) {
|
|
if (defined $force) {
|
|
print "Warning: $file already exists and will be replaced!\n";
|
|
} else {
|
|
die "Error: $file alrady exists.\n".
|
|
" Use --force if you want to replace it.\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
sub check_if_already_released($$$$$$$)
|
|
{
|
|
my ($lo_core_tarball_name, $p_piece_tarball_name, $force, $bzip2, $xz, $pack_lo_core, $pack_lo_pieces) = @_;
|
|
|
|
check_if_file_exists("$lo_core_tarball_name.tar.bz2", $force) if ($pack_lo_core && defined $bzip2);
|
|
check_if_file_exists("$lo_core_tarball_name.tar.xz", $force) if ($pack_lo_core && defined $xz);
|
|
|
|
if ($pack_lo_pieces) {
|
|
foreach my $tarball_name ( values %{$p_piece_tarball_name} ) {
|
|
check_if_file_exists("$tarball_name.tar.bz2", $force) if (defined $bzip2);
|
|
check_if_file_exists("$tarball_name.tar.xz", $force) if (defined $xz);
|
|
}
|
|
}
|
|
}
|
|
|
|
sub prepare_piece_sources($$$$)
|
|
{
|
|
my ($piece_dir, $release_version, $piece, $piece_tarball_name) = @_;
|
|
|
|
# prepare sources
|
|
my $temp_dir = copy_lo_piece_to_tempdir($piece_dir, $piece, $piece_tarball_name);
|
|
generate_lo_piece_changelog($piece_dir, "$temp_dir/$piece_tarball_name", $piece);
|
|
run_autoreconf("$temp_dir/$piece_tarball_name", $piece) if ($piece eq 'core');
|
|
generate_sources_version_file("$temp_dir/$piece_tarball_name", $release_version) if ($piece eq 'core');
|
|
|
|
return $temp_dir;
|
|
}
|
|
|
|
sub pack_piece_sources($$$$)
|
|
{
|
|
my ($temp_dir, $md5, $tarball, $tar_compress_option) = @_;
|
|
|
|
generate_tarball($temp_dir, $tarball, $tar_compress_option);
|
|
generate_md5($tarball) if (defined $md5);
|
|
}
|
|
|
|
sub generate_piece_tarball($$$$$$$)
|
|
{
|
|
my ($piece_dir, $release_version, $piece, $md5, $bzip2, $xz, $piece_tarball_name) = @_;
|
|
|
|
my $temp_dir = prepare_piece_sources($piece_dir, $release_version, $piece, $piece_tarball_name);
|
|
pack_piece_sources($temp_dir, $md5, "$piece_tarball_name.tar.bz2", "--bzip2") if (defined $bzip2);
|
|
pack_piece_sources($temp_dir, $md5, "$piece_tarball_name.tar.xz", "--xz") if (defined $xz);
|
|
remove_tempdir($temp_dir);
|
|
}
|
|
|
|
|
|
sub generate_tarballs($$$$$$$$$$)
|
|
{
|
|
my ($source_dir, $release_version, $md5, $bzip2, $xz, $lo_core_tarball_name, $p_piece_tarball_name, $pack_lo_core, $pack_lo_pieces, $is_lo_core_dir) = @_;
|
|
|
|
if ($pack_lo_core) {
|
|
generate_piece_tarball($source_dir, $release_version, "core", $md5, $bzip2, $xz, $lo_core_tarball_name);
|
|
}
|
|
|
|
if ($pack_lo_pieces) {
|
|
my $piece_dir = $source_dir;
|
|
foreach my $piece ( keys %{$p_piece_tarball_name} ) {
|
|
print "\n--- Generating $piece ---\n";
|
|
$piece_dir = "$source_dir/clone/$piece" if ($is_lo_core_dir);
|
|
generate_piece_tarball($piece_dir, $release_version, $piece, $md5, $bzip2, $xz, $p_piece_tarball_name->{$piece});
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
sub usage()
|
|
{
|
|
print "This tool helps to pack the libreoffice-build and piece sources\n\n" .
|
|
|
|
"Usage:\n".
|
|
"\tlo-pack-sources [--help]\n" .
|
|
"\t [--force] [--md5] [--bzip2] [--xz]\n" .
|
|
"\t [--version][--set-version=<ver>] [--inc-version]\n" .
|
|
"\t [--no-lo-core] [--no-lo-pieces] [--piece=<piece>]\n" .
|
|
"\t [dir]\n\n" .
|
|
|
|
"Options:\n\n" .
|
|
"\t--help: print this help\n" .
|
|
"\t--force: replace an already existing release of the same version\n" .
|
|
"\t--md5: generate md5 sum for the final tarball\n" .
|
|
"\t--bzip2: generate tarballs compressed by bzip2\n" .
|
|
"\t--xz: generate tarballs compressed by xz (default)\n" .
|
|
"\t--version: just print version of the released package but do not\n" .
|
|
"\t\trelease it; the version is affected by the other options, e.g.\n" .
|
|
"\t\t--inc-version\n" .
|
|
"\t--set-version: force another version\n" .
|
|
"\t--inc-version: increment the latest version; there is a difference\n" .
|
|
"\t\tbetween test release (default) and final (not yet supported)\n" .
|
|
"\t--no-lo-core: do not pack the libreoffice-core tarball\n" .
|
|
"\t--no-lo-pieces: do not pack the extra LO piece sources\n" .
|
|
"\t--piece=<piece>: pack just a single piece, .e.g. \"help\",\n" .
|
|
"\tdir: path of the source directory, either libreoffice-build or piece\n";
|
|
}
|
|
|
|
|
|
my $ptf;
|
|
my $md5;
|
|
my $bzip2;
|
|
my $xz;
|
|
my $inc_version;
|
|
my $config_version;
|
|
my $set_version;
|
|
my $get_config_version;
|
|
my $release_version;
|
|
my $pack_lo_core=1;
|
|
my $pack_lo_pieces=1;
|
|
my $source_dir;
|
|
my $releases_state_file;
|
|
my $state_config_version;
|
|
my $state_release_version;
|
|
my $lo_core_tarball_name;
|
|
my $lo_core_tempdir;
|
|
my $force;
|
|
my $verbose=1;
|
|
my $is_lo_core_dir=0;
|
|
my @pieces=("binfilter", "dictionaries", "help", "translations");
|
|
my %piece_tarball_name;
|
|
|
|
###################
|
|
# Arguments parsing
|
|
###################
|
|
|
|
for my $arg (@ARGV) {
|
|
if ($arg eq '--help' || $arg eq '-h') {
|
|
usage;
|
|
exit 0;
|
|
} elsif ($arg eq '--force') {
|
|
$force=1;
|
|
} elsif ($arg eq '--md5') {
|
|
$md5=1;
|
|
} elsif ($arg eq '--bzip2') {
|
|
$bzip2=1;
|
|
} elsif ($arg eq '--xz') {
|
|
$xz=1;
|
|
} elsif ($arg eq '--version') {
|
|
$get_config_version=1;
|
|
$verbose = undef;
|
|
} elsif ($arg eq '--inc-version') {
|
|
$inc_version=1
|
|
} elsif ($arg =~ m/--set-version=(.*)/) {
|
|
$set_version="$1";
|
|
} elsif ($arg eq '--no-lo-core') {
|
|
$pack_lo_core=0;
|
|
} elsif ($arg eq '--no-lo-pieces') {
|
|
$pack_lo_pieces=0;
|
|
} elsif ($arg =~ m/--piece=(.*)/) {
|
|
# process just one piece and do not pack libreoffice-build
|
|
@pieces=();
|
|
push @pieces, "$1";
|
|
$pack_lo_core=0;
|
|
} elsif ($arg =~ /^-/ ) {
|
|
die "Error: unknown option: $arg\n";
|
|
} else {
|
|
if (! defined $source_dir) {
|
|
$source_dir = $arg;
|
|
} else {
|
|
die "Error: Too many arguments $arg\n";
|
|
}
|
|
}
|
|
}
|
|
|
|
###################
|
|
# Initial checks
|
|
###################
|
|
|
|
unless ( defined $source_dir ) {
|
|
die "Error: undefined source directory, try --help\n";
|
|
}
|
|
|
|
unless ( -d "$source_dir" ) {
|
|
die "Error: is not a directory: $source_dir\n";
|
|
}
|
|
|
|
# check if it is a valid libreoffice-core directory
|
|
$is_lo_core_dir=1 if (-f "$source_dir/autogen.sh" && -f "$source_dir/set_soenv.in");
|
|
|
|
# all tarballs are generated from the libreoffice-core directory
|
|
if (@pieces > 1 && $is_lo_core_dir == 0 ) {
|
|
die "Error: \"$source_dir\" is not a valid libreoffice-core directory\n";
|
|
}
|
|
|
|
# just a single piece tarball can be generated from piece directory; version must be explicitly set in this case
|
|
if (@pieces == 1 && $is_lo_core_dir == 0 && ! defined $set_version ) {
|
|
die "Error: version must be set using the --set-version=<version> option\n" unless (defined $set_version);
|
|
}
|
|
|
|
if (defined $set_version && defined $inc_version) {
|
|
die "Error: --set-version and --inc-version options can't be used together\n";
|
|
}
|
|
|
|
# default compression
|
|
$xz = 1 unless (defined $xz || defined $bzip2);
|
|
|
|
|
|
###################
|
|
# Main logic
|
|
###################
|
|
|
|
|
|
print "Source: $source_dir\n" if ($verbose);
|
|
|
|
if ($is_lo_core_dir) {
|
|
# detect some paths
|
|
$releases_state_file = default_releases_state_file($source_dir) unless (defined $releases_state_file);
|
|
|
|
# detect versions
|
|
$config_version = get_config_version($source_dir);
|
|
($state_config_version, $state_release_version) = load_releases_state($releases_state_file);
|
|
if (defined $set_version) {
|
|
$release_version = "$set_version";
|
|
} else {
|
|
$release_version = get_release_version($config_version, $state_config_version, $state_release_version, $inc_version);
|
|
}
|
|
} else {
|
|
# must be single piece release with predefined version
|
|
$release_version = "$set_version";
|
|
}
|
|
|
|
# define tarball names
|
|
$lo_core_tarball_name = "libreoffice-core-$release_version";
|
|
foreach my $piece (@pieces) {
|
|
if (-d "$source_dir/clone/$piece") {
|
|
$piece_tarball_name{$piece} = "libreoffice-$piece-$release_version";
|
|
} else {
|
|
print "Warning: $piece sources are not available -> skipping\n";
|
|
}
|
|
}
|
|
|
|
print "Default version : $config_version\n" if ($verbose && defined $config_version);
|
|
print "Last used version : $state_release_version\n" if ($verbose && defined $state_release_version);
|
|
print "New version : $release_version\n" if ($verbose);
|
|
|
|
# do the real job
|
|
if ( defined $get_config_version ) {
|
|
print "$release_version\n";
|
|
} else {
|
|
check_if_already_released($lo_core_tarball_name, \%piece_tarball_name, $force, $bzip2, $xz, $pack_lo_core, $pack_lo_pieces);
|
|
|
|
# give a chance to stop the process
|
|
print ("\nWaiting 3 seconds...\n");
|
|
sleep 3;
|
|
|
|
generate_tarballs($source_dir, $release_version, $md5, $bzip2, $xz, $lo_core_tarball_name, \%piece_tarball_name, $pack_lo_core, $pack_lo_pieces, $is_lo_core_dir);
|
|
|
|
if ( defined $releases_state_file ) {
|
|
save_releases_state($releases_state_file, $config_version, $release_version);
|
|
}
|
|
}
|