git-archimport.perl

   1 #!/usr/bin/perl -w
   2 #
   3 # This tool is copyright (c) 2005, Martin Langhoff.
   4 # It is released under the Gnu Public License, version 2.
   5 #
   6 # The basic idea is to walk the output of tla abrowse,
   7 # fetch the changesets and apply them.
   8 #
   9
  10 =head1 Invocation
  11
  12     git-archimport [ -h ] [ -v ] [ -T ] [ -t tempdir ] <archive>/<branch> [ <archive>/<branch> ]
  13
  14 Imports a project from one or more Arch repositories. It will follow branches
  15 and repositories within the namespaces defined by the <archive/branch>
  16 parameters suppplied. If it cannot find the remote branch a merge comes from
  17 it will just import it as a regular commit. If it can find it, it will mark it
  18 as a merge whenever possible.
  19
  20 See man (1) git-archimport for more details.
  21
  22 =head1 TODO
  23
  24  - create tag objects instead of ref tags
  25  - audit shell-escaping of filenames
  26  - hide our private tags somewhere smarter
  27  - find a way to make "cat *patches | patch" safe even when patchfiles are missing newlines
  28
  29 =head1 Devel tricks
  30
  31 Add print in front of the shell commands invoked via backticks.
  32
  33 =head1 Devel Notes
  34
  35 There are several places where Arch and git terminology are intermixed
  36 and potentially confused.
  37
  38 The notion of a "branch" in git is approximately equivalent to
  39 a "archive/category--branch--version" in Arch.  Also, it should be noted
  40 that the "--branch" portion of "archive/category--branch--version" is really
  41 optional in Arch although not many people (nor tools!) seem to know this.
  42 This means that "archive/category--version" is also a valid "branch"
  43 in git terms.
  44
  45 We always refer to Arch names by their fully qualified variant (which
  46 means the "archive" name is prefixed.
  47
  48 For people unfamiliar with Arch, an "archive" is the term for "repository",
  49 and can contain multiple, unrelated branches.
  50
  51 =cut
  52
  53 use strict;
  54 use warnings;
  55 use Getopt::Std;
  56 use File::Spec;
  57 use File::Temp qw(tempfile tempdir);
  58 use File::Path qw(mkpath rmtree);
  59 use File::Basename qw(basename dirname);
  60 use Time::Local;
  61 use IO::Socket;
  62 use IO::Pipe;
  63 use POSIX qw(strftime dup2);
  64 use Data::Dumper qw/ Dumper /;
  65 use IPC::Open2;
  66
  67 $SIG{'PIPE'}="IGNORE";
  68 $ENV{'TZ'}="UTC";
  69
  70 my $git_dir = $ENV{"GIT_DIR"} || ".git";
  71 $ENV{"GIT_DIR"} = $git_dir;
  72 my $ptag_dir = "$git_dir/archimport/tags";
  73
  74 our($opt_h,$opt_v, $opt_T,$opt_t,$opt_o);
  75
  76 sub usage() {
  77     print STDERR <<END;
  78 Usage: ${\basename $0}     # fetch/update GIT from Arch
  79        [ -o ] [ -h ] [ -v ] [ -T ] [ -t tempdir ]
  80        repository/arch-branch [ repository/arch-branch] ...
  81 END
  82     exit(1);
  83 }
  84
  85 getopts("Thvt:") or usage();
  86 usage if $opt_h;
  87
  88 @ARGV >= 1 or usage();
  89 my @arch_roots = @ARGV;
  90
  91 my ($tmpdir, $tmpdirname) = tempdir('git-archimport-XXXXXX', TMPDIR => 1, CLEANUP => 1);
  92 my $tmp = $opt_t || 1;
  93 $tmp = tempdir('git-archimport-XXXXXX', TMPDIR => 1, CLEANUP => 1);
  94 $opt_v && print "+ Using $tmp as temporary directory\n";
  95
  96 my @psets  = ();                # the collection
  97 my %psets  = ();                # the collection, by name
  98
  99 my %rptags = ();                # my reverse private tags
 100                                 # to map a SHA1 to a commitid
 101 my $TLA = $ENV{'ARCH_CLIENT'} || 'tla';
 102
 103 foreach my $root (@arch_roots) {
 104     my ($arepo, $abranch) = split(m!/!, $root);
 105     open ABROWSE, "tla abrowse -f -A $arepo --desc --merges $abranch |"
 106         or die "Problems with tla abrowse: $!";
 107
 108     my %ps        = ();         # the current one
 109     my $mode      = '';
 110     my $lastseen  = '';
 111
 112     while (<ABROWSE>) {
 113         chomp;
 114
 115         # first record padded w 8 spaces
 116         if (s/^\s{8}\b//) {
 117
 118             # store the record we just captured
 119             if (%ps) {
 120                 my %temp = %ps; # break references
 121                 push (@psets, \%temp);
 122                 $psets{$temp{id}} = \%temp;
 123                 %ps = ();
 124             }
 125
 126             my ($id, $type) = split(m/\s{3}/, $_);
 127             $ps{id}   = $id;
 128             $ps{repo} = $arepo;
 129
 130             # deal with types
 131             if ($type =~ m/^\(simple changeset\)/) {
 132                 $ps{type} = 's';
 133             } elsif ($type eq '(initial import)') {
 134                 $ps{type} = 'i';
 135             } elsif ($type =~ m/^\(tag revision of (.+)\)/) {
 136                 $ps{type} = 't';
 137                 $ps{tag}  = $1;
 138             } else {
 139                 warn "Unknown type $type";
 140             }
 141             $lastseen = 'id';
 142         }
 143
 144         if (s/^\s{10}//) {
 145             # 10 leading spaces or more
 146             # indicate commit metadata
 147
 148             # date & author
 149             if ($lastseen eq 'id' && m/^\d{4}-\d{2}-\d{2}/) {
 150
 151                 my ($date, $authoremail) = split(m/\s{2,}/, $_);
 152                 $ps{date}   = $date;
 153                 $ps{date}   =~ s/\bGMT$//; # strip off trailign GMT
 154                 if ($ps{date} =~ m/\b\w+$/) {
 155                     warn 'Arch dates not in GMT?! - imported dates will be wrong';
 156                 }
 157
 158                 $authoremail =~ m/^(.+)\s(\S+)$/;
 159                 $ps{author} = $1;
 160                 $ps{email}  = $2;
 161
 162                 $lastseen = 'date';
 163
 164             } elsif ($lastseen eq 'date') {
 165                 # the only hint is position
 166                 # subject is after date
 167                 $ps{subj} = $_;
 168                 $lastseen = 'subj';
 169
 170             } elsif ($lastseen eq 'subj' && $_ eq 'merges in:') {
 171                 $ps{merges} = [];
 172                 $lastseen = 'merges';
 173
 174             } elsif ($lastseen eq 'merges' && s/^\s{2}//) {
 175                 push (@{$ps{merges}}, $_);
 176             } else {
 177                 warn 'more metadata after merges!?';
 178             }
 179
 180         }
 181     }
 182
 183     if (%ps) {
 184         my %temp = %ps;         # break references
 185         push (@psets, \%temp);
 186         $psets{ $temp{id} } = \%temp;
 187         %ps = ();
 188     }
 189     close ABROWSE;
 190 }                               # end foreach $root
 191
 192 ## Order patches by time
 193 @psets = sort {$a->{date}.$b->{id} cmp $b->{date}.$b->{id}} @psets;
 194
 195 #print Dumper \@psets;
 196
 197 ##
 198 ## TODO cleanup irrelevant patches
 199 ##      and put an initial import
 200 ##      or a full tag
 201 my $import = 0;
 202 unless (-d $git_dir) { # initial import
 203     if ($psets[0]{type} eq 'i' || $psets[0]{type} eq 't') {
 204         print "Starting import from $psets[0]{id}\n";
 205         `git-init-db`;
 206         die $! if $?;
 207         $import = 1;
 208     } else {
 209         die "Need to start from an import or a tag -- cannot use $psets[0]{id}";
 210     }
 211 } else {    # progressing an import
 212     # load the rptags
 213     opendir(DIR, "$git_dir/archimport/tags")
 214         || die "can't opendir: $!";
 215     while (my $file = readdir(DIR)) {
 216         # skip non-interesting-files
 217         next unless -f "$ptag_dir/$file";
 218
 219         # convert first '--' to '/' from old git-archimport to use
 220         # as an archivename/c--b--v private tag
 221         if ($file !~ m!,!) {
 222             my $oldfile = $file;
 223             $file =~ s!--!,!;
 224             print STDERR "converting old tag $oldfile to $file\n";
 225             rename("$ptag_dir/$oldfile", "$ptag_dir/$file") or die $!;
 226         }
 227         my $sha = ptag($file);
 228         chomp $sha;
 229         $rptags{$sha} = $file;
 230     }
 231     closedir DIR;
 232 }
 233
 234 # process patchsets
 235 # extract the Arch repository name (Arch "archive" in Arch-speak)
 236 sub extract_reponame {
 237     my $fq_cvbr = shift; # archivename/[[[[category]branch]version]revision]
 238     return (split(/\//, $fq_cvbr))[0];
 239 }
 240
 241 sub extract_versionname {
 242     my $name = shift;
 243     $name =~ s/--(?:patch|version(?:fix)?|base)-\d+$//;
 244     return $name;
 245 }
 246
 247 # convert a fully-qualified revision or version to a unique dirname:
 248 #   normalperson@yhbt.net-05/mpd--uclinux--1--patch-2
 249 # becomes: normalperson@yhbt.net-05,mpd--uclinux--1
 250 #
 251 # the git notion of a branch is closer to
 252 # archive/category--branch--version than archive/category--branch, so we
 253 # use this to convert to git branch names.
 254 # Also, keep archive names but replace '/' with ',' since it won't require
 255 # subdirectories, and is safer than swapping '--' which could confuse
 256 # reverse-mapping when dealing with bastard branches that
 257 # are just archive/category--version  (no --branch)
 258 sub tree_dirname {
 259     my $revision = shift;
 260     my $name = extract_versionname($revision);
 261     $name =~ s#/#,#;
 262     return $name;
 263 }
 264
 265 # old versions of git-archimport just use the <category--branch> part:
 266 sub old_style_branchname {
 267     my $id = shift;
 268     my $ret = safe_pipe_capture($TLA,'parse-package-name','-p',$id);
 269     chomp $ret;
 270     return $ret;
 271 }
 272
 273 *git_branchname = $opt_o ? *old_style_branchname : *tree_dirname;
 274
 275 # process patchsets
 276 foreach my $ps (@psets) {
 277     $ps->{branch} = git_branchname($ps->{id});
 278
 279     #
 280     # ensure we have a clean state
 281     #
 282     if (`git diff-files`) {
 283         die "Unclean tree when about to process $ps->{id} " .
 284             " - did we fail to commit cleanly before?";
 285     }
 286     die $! if $?;
 287
 288     #
 289     # skip commits already in repo
 290     #
 291     if (ptag($ps->{id})) {
 292       $opt_v && print " * Skipping already imported: $ps->{id}\n";
 293       next;
 294     }
 295
 296     print " * Starting to work on $ps->{id}\n";
 297
 298     #
 299     # create the branch if needed
 300     #
 301     if ($ps->{type} eq 'i' && !$import) {
 302         die "Should not have more than one 'Initial import' per GIT import: $ps->{id}";
 303     }
 304
 305     unless ($import) { # skip for import
 306         if ( -e "$git_dir/refs/heads/$ps->{branch}") {
 307             # we know about this branch
 308             system('git-checkout',$ps->{branch});
 309         } else {
 310             # new branch! we need to verify a few things
 311             die "Branch on a non-tag!" unless $ps->{type} eq 't';
 312             my $branchpoint = ptag($ps->{tag});
 313             die "Tagging from unknown id unsupported: $ps->{tag}"
 314                 unless $branchpoint;
 315
 316             # find where we are supposed to branch from
 317             system('git-checkout','-b',$ps->{branch},$branchpoint);
 318
 319             # If we trust Arch with the fact that this is just
 320             # a tag, and it does not affect the state of the tree
 321             # then we just tag and move on
 322             tag($ps->{id}, $branchpoint);
 323             ptag($ps->{id}, $branchpoint);
 324             print " * Tagged $ps->{id} at $branchpoint\n";
 325             next;
 326         }
 327         die $! if $?;
 328     }
 329
 330     #
 331     # Apply the import/changeset/merge into the working tree
 332     #
 333     if ($ps->{type} eq 'i' || $ps->{type} eq 't') {
 334         apply_import($ps) or die $!;
 335         $import=0;
 336     } elsif ($ps->{type} eq 's') {
 337         apply_cset($ps);
 338     }
 339
 340     #
 341     # prepare update git's index, based on what arch knows
 342     # about the pset, resolve parents, etc
 343     #
 344     my $tree;
 345
 346     my $commitlog = safe_pipe_capture($TLA,'cat-archive-log',$ps->{id});
 347     die "Error in cat-archive-log: $!" if $?;
 348
 349     # parselog will git-add/rm files
 350     # and generally prepare things for the commit
 351     # NOTE: parselog will shell-quote filenames!
 352     my ($sum, $msg, $add, $del, $mod, $ren) = parselog($commitlog);
 353     my $logmessage = "$sum\n$msg";
 354
 355
 356     # imports don't give us good info
 357     # on added files. Shame on them
 358     if ($ps->{type} eq 'i' || $ps->{type} eq 't') {
 359         `find . -type f -print0 | grep -zv '^./$git_dir' | xargs -0 -l100 git-update-index --add`;
 360         `git-ls-files --deleted -z | xargs --no-run-if-empty -0 -l100 git-update-index --remove`;
 361     }
 362
 363     if (@$add) {
 364         while (@$add) {
 365             my @slice = splice(@$add, 0, 100);
 366             my $slice = join(' ', @slice);
 367             `git-update-index --add $slice`;
 368             die "Error in git-update-index --add: $!" if $?;
 369         }
 370     }
 371     if (@$del) {
 372         foreach my $file (@$del) {
 373             unlink $file or die "Problems deleting $file : $!";
 374         }
 375         while (@$del) {
 376             my @slice = splice(@$del, 0, 100);
 377             my $slice = join(' ', @slice);
 378             `git-update-index --remove $slice`;
 379             die "Error in git-update-index --remove: $!" if $?;
 380         }
 381     }
 382     if (@$ren) {                # renamed
 383         if (@$ren % 2) {
 384             die "Odd number of entries in rename!?";
 385         }
 386         ;
 387         while (@$ren) {
 388             my $from = pop @$ren;
 389             my $to   = pop @$ren;
 390
 391             unless (-d dirname($to)) {
 392                 mkpath(dirname($to)); # will die on err
 393             }
 394             #print "moving $from $to";
 395             `mv $from $to`;
 396             die "Error renaming $from $to : $!" if $?;
 397             `git-update-index --remove $from`;
 398             die "Error in git-update-index --remove: $!" if $?;
 399             `git-update-index --add $to`;
 400             die "Error in git-update-index --add: $!" if $?;
 401         }
 402
 403     }
 404     if (@$mod) {                # must be _after_ renames
 405         while (@$mod) {
 406             my @slice = splice(@$mod, 0, 100);
 407             my $slice = join(' ', @slice);
 408             `git-update-index $slice`;
 409             die "Error in git-update-index: $!" if $?;
 410         }
 411     }
 412
 413     # warn "errors when running git-update-index! $!";
 414     $tree = `git-write-tree`;
 415     die "cannot write tree $!" if $?;
 416     chomp $tree;
 417
 418
 419     #
 420     # Who's your daddy?
 421     #
 422     my @par;
 423     if ( -e "$git_dir/refs/heads/$ps->{branch}") {
 424         if (open HEAD, "<","$git_dir/refs/heads/$ps->{branch}") {
 425             my $p = <HEAD>;
 426             close HEAD;
 427             chomp $p;
 428             push @par, '-p', $p;
 429         } else {
 430             if ($ps->{type} eq 's') {
 431                 warn "Could not find the right head for the branch $ps->{branch}";
 432             }
 433         }
 434     }
 435
 436     if ($ps->{merges}) {
 437         push @par, find_parents($ps);
 438     }
 439
 440     #
 441     # Commit, tag and clean state
 442     #
 443     $ENV{TZ}                  = 'GMT';
 444     $ENV{GIT_AUTHOR_NAME}     = $ps->{author};
 445     $ENV{GIT_AUTHOR_EMAIL}    = $ps->{email};
 446     $ENV{GIT_AUTHOR_DATE}     = $ps->{date};
 447     $ENV{GIT_COMMITTER_NAME}  = $ps->{author};
 448     $ENV{GIT_COMMITTER_EMAIL} = $ps->{email};
 449     $ENV{GIT_COMMITTER_DATE}  = $ps->{date};
 450
 451     my ($pid, $commit_rh, $commit_wh);
 452     $commit_rh = 'commit_rh';
 453     $commit_wh = 'commit_wh';
 454
 455     $pid = open2(*READER, *WRITER,'git-commit-tree',$tree,@par)
 456         or die $!;
 457     print WRITER $logmessage;   # write
 458     close WRITER;
 459     my $commitid = <READER>;    # read
 460     chomp $commitid;
 461     close READER;
 462     waitpid $pid,0;             # close;
 463
 464     if (length $commitid != 40) {
 465         die "Something went wrong with the commit! $! $commitid";
 466     }
 467     #
 468     # Update the branch
 469     #
 470     open  HEAD, ">","$git_dir/refs/heads/$ps->{branch}";
 471     print HEAD $commitid;
 472     close HEAD;
 473     system('git-update-ref', 'HEAD', "$ps->{branch}");
 474
 475     # tag accordingly
 476     ptag($ps->{id}, $commitid); # private tag
 477     if ($opt_T || $ps->{type} eq 't' || $ps->{type} eq 'i') {
 478         tag($ps->{id}, $commitid);
 479     }
 480     print " * Committed $ps->{id}\n";
 481     print "   + tree   $tree\n";
 482     print "   + commit $commitid\n";
 483     $opt_v && print "   + commit date is  $ps->{date} \n";
 484     $opt_v && print "   + parents:  ",join(' ',@par),"\n";
 485 }
 486
 487 sub apply_import {
 488     my $ps = shift;
 489     my $bname = git_branchname($ps->{id});
 490
 491     mkpath($tmp);
 492
 493     safe_pipe_capture($TLA,'get','-s','--no-pristine',$ps->{id},"$tmp/import");
 494     die "Cannot get import: $!" if $?;
 495     system('rsync','-aI','--delete', '--exclude',$git_dir,
 496                 '--exclude','.arch-ids','--exclude','{arch}',
 497                 "$tmp/import/", './');
 498     die "Cannot rsync import:$!" if $?;
 499
 500     rmtree("$tmp/import");
 501     die "Cannot remove tempdir: $!" if $?;
 502
 503
 504     return 1;
 505 }
 506
 507 sub apply_cset {
 508     my $ps = shift;
 509
 510     mkpath($tmp);
 511
 512     # get the changeset
 513     safe_pipe_capture($TLA,'get-changeset',$ps->{id},"$tmp/changeset");
 514     die "Cannot get changeset: $!" if $?;
 515
 516     # apply patches
 517     if (`find $tmp/changeset/patches -type f -name '*.patch'`) {
 518         # this can be sped up considerably by doing
 519         #    (find | xargs cat) | patch
 520         # but that cna get mucked up by patches
 521         # with missing trailing newlines or the standard
 522         # 'missing newline' flag in the patch - possibly
 523         # produced with an old/buggy diff.
 524         # slow and safe, we invoke patch once per patchfile
 525         `find $tmp/changeset/patches -type f -name '*.patch' -print0 | grep -zv '{arch}' | xargs -iFILE -0 --no-run-if-empty patch -p1 --forward -iFILE`;
 526         die "Problem applying patches! $!" if $?;
 527     }
 528
 529     # apply changed binary files
 530     if (my @modified = `find $tmp/changeset/patches -type f -name '*.modified'`) {
 531         foreach my $mod (@modified) {
 532             chomp $mod;
 533             my $orig = $mod;
 534             $orig =~ s/\.modified$//; # lazy
 535             $orig =~ s!^\Q$tmp\E/changeset/patches/!!;
 536             #print "rsync -p '$mod' '$orig'";
 537             system('rsync','-p',$mod,"./$orig");
 538             die "Problem applying binary changes! $!" if $?;
 539         }
 540     }
 541
 542     # bring in new files
 543     system('rsync','-aI','--exclude',$git_dir,
 544                 '--exclude','.arch-ids',
 545                 '--exclude', '{arch}',
 546                 "$tmp/changeset/new-files-archive/",'./');
 547
 548     # deleted files are hinted from the commitlog processing
 549
 550     rmtree("$tmp/changeset");
 551 }
 552
 553
 554 # =for reference
 555 # A log entry looks like
 556 # Revision: moodle-org--moodle--1.3.3--patch-15
 557 # Archive: arch-eduforge@catalyst.net.nz--2004
 558 # Creator: Penny Leach <penny@catalyst.net.nz>
 559 # Date: Wed May 25 14:15:34 NZST 2005
 560 # Standard-date: 2005-05-25 02:15:34 GMT
 561 # New-files: lang/de/.arch-ids/block_glossary_random.php.id
 562 #     lang/de/.arch-ids/block_html.php.id
 563 # New-directories: lang/de/help/questionnaire
 564 #     lang/de/help/questionnaire/.arch-ids
 565 # Renamed-files: .arch-ids/db_sears.sql.id db/.arch-ids/db_sears.sql.id
 566 #    db_sears.sql db/db_sears.sql
 567 # Removed-files: lang/be/docs/.arch-ids/release.html.id
 568 #     lang/be/docs/.arch-ids/releaseold.html.id
 569 # Modified-files: admin/cron.php admin/delete.php
 570 #     admin/editor.html backup/lib.php backup/restore.php
 571 # New-patches: arch-eduforge@catalyst.net.nz--2004/moodle-org--moodle--1.3.3--patch-15
 572 # Summary: Updating to latest from MOODLE_14_STABLE (1.4.5+)
 573 # Keywords:
 574 #
 575 # Updating yadda tadda tadda madda
 576 sub parselog {
 577     my $log = shift;
 578     #print $log;
 579
 580     my (@add, @del, @mod, @ren, @kw, $sum, $msg );
 581
 582     if ($log =~ m/(?:\n|^)New-files:(.*?)(?=\n\w)/s ) {
 583         my $files = $1;
 584         @add = split(m/\s+/s, $files);
 585     }
 586
 587     if ($log =~ m/(?:\n|^)Removed-files:(.*?)(?=\n\w)/s ) {
 588         my $files = $1;
 589         @del = split(m/\s+/s, $files);
 590     }
 591
 592     if ($log =~ m/(?:\n|^)Modified-files:(.*?)(?=\n\w)/s ) {
 593         my $files = $1;
 594         @mod = split(m/\s+/s, $files);
 595     }
 596
 597     if ($log =~ m/(?:\n|^)Renamed-files:(.*?)(?=\n\w)/s ) {
 598         my $files = $1;
 599         @ren = split(m/\s+/s, $files);
 600     }
 601
 602     $sum ='';
 603     if ($log =~ m/^Summary:(.+?)$/m ) {
 604         $sum = $1;
 605         $sum =~ s/^\s+//;
 606         $sum =~ s/\s+$//;
 607     }
 608
 609     $msg = '';
 610     if ($log =~ m/\n\n(.+)$/s) {
 611         $msg = $1;
 612         $msg =~ s/^\s+//;
 613         $msg =~ s/\s+$//;
 614     }
 615
 616
 617     # cleanup the arrays
 618     foreach my $ref ( (\@add, \@del, \@mod, \@ren) ) {
 619         my @tmp = ();
 620         while (my $t = pop @$ref) {
 621             next unless length ($t);
 622             next if $t =~ m!\{arch\}/!;
 623             next if $t =~ m!\.arch-ids/!;
 624             next if $t =~ m!\.arch-inventory$!;
 625            # tla cat-archive-log will give us filenames with spaces as file\(sp)name - why?
 626            # we can assume that any filename with \ indicates some pika escaping that we want to get rid of.
 627            if  ($t =~ /\\/ ){
 628                $t = (safe_pipe_capture($TLA,'escape','--unescaped',$t))[0];
 629            }
 630             push (@tmp, $t);
 631         }
 632         @$ref = @tmp;
 633     }
 634
 635     #print Dumper [$sum, $msg, \@add, \@del, \@mod, \@ren];
 636     return       ($sum, $msg, \@add, \@del, \@mod, \@ren);
 637 }
 638
 639 # write/read a tag
 640 sub tag {
 641     my ($tag, $commit) = @_;
 642
 643     if ($opt_o) {
 644         $tag =~ s|/|--|g;
 645     } else {
 646         # don't use subdirs for tags yet, it could screw up other porcelains
 647         $tag =~ s|/|,|g;
 648     }
 649
 650     if ($commit) {
 651         open(C,">","$git_dir/refs/tags/$tag")
 652             or die "Cannot create tag $tag: $!\n";
 653         print C "$commit\n"
 654             or die "Cannot write tag $tag: $!\n";
 655         close(C)
 656             or die "Cannot write tag $tag: $!\n";
 657         print " * Created tag '$tag' on '$commit'\n" if $opt_v;
 658     } else {                    # read
 659         open(C,"<","$git_dir/refs/tags/$tag")
 660             or die "Cannot read tag $tag: $!\n";
 661         $commit = <C>;
 662         chomp $commit;
 663         die "Error reading tag $tag: $!\n" unless length $commit == 40;
 664         close(C)
 665             or die "Cannot read tag $tag: $!\n";
 666         return $commit;
 667     }
 668 }
 669
 670 # write/read a private tag
 671 # reads fail softly if the tag isn't there
 672 sub ptag {
 673     my ($tag, $commit) = @_;
 674
 675     # don't use subdirs for tags yet, it could screw up other porcelains
 676     $tag =~ s|/|,|g;
 677
 678     my $tag_file = "$ptag_dir/$tag";
 679     my $tag_branch_dir = dirname($tag_file);
 680     mkpath($tag_branch_dir) unless (-d $tag_branch_dir);
 681
 682     if ($commit) {              # write
 683         open(C,">",$tag_file)
 684             or die "Cannot create tag $tag: $!\n";
 685         print C "$commit\n"
 686             or die "Cannot write tag $tag: $!\n";
 687         close(C)
 688             or die "Cannot write tag $tag: $!\n";
 689         $rptags{$commit} = $tag
 690             unless $tag =~ m/--base-0$/;
 691     } else {                    # read
 692         # if the tag isn't there, return 0
 693         unless ( -s $tag_file) {
 694             return 0;
 695         }
 696         open(C,"<",$tag_file)
 697             or die "Cannot read tag $tag: $!\n";
 698         $commit = <C>;
 699         chomp $commit;
 700         die "Error reading tag $tag: $!\n" unless length $commit == 40;
 701         close(C)
 702             or die "Cannot read tag $tag: $!\n";
 703         unless (defined $rptags{$commit}) {
 704             $rptags{$commit} = $tag;
 705         }
 706         return $commit;
 707     }
 708 }
 709
 710 sub find_parents {
 711     #
 712     # Identify what branches are merging into me
 713     # and whether we are fully merged
 714     # git-merge-base <headsha> <headsha> should tell
 715     # me what the base of the merge should be
 716     #
 717     my $ps = shift;
 718
 719     my %branches; # holds an arrayref per branch
 720                   # the arrayref contains a list of
 721                   # merged patches between the base
 722                   # of the merge and the current head
 723
 724     my @parents;  # parents found for this commit
 725
 726     # simple loop to split the merges
 727     # per branch
 728     foreach my $merge (@{$ps->{merges}}) {
 729         my $branch = git_branchname($merge);
 730         unless (defined $branches{$branch} ){
 731             $branches{$branch} = [];
 732         }
 733         push @{$branches{$branch}}, $merge;
 734     }
 735
 736     #
 737     # foreach branch find a merge base and walk it to the
 738     # head where we are, collecting the merged patchsets that
 739     # Arch has recorded. Keep that in @have
 740     # Compare that with the commits on the other branch
 741     # between merge-base and the tip of the branch (@need)
 742     # and see if we have a series of consecutive patches
 743     # starting from the merge base. The tip of the series
 744     # of consecutive patches merged is our new parent for
 745     # that branch.
 746     #
 747     foreach my $branch (keys %branches) {
 748
 749         # check that we actually know about the branch
 750         next unless -e "$git_dir/refs/heads/$branch";
 751
 752         my $mergebase = `git-merge-base $branch $ps->{branch}`;
 753         if ($?) {
 754             # Don't die here, Arch supports one-way cherry-picking
 755             # between branches with no common base (or any relationship
 756             # at all beforehand)
 757             warn "Cannot find merge base for $branch and $ps->{branch}";
 758             next;
 759         }
 760         chomp $mergebase;
 761
 762         # now walk up to the mergepoint collecting what patches we have
 763         my $branchtip = git_rev_parse($ps->{branch});
 764         my @ancestors = `git-rev-list --merge-order $branchtip ^$mergebase`;
 765         my %have; # collected merges this branch has
 766         foreach my $merge (@{$ps->{merges}}) {
 767             $have{$merge} = 1;
 768         }
 769         my %ancestorshave;
 770         foreach my $par (@ancestors) {
 771             $par = commitid2pset($par);
 772             if (defined $par->{merges}) {
 773                 foreach my $merge (@{$par->{merges}}) {
 774                     $ancestorshave{$merge}=1;
 775                 }
 776             }
 777         }
 778         # print "++++ Merges in $ps->{id} are....\n";
 779         # my @have = sort keys %have;   print Dumper(\@have);
 780
 781         # merge what we have with what ancestors have
 782         %have = (%have, %ancestorshave);
 783
 784         # see what the remote branch has - these are the merges we
 785         # will want to have in a consecutive series from the mergebase
 786         my $otherbranchtip = git_rev_parse($branch);
 787         my @needraw = `git-rev-list --merge-order $otherbranchtip ^$mergebase`;
 788         my @need;
 789         foreach my $needps (@needraw) {         # get the psets
 790             $needps = commitid2pset($needps);
 791             # git-rev-list will also
 792             # list commits merged in via earlier
 793             # merges. we are only interested in commits
 794             # from the branch we're looking at
 795             if ($branch eq $needps->{branch}) {
 796                 push @need, $needps->{id};
 797             }
 798         }
 799
 800         # print "++++ Merges from $branch we want are....\n";
 801         # print Dumper(\@need);
 802
 803         my $newparent;
 804         while (my $needed_commit = pop @need) {
 805             if ($have{$needed_commit}) {
 806                 $newparent = $needed_commit;
 807             } else {
 808                 last; # break out of the while
 809             }
 810         }
 811         if ($newparent) {
 812             push @parents, $newparent;
 813         }
 814
 815
 816     } # end foreach branch
 817
 818     # prune redundant parents
 819     my %parents;
 820     foreach my $p (@parents) {
 821         $parents{$p} = 1;
 822     }
 823     foreach my $p (@parents) {
 824         next unless exists $psets{$p}{merges};
 825         next unless ref    $psets{$p}{merges};
 826         my @merges = @{$psets{$p}{merges}};
 827         foreach my $merge (@merges) {
 828             if ($parents{$merge}) {
 829                 delete $parents{$merge};
 830             }
 831         }
 832     }
 833     @parents = ();
 834     foreach (keys %parents) {
 835         push @parents, '-p', ptag($_);
 836     }
 837     return @parents;
 838 }
 839
 840 sub git_rev_parse {
 841     my $name = shift;
 842     my $val  = `git-rev-parse $name`;
 843     die "Error: git-rev-parse $name" if $?;
 844     chomp $val;
 845     return $val;
 846 }
 847
 848 # resolve a SHA1 to a known patchset
 849 sub commitid2pset {
 850     my $commitid = shift;
 851     chomp $commitid;
 852     my $name = $rptags{$commitid}
 853         || die "Cannot find reverse tag mapping for $commitid";
 854     $name =~ s|,|/|;
 855     my $ps   = $psets{$name}
 856         || (print Dumper(sort keys %psets)) && die "Cannot find patchset for $name";
 857     return $ps;
 858 }
 859
 860 # an alterative to `command` that allows input to be passed as an array
 861 # to work around shell problems with weird characters in arguments
 862 sub safe_pipe_capture {
 863     my @output;
 864     if (my $pid = open my $child, '-|') {
 865         @output = (<$child>);
 866         close $child or die join(' ',@_).": $! $?";
 867     } else {
 868         exec(@_) or die $?; # exec() can fail the executable can't be found
 869     }
 870     return wantarray ? @output : join('',@output);
 871 }
 872
 873