[BACK]Return to release-rsync CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync / packaging

Diff for /embedaddon/rsync/packaging/release-rsync between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2016/11/01 09:54:32 version 1.1.1.4, 2021/03/17 00:32:36
Line 1 Line 1
#!/usr/bin/perl#!/usr/bin/env -S python3 -B
 
 # This script expects the directory ~/samba-rsync-ftp to exist and to be a  # This script expects the directory ~/samba-rsync-ftp to exist and to be a
 # copy of the /home/ftp/pub/rsync dir on samba.org.  When the script is done,  # copy of the /home/ftp/pub/rsync dir on samba.org.  When the script is done,
 # the git repository in the current directory will be updated, and the local  # the git repository in the current directory will be updated, and the local
 # ~/samba-rsync-ftp dir will be ready to be rsynced to samba.org.  # ~/samba-rsync-ftp dir will be ready to be rsynced to samba.org.
   
use strict;import os, sys, re, argparse, glob, shutil, signal
use warnings;from datetime import datetime
use Cwd;from getpass import getpass
use Getopt::Long; 
use Term::ReadKey; 
use Date::Format; 
   
my $dest = $ENV{HOME} . '/samba-rsync-ftp';sys.path = ['packaging'] + sys.path
my $passfile = $ENV{HOME} . '/.rsyncpass'; 
my $path = $ENV{PATH}; 
my $make_gen_cmd = 'make -f prepare-source.mak conf && ./config.status && make gen'; 
   
&Getopt::Long::Configure('bundling');from pkglib import *
&usage if !&GetOptions( 
    'branch|b=s' => \( my $master_branch = 'master' ), 
    'help|h' => \( my $help_opt ), 
); 
&usage if $help_opt; 
   
my $now = time;os.environ['LESS'] = 'mqeiXR'; # Make sure that -F is turned off and -R is turned on.
my $cl_today = time2str('* %a %b %d %Y', $now);dest = os.environ['HOME'] + '/samba-rsync-ftp'
my $year = time2str('%Y', $now);ORIGINAL_PATH = os.environ['PATH']
my $ztoday = time2str('%d %b %Y', $now); 
(my $today = $ztoday) =~ s/^0//; 
   
my $curdir = Cwd::cwd;def main():
     now = datetime.now()
     cl_today = now.strftime('* %a %b %d %Y')
     year = now.strftime('%Y')
     ztoday = now.strftime('%d %b %Y')
     today = ztoday.lstrip('0')
   
END {    mandate_gensend_hook()
    unlink($passfile); 
} 
   
my @extra_files;    curdir = os.getcwd()
open(IN, '<', 'Makefile.in') or die "Couldn't open Makefile.in: $!\n"; 
while (<IN>) { 
    if (s/^GENFILES=//) { 
        while (s/\\$//) { 
            $_ .= <IN>; 
        } 
        @extra_files = split(' ', $_); 
        last; 
    } 
} 
close IN; 
   
my $break = <<EOT;    signal.signal(signal.SIGINT, signal_handler)
========================================================================== 
EOT 
   
print $break, <<EOT, $break, "\n";    if cmd_txt_chk(['packaging/prep-auto-dir']) == '':
         die('You must setup an auto-build-save dir to use this script.');
 
     auto_dir, gen_files = get_gen_files(True)
     gen_pathnames = [ os.path.join(auto_dir, fn) for fn in gen_files ]
 
     dash_line = '=' * 74
 
     print(f"""\
 {dash_line}
 == This will release a new version of rsync onto an unsuspecting world. ==  == This will release a new version of rsync onto an unsuspecting world. ==
EOT{dash_line}
 """)
   
die "$dest does not exist\n" unless -d $dest;    if not os.path.isdir(dest):
die "There is no .git dir in the current directory.\n" unless -d '.git';        die(dest, "dest does not exist")
die "'a' must not exist in the current directory.\n" if -e 'a';    if not os.path.isdir('.git'):
die "'b' must not exist in the current directory.\n" if -e 'b';        die("There is no .git dir in the current directory.")
     if os.path.lexists('a'):
         die('"a" must not exist in the current directory.')
     if os.path.lexists('b'):
         die('"b" must not exist in the current directory.')
     if os.path.lexists('patches.gen'):
         die('"patches.gen" must not exist in the current directory.')
   
require 'packaging/git-status.pl';    check_git_state(args.master_branch, True, 'patches')
check_git_state($master_branch, 1, 1); 
   
my $confversion;    curversion = get_rsync_version()
open(IN, '<', 'configure.ac') or die $!; 
while (<IN>) { 
    if (/^AC_INIT\(\[rsync\],\s*\[(\d.+?)\]/) { 
        $confversion = $1; 
        last; 
    } 
} 
close IN; 
die "Unable to find AC_INIT with version in configure.ac\n" unless defined $confversion; 
   
open(IN, '<', 'OLDNEWS') or die $!;    # All version values are strings!
$_ = <IN>;    lastversion, last_protocol_version, pdate = get_NEWS_version_info()
my($lastversion) = /(\d+\.\d+\.\d+)/;    protocol_version, subprotocol_version = get_protocol_versions()
my($last_protocol_version, %pdate); 
while (<IN>) { 
    if (my($ver,$pdate,$pver) = /^\s+\S\S\s\S\S\S\s\d\d\d\d\s+(\d+\.\d+\.\d+)\s+(\d\d \w\w\w \d\d\d\d\s+)?(\d+)$/) { 
        $pdate{$ver} = $pdate if defined $pdate; 
        $last_protocol_version = $pver if $ver eq $lastversion; 
    } 
} 
close IN; 
die "Unable to determine protocol_version for $lastversion.\n" unless defined $last_protocol_version; 
   
my $protocol_version;    version = curversion
open(IN, '<', 'rsync.h') or die $!;    m = re.search(r'pre(\d+)', version)
while (<IN>) {    if m:
    if (/^#define\s+PROTOCOL_VERSION\s+(\d+)/) {        version = re.sub(r'pre\d+', 'pre' + str(int(m[1]) + 1), version)
        $protocol_version = $1;    else:
        last;        version = version.replace('dev', 'pre1')
    } 
} 
close IN; 
die "Unable to determine the current PROTOCOL_VERSION.\n" unless defined $protocol_version; 
   
my $version = $confversion;    ans = input(f"Please enter the version number of this release: [{version}] ")
$version =~ s/dev/pre1/ || $version =~ s/pre(\d+)/ 'pre' . ($1 + 1) /e;    if ans == '.':
         version = re.sub(r'pre\d+', '', version)
     elif ans != '':
         version = ans
     if not re.match(r'^[\d.]+(pre\d+)?$', version):
         die(f'Invalid version: "{version}"')
   
print "Please enter the version number of this release: [$version] ";    v_ver = 'v' + version
chomp($_ = <STDIN>);    rsync_ver = 'rsync-' + version
if ($_ eq '.') { 
    $version =~ s/pre\d+//; 
} elsif ($_ ne '') { 
    $version = $_; 
} 
die "Invalid version: `$version'\n" unless $version =~ /^[\d.]+(pre\d+)?$/; 
   
if (`git tag -l v$version` ne '') {    if os.path.lexists(rsync_ver):
    print "Tag v$version already exists.\n\nDelete tag or quit? [q/del] ";        die(f'"{rsync_ver}" must not exist in the current directory.')
    $_ = <STDIN>; 
    exit 1 unless /^del/i; 
    system "git tag -d v$version"; 
} 
   
if ($version =~ s/[-.]*pre[-.]*/pre/ && $confversion !~ /dev$/) {    out = cmd_txt_chk(['git', 'tag', '-l', v_ver])
    $lastversion = $confversion;    if out != '':
}        print(f"Tag {v_ver} already exists.")
         ans = input("\nDelete tag or quit? [Q/del] ")
         if not re.match(r'^del', ans, flags=re.I):
             die("Aborted")
         cmd_chk(['git', 'tag', '-d', v_ver])
   
print "Enter the previous version to produce a patch against: [$lastversion] ";    version = re.sub(r'[-.]*pre[-.]*', 'pre', version)
chomp($_ = <STDIN>);    if 'pre' in version and not curversion.endswith('dev'):
$lastversion = $_ if $_ ne '';        lastversion = curversion
$lastversion =~ s/[-.]*pre[-.]*/pre/; 
   
my $pre = $version =~ /(pre\d+)/ ? $1 : '';    ans = input(f"Enter the previous version to produce a patch against: [{lastversion}] ")
     if ans != '':
         lastversion = ans
     lastversion = re.sub(r'[-.]*pre[-.]*', 'pre', lastversion)
   
my $release = $pre ? '0.1' : '1';    rsync_lastver = 'rsync-' + lastversion
print "Please enter the RPM release number of this release: [$release] ";    if os.path.lexists(rsync_lastver):
chomp($_ = <STDIN>);        die(f'"{rsync_lastver}" must not exist in the current directory.')
$release = $_ if $_ ne ''; 
$release .= ".$pre" if $pre; 
   
(my $finalversion = $version) =~ s/pre\d+//;    m = re.search(r'(pre\d+)', version)
my($proto_changed,$proto_change_date);    pre = m[1] if m else ''
if ($protocol_version eq $last_protocol_version) { 
    $proto_changed = 'unchanged'; 
    $proto_change_date = "\t\t"; 
} else { 
    $proto_changed = 'changed'; 
    if (!defined($proto_change_date = $pdate{$finalversion})) { 
        while (1) { 
            print "On what date did the protocol change to $protocol_version get checked in? (dd Mmm yyyy) "; 
            chomp($_ = <STDIN>); 
            last if /^\d\d \w\w\w \d\d\d\d$/; 
        } 
        $proto_change_date = "$_\t"; 
    } 
} 
   
my($srcdir,$srcdiffdir,$lastsrcdir,$skipping);    release = '0.1' if pre else '1'
if ($lastversion =~ /pre/) {    ans = input(f"Please enter the RPM release number of this release: [{release}] ")
    if (!$pre) {    if ans != '':
        die "You should not diff a release version against a pre-release version.\n";        release = ans
    }    if pre:
    $srcdir = $srcdiffdir = $lastsrcdir = 'src-previews';        release += '.' + pre
    $skipping = ' ** SKIPPING **'; 
} elsif ($pre) { 
    $srcdir = $srcdiffdir = 'src-previews'; 
    $lastsrcdir = 'src'; 
    $skipping = ' ** SKIPPING **'; 
} else { 
    $srcdir = $lastsrcdir = 'src'; 
    $srcdiffdir = 'src-diffs'; 
    $skipping = ''; 
} 
   
print "\n", $break, <<EOT;    finalversion = re.sub(r'pre\d+', '', version)
\$version is "$version"    proto_changed = protocol_version != last_protocol_version
\$lastversion is "$lastversion"    if proto_changed:
\$dest is "$dest"        if finalversion in pdate:
\$curdir is "$curdir"            proto_change_date = pdate[finalversion]
\$srcdir is "$srcdir"        else:
\$srcdiffdir is "$srcdiffdir"            while True:
\$lastsrcdir is "$lastsrcdir"                ans = input("On what date did the protocol change to {protocol_version} get checked in? (dd Mmm yyyy) ")
\$release is "$release"                if re.match(r'^\d\d \w\w\w \d\d\d\d$', ans):
                     break
             proto_change_date = ans
     else:
         proto_change_date = ' ' * 11
   
       if 'pre' in lastversion:
           if not pre:
               die("You should not diff a release version against a pre-release version.")
           srcdir = srcdiffdir = lastsrcdir = 'src-previews'
           skipping = ' ** SKIPPING **'
       elif pre:
           srcdir = srcdiffdir = 'src-previews'
           lastsrcdir = 'src'
           skipping = ' ** SKIPPING **'
       else:
           srcdir = lastsrcdir = 'src'
           srcdiffdir = 'src-diffs'
           skipping = ''
   
       print(f"""
   {dash_line}
   version is "{version}"
   lastversion is "{lastversion}"
   dest is "{dest}"
   curdir is "{curdir}"
   srcdir is "{srcdir}"
   srcdiffdir is "{srcdiffdir}"
   lastsrcdir is "{lastsrcdir}"
   release is "{release}"
   
 About to:  About to:
     - tweak SUBPROTOCOL_VERSION in rsync.h, if needed      - tweak SUBPROTOCOL_VERSION in rsync.h, if needed
    - tweak the version in configure.ac and the spec files    - tweak the version in version.h and the spec files
    - tweak NEWS and OLDNEWS to ensure header values are correct    - tweak NEWS.md to ensure header values are correct
    - tweak the date in the *.yo files and generate the manpages 
     - generate configure.sh, config.h.in, and proto.h      - generate configure.sh, config.h.in, and proto.h
     - page through the differences      - page through the differences
   """)
       ans = input("<Press Enter to continue> ")
   
EOT    specvars = {
print "<Press Enter to continue> ";        'Version:': finalversion,
$_ = <STDIN>;        'Release:': release,
         '%define fullversion': f'%{{version}}{pre}',
         'Released': version + '.',
         '%define srcdir': srcdir,
         }
   
my %specvars = ( 'Version:' => $finalversion, 'Release:' => $release,    tweak_files = 'version.h rsync.h NEWS.md'.split()
                 '%define fullversion' => "\%{version}$pre", 'Released' => "$version.",    tweak_files += glob.glob('packaging/*.spec')
                 '%define srcdir' => $srcdir );    tweak_files += glob.glob('packaging/*/*.spec')
my @tweak_files = ( glob('packaging/*.spec'), glob('packaging/*/*.spec'), glob('*.yo'), 
                    qw( configure.ac rsync.h NEWS OLDNEWS options.c ) ); 
   
foreach my $fn (@tweak_files) {    for fn in tweak_files:
    open(IN, '<', $fn) or die $!;        with open(fn, 'r', encoding='utf-8') as fh:
    undef $/; $_ = <IN>; $/ = "\n";            old_txt = txt = fh.read()
    close IN;        if fn == 'version.h':
    if ($fn =~ /configure/) {            txt = f'#define RSYNC_VERSION "{version}"\n'
        s/^(AC_INIT\(\[rsync\],\s*\[)\d.+?(\])/$1$version$2/m        elif '.spec' in fn:
            or die "Unable to update AC_INIT with version in $fn\n";            for var, val in specvars.items():
    } elsif ($fn =~ /\.spec/) {                x_re = re.compile(r'^%s .*' % re.escape(var), re.M)
        while (my($str, $val) = each %specvars) {                txt = replace_or_die(x_re, var + ' ' + val, txt, f"Unable to update {var} in {fn}")
            s/^\Q$str\E .*/$str $val/m            x_re = re.compile(r'^\* \w\w\w \w\w\w \d\d \d\d\d\d (.*)', re.M)
                or die "Unable to update $str in $fn\n";            txt = replace_or_die(x_re, r'%s \1' % cl_today, txt, f"Unable to update ChangeLog header in {fn}")
        }        elif fn == 'rsync.h':
        s/^\* \w\w\w \w\w\w \d\d \d\d\d\d (.*)/$cl_today $1/m            x_re = re.compile('(#define\s+SUBPROTOCOL_VERSION)\s+(\d+)')
            or die "Unable to update ChangeLog header in $fn\n";            repl = lambda m: m[1] + ' ' + ('0' if not pre or not proto_changed else '1' if m[2] == '0' else m[2])
    } elsif ($fn =~ /\.yo/) {            txt = replace_or_die(x_re, repl, txt, f"Unable to find SUBPROTOCOL_VERSION define in {fn}")
        s/^(manpage\([^)]+\)\(\d+\)\()[^)]+(\).*)/$1$today$2/m        elif fn == 'NEWS.md':
            or die "Unable to update date in manpage() header in $fn\n";            efv = re.escape(finalversion)
        s/^(This man ?page is current for version) \S+ (of rsync)/$1 $version $2/m            x_re = re.compile(r'^<.+>\s+# NEWS for rsync %s \(UNRELEASED\)\s+## Changes in this version:\n' % efv
            or die "Unable to update current version info in $fn\n";                    + r'(\n### PROTOCOL NUMBER:\s+- The protocol number was changed to \d+\.\n)?')
    } elsif ($fn eq 'rsync.h') {            rel_day = 'UNRELEASED' if pre else today
        s{(#define\s+SUBPROTOCOL_VERSION)\s+(\d+)}            repl = (f'<a name="{finalversion}"></a>\n\n# NEWS for rsync {finalversion} ({rel_day})\n\n'
         { $1 . ' ' . get_subprotocol_version($2) }e                + '## Changes in this version:\n')
            or die "Unable to find SUBPROTOCOL_VERSION define in $fn\n";            if proto_changed:
    } elsif ($fn eq 'NEWS') {                repl += f'\n### PROTOCOL NUMBER:\n\n - The protocol number was changed to {protocol_version}.\n'
        s{^(NEWS for rsync \Q$finalversion\E )(\(UNRELEASED\))\s*(\nProtocol: )(\d+) (\([^)]+\))\n}            good_top = re.sub(r'\(.*?\)', '(UNRELEASED)', repl, 1)
         { $1 . ($pre ? $2 : "($today)") . "$3$protocol_version ($proto_changed)\n" }ei            msg = f"The top lines of {fn} are not in the right format.  It should be:\n" + good_top
            or die "The first 2 lines of $fn are not in the right format.  They must be:\n"            txt = replace_or_die(x_re, repl, txt, msg)
                 . "NEWS for rsync $finalversion (UNRELEASED)\n"            x_re = re.compile(r'^(\| )(\S{2} \S{3} \d{4})(\s+\|\s+%s\s+\| ).{11}(\s+\| )\S{2}(\s+\|+)$' % efv, re.M)
                 . "Protocol: $protocol_version ($proto_changed)\n";            repl = lambda m: m[1] + (m[2] if pre else ztoday) + m[3] + proto_change_date + m[4] + protocol_version + m[5]
    } elsif ($fn eq 'OLDNEWS') {            txt = replace_or_die(x_re, repl, txt, f'Unable to find "| ?? ??? {year} | {finalversion} | ... |" line in {fn}')
        s{^(\t\S\S\s\S\S\S\s\d\d\d\d)(\t\Q$finalversion\E\t).*}        else:
         { ($pre ? $1 : "\t$ztoday") . $2 . $proto_change_date . $protocol_version }em            die(f"Unrecognized file in tweak_files: {fn}")
            or die "Unable to find \"?? ??? $year\t$finalversion\" line in $fn\n"; 
    } elsif ($fn eq 'options.c') { 
        if (s/(Copyright \(C\) 2002-)(\d+)( Wayne Davison)/$1$year$3/ 
         && $2 ne $year) { 
            die "Copyright comments need to be updated to $year in all files!\n"; 
        } 
        # Adjust the year in the --version output. 
        s/(rprintf\(f, "Copyright \(C\) 1996-)(\d+)/$1$year/ 
            or die "Unable to find Copyright string in --version output of $fn\n"; 
        next if $2 eq $year; 
    } else { 
        die "Unrecognized file in \@tweak_files: $fn\n"; 
    } 
    open(OUT, '>', $fn) or die $!; 
    print OUT $_; 
    close OUT; 
} 
   
print $break;        if txt != old_txt:
system "git diff --color | less -p '^diff .*'";            print(f"Updating {fn}")
             with open(fn, 'w', encoding='utf-8') as fh:
                 fh.write(txt)
   
my $srctar_name = "rsync-$version.tar.gz";    cmd_chk(['packaging/year-tweak'])
my $pattar_name = "rsync-patches-$version.tar.gz"; 
my $diff_name = "rsync-$lastversion-$version.diffs.gz"; 
my $srctar_file = "$dest/$srcdir/$srctar_name"; 
my $pattar_file = "$dest/$srcdir/$pattar_name"; 
my $diff_file = "$dest/$srcdiffdir/$diff_name"; 
my $news_file = "$dest/$srcdir/rsync-$version-NEWS"; 
my $lasttar_file = "$dest/$lastsrcdir/rsync-$lastversion.tar.gz"; 
   
print $break, <<EOT;    print(dash_line)
     cmd_run("git diff --color | less -p '^diff .*'")
   
       srctar_name = f"{rsync_ver}.tar.gz"
       pattar_name = f"rsync-patches-{version}.tar.gz"
       diff_name = f"{rsync_lastver}-{version}.diffs.gz"
       srctar_file = os.path.join(dest, srcdir, srctar_name)
       pattar_file = os.path.join(dest, srcdir, pattar_name)
       diff_file = os.path.join(dest, srcdiffdir, diff_name)
       lasttar_file = os.path.join(dest, lastsrcdir, rsync_lastver + '.tar.gz')
   
       print(f"""\
   {dash_line}
   
 About to:  About to:
    - commit all version changes    - git commit all changes
    - merge the $master_branch branch into the patch/$master_branch/* branches    - generate the manpages
    - update the files in the "patches" dir and OPTIONALLY    - merge the {args.master_branch} branch into the patch/{args.master_branch}/* branches
      (if you type 'y') to launch a shell for each patch    - update the files in the "patches" dir and OPTIONALLY (if you type 'y') to
       run patch-update with the --make option (which opens a shell on error)
 """)
     ans = input("<Press Enter OR 'y' to continue> ")
   
EOT    s = cmd_run(['git', 'commit', '-a', '-m', f'Preparing for release of {version}'])
print "<Press Enter OR 'y' to continue> ";    if s.returncode:
my $ans = <STDIN>;        die('Aborting')
   
system "git commit -a -m 'Preparing for release of $version'" and exit 1;    cmd_chk('make gen')
   
print "Updating files in \"patches\" dir ...\n";    print(f'Creating any missing patch branches.')
system "packaging/patch-update --branch=$master_branch";    s = cmd_run(f'packaging/branch-from-patch --branch={args.master_branch} --add-missing')
     if s.returncode:
         die('Aborting')
   
if ($ans =~ /^y/i) {    print('Updating files in "patches" dir ...')
    print "\nVisiting all \"patch/$master_branch/*\" branches ...\n";    s = cmd_run(f'packaging/patch-update --branch={args.master_branch}')
    system "packaging/patch-update --branch=$master_branch --skip-check --shell";    if s.returncode:
}        die('Aborting')
   
if (-d 'patches/.git') {    if re.match(r'^y', ans, re.I):
    system "cd patches && git commit -a -m 'The patches for $version.'" and exit 1;        print(f'\nRunning smart-make on all "patch/{args.master_branch}/*" branches ...')
}        cmd_run(f"packaging/patch-update --branch={args.master_branch} --skip-check --make")
   
print $break, <<EOT;    if os.path.isdir('patches/.git'):
         s = cmd_run(f"cd patches && git commit -a -m 'The patches for {version}.'")
         if s.returncode:
             die('Aborting')
   
       print(f"""\
   {dash_line}
   
 About to:  About to:
    - create signed tag for this release: v$version    - create signed tag for this release: {v_ver}
    - create release diffs, "$diff_name"    - create release diffs, "{diff_name}"
    - create release tar, "$srctar_name"    - create release tar, "{srctar_name}"
    - generate rsync-$version/patches/* files    - generate {rsync_ver}/patches/* files
    - create patches tar, "$pattar_name"    - create patches tar, "{pattar_name}"
    - update top-level README, *NEWS, TODO, and ChangeLog    - update top-level README.md, NEWS.md, TODO, and ChangeLog
     - update top-level rsync*.html manpages      - update top-level rsync*.html manpages
     - gpg-sign the release files      - gpg-sign the release files
    - update hard-linked top-level release files$skipping    - update hard-linked top-level release files{skipping}
 """)
     ans = input("<Press Enter to continue> ")
   
EOT    # TODO: is there a better way to ensure that our passphrase is in the agent?
print "<Press Enter to continue> ";    cmd_run("touch TeMp; gpg --sign TeMp; rm TeMp*")
$_ = <STDIN>; 
   
# We want to use our passphrase-providing "gpg" script, so modify the PATH.    out = cmd_txt(f"git tag -s -m 'Version {version}.' {v_ver}", capture='combined')
$ENV{PATH} = "$curdir/packaging/bin:$path";    print(out, end='')
     if 'bad passphrase' in out or 'failed' in out:
         die('Aborting')
   
my $passphrase;    if os.path.isdir('patches/.git'):
while (1) {        out = cmd_txt(f"cd patches && git tag -s -m 'Version {version}.' {v_ver}", capture='combined')
    ReadMode('noecho');        print(out, end='')
    print "\nEnter your GPG pass-phrase: ";        if 'bad passphrase' in out or 'failed' in out:
    chomp($passphrase = <STDIN>);            die('Aborting')
    ReadMode(0); 
    print "\n"; 
   
    # Briefly create a temp file with the passphrase for git's tagging use.    os.environ['PATH'] = ORIGINAL_PATH
    my $oldmask = umask 077; 
    unlink($passfile); 
    open(OUT, '>', $passfile) or die $!; 
    print OUT $passphrase, "\n"; 
    close OUT; 
    umask $oldmask; 
    $ENV{'GPG_PASSFILE'} = $passfile; 
   
    $_ = `git tag -s -m 'Version $version.' v$version 2>&1`;    # Extract the generated files from the old tar.
    print $_;    tweaked_gen_files = [ os.path.join(rsync_lastver, fn) for fn in gen_files ]
    next if /bad passphrase/;    cmd_run(['tar', 'xzf', lasttar_file, *tweaked_gen_files])
    exit 1 if /failed/;    os.rename(rsync_lastver, 'a')
   
    if (-d 'patches/.git') {    print(f"Creating {diff_file} ...")
        $_ = `cd patches && git tag -s -m 'Version $version.' v$version 2>&1`;    cmd_chk(['rsync', '-a', *gen_pathnames, 'b/'])
        print $_; 
        exit 1 if /bad passphrase|failed/; 
    } 
   
    unlink($passfile);    sed_script = r's:^((---|\+\+\+) [ab]/[^\t]+)\t.*:\1:' # CAUTION: must not contain any single quotes!
    last;    cmd_chk(f"(git diff v{lastversion} {v_ver} -- ':!.github'; diff -upN a b | sed -r '{sed_script}') | gzip -9 >{diff_file}")
}    shutil.rmtree('a')
     os.rename('b', rsync_ver)
   
$ENV{PATH} = $path;    print(f"Creating {srctar_file} ...")
     cmd_chk(f"git archive --format=tar --prefix={rsync_ver}/ {v_ver} | tar xf -")
     cmd_chk(f"support/git-set-file-times --quiet --prefix={rsync_ver}/")
     cmd_chk(['fakeroot', 'tar', 'czf', srctar_file, '--exclude=.github', rsync_ver])
     shutil.rmtree(rsync_ver)
   
# Extract the generated files from the old tar.    print(f'Updating files in "{rsync_ver}/patches" dir ...')
@_ = @extra_files;    os.mkdir(rsync_ver, 0o755)
map { s#^#rsync-$lastversion/# } @_;    os.mkdir(f"{rsync_ver}/patches", 0o755)
system "tar xzf $lasttar_file @_";    cmd_chk(f"packaging/patch-update --skip-check --branch={args.master_branch} --gen={rsync_ver}/patches".split())
rename("rsync-$lastversion", 'a'); 
   
print "Creating $diff_file ...\n";    print(f"Creating {pattar_file} ...")
system "$make_gen_cmd && rsync -a @extra_files b/" and exit 1;    cmd_chk(['fakeroot', 'tar', 'chzf', pattar_file, rsync_ver + '/patches'])
my $sed_script = 's:^((---|\+\+\+) [ab]/[^\t]+)\t.*:\1:';    shutil.rmtree(rsync_ver)
system "(git diff v$lastversion v$version; diff -upN a b | sed -r '$sed_script') | gzip -9 >$diff_file"; 
system "rm -rf a"; 
rename('b', "rsync-$version"); 
   
print "Creating $srctar_file ...\n";    print(f"Updating the other files in {dest} ...")
system "git archive --format=tar --prefix=rsync-$version/ v$version | tar xf -";    md_files = 'README.md NEWS.md INSTALL.md'.split()
system "support/git-set-file-times --prefix=rsync-$version/";    html_files = [ fn for fn in gen_pathnames if fn.endswith('.html') ]
system "fakeroot tar czf $srctar_file rsync-$version; rm -rf rsync-$version";    cmd_chk(['rsync', '-a', *md_files, *html_files, dest])
     cmd_chk(["packaging/md2html"] + [ dest +'/'+ fn for fn in md_files ])
   
print "Updating files in \"rsync-$version/patches\" dir ...\n";    cmd_chk(f"git log --name-status | gzip -9 >{dest}/ChangeLog.gz")
mkdir("rsync-$version", 0755); 
mkdir("rsync-$version/patches", 0755); 
system "packaging/patch-update --skip-check --branch=$master_branch --gen=rsync-$version/patches"; 
   
print "Creating $pattar_file ...\n";    for fn in (srctar_file, pattar_file, diff_file):
system "fakeroot tar chzf $pattar_file rsync-$version/patches; rm -rf rsync-$version";        asc_fn = fn + '.asc'
         if os.path.lexists(asc_fn):
             os.unlink(asc_fn)
         res = cmd_run(['gpg', '--batch', '-ba', fn])
         if res.returncode != 0 and res.returncode != 2:
             die("gpg signing failed")
   
print "Updating the other files in $dest ...\n";    if not pre:
system "rsync -a README NEWS OLDNEWS TODO $dest";        for find in f'{dest}/rsync-*.gz {dest}/rsync-*.asc {dest}/src-previews/rsync-*diffs.gz*'.split():
unlink($news_file);            for fn in glob.glob(find):
link("$dest/NEWS", $news_file);                os.unlink(fn)
system "git log --name-status | gzip -9 >$dest/ChangeLog.gz";        top_link = [
                 srctar_file, f"{srctar_file}.asc",
                 pattar_file, f"{pattar_file}.asc",
                 diff_file, f"{diff_file}.asc",
                 ]
         for fn in top_link:
             os.link(fn, re.sub(r'/src(-\w+)?/', '/', fn))
   
system "yodl2html -o $dest/rsync.html rsync.yo";    print(f"""\
system "yodl2html -o $dest/rsyncd.conf.html rsyncd.conf.yo";{dash_line}
   
 foreach my $fn ($srctar_file, $pattar_file, $diff_file) {  
     unlink("$fn.asc");  
     open(GPG, '|-', "gpg --batch --passphrase-fd=0 -ba $fn") or die $!;  
     print GPG $passphrase, "\n";  
     close GPG;  
 }  
   
 if (!$pre) {  
     system "rm $dest/rsync-*.gz $dest/rsync-*.asc $dest/rsync-*-NEWS $dest/src-previews/rsync-*diffs.gz*";  
   
     foreach my $fn ($srctar_file, "$srctar_file.asc",  
                     $pattar_file, "$pattar_file.asc",  
                     $diff_file, "$diff_file.asc", $news_file) {  
         (my $top_fn = $fn) =~ s#/src(-\w+)?/#/#;  
         link($fn, $top_fn);  
     }  
 }  
   
 print $break, <<'EOT';  
   
 Local changes are done.  When you're satisfied, push the git repository  Local changes are done.  When you're satisfied, push the git repository
 and rsync the release files.  Remember to announce the release on *BOTH*  and rsync the release files.  Remember to announce the release on *BOTH*
 rsync-announce@lists.samba.org and rsync@lists.samba.org (and the web)!  rsync-announce@lists.samba.org and rsync@lists.samba.org (and the web)!
EOT""")
   
 exit;  
   
sub get_subprotocol_versiondef replace_or_die(regex, repl, txt, die_msg):
{    m = regex.search(txt)
    my($subver) = @_;    if not m:
    if ($pre && $proto_changed eq 'changed') {        die(die_msg)
        return $subver == 0 ? 1 : $subver;    return regex.sub(repl, txt, 1)
    } 
    0; 
} 
   
 sub usage  
 {  
     die <<EOT;  
 Usage: release-rsync [OPTIONS]  
   
-b, --branch=BRANCH   The branch to release (default: master)def signal_handler(sig, frame):
-h, --help            Display this help message    die("\nAborting due to SIGINT.")
EOT
}
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description="Prepare a new release of rsync in the git repo & ftp dir.", add_help=False)
     parser.add_argument('--branch', '-b', dest='master_branch', default='master', help="The branch to release. Default: master.")
     parser.add_argument("--help", "-h", action="help", help="Output this help message and exit.")
     args = parser.parse_args()
     main()
 
 # vim: sw=4 et ft=python
Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>