Use GIT_EXEC_PATH explicitly for initial git-init-db in tests.
[git.git] / 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);
59 use File::Basename qw(basename dirname);
60 use String::ShellQuote;
61 use Time::Local;
62 use IO::Socket;
63 use IO::Pipe;
64 use POSIX qw(strftime dup2);
65 use Data::Dumper qw/ Dumper /;
66 use IPC::Open2;
67
68 $SIG{'PIPE'}="IGNORE";
69 $ENV{'TZ'}="UTC";
70
71 my $git_dir = $ENV{"GIT_DIR"} || ".git";
72 $ENV{"GIT_DIR"} = $git_dir;
73 my $ptag_dir = "$git_dir/archimport/tags";
74
75 our($opt_h,$opt_v, $opt_T,$opt_t,$opt_o);
76
77 sub usage() {
78     print STDERR <<END;
79 Usage: ${\basename $0}     # fetch/update GIT from Arch
80        [ -o ] [ -h ] [ -v ] [ -T ] [ -t tempdir ] 
81        repository/arch-branch [ repository/arch-branch] ...
82 END
83     exit(1);
84 }
85
86 getopts("Thvt:") or usage();
87 usage if $opt_h;
88
89 @ARGV >= 1 or usage();
90 my @arch_roots = @ARGV;
91
92 my ($tmpdir, $tmpdirname) = tempdir('git-archimport-XXXXXX', TMPDIR => 1, CLEANUP => 1);
93 my $tmp = $opt_t || 1;
94 $tmp = tempdir('git-archimport-XXXXXX', TMPDIR => 1, CLEANUP => 1);
95 $opt_v && print "+ Using $tmp as temporary directory\n";
96
97 my @psets  = ();                # the collection
98 my %psets  = ();                # the collection, by name
99
100 my %rptags = ();                # my reverse private tags
101                                 # to map a SHA1 to a commitid
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             `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             `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 = `tla cat-archive-log -A $ps->{repo} $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     my $par = join (' ', @par);
440
441     #    
442     # Commit, tag and clean state
443     #
444     $ENV{TZ}                  = 'GMT';
445     $ENV{GIT_AUTHOR_NAME}     = $ps->{author};
446     $ENV{GIT_AUTHOR_EMAIL}    = $ps->{email};
447     $ENV{GIT_AUTHOR_DATE}     = $ps->{date};
448     $ENV{GIT_COMMITTER_NAME}  = $ps->{author};
449     $ENV{GIT_COMMITTER_EMAIL} = $ps->{email};
450     $ENV{GIT_COMMITTER_DATE}  = $ps->{date};
451
452     my ($pid, $commit_rh, $commit_wh);
453     $commit_rh = 'commit_rh';
454     $commit_wh = 'commit_wh';
455     
456     $pid = open2(*READER, *WRITER, "git-commit-tree $tree $par") 
457         or die $!;
458     print WRITER $logmessage;   # write
459     close WRITER;
460     my $commitid = <READER>;    # read
461     chomp $commitid;
462     close READER;
463     waitpid $pid,0;             # close;
464
465     if (length $commitid != 40) {
466         die "Something went wrong with the commit! $! $commitid";
467     }
468     #
469     # Update the branch
470     # 
471     open  HEAD, ">$git_dir/refs/heads/$ps->{branch}";
472     print HEAD $commitid;
473     close HEAD;
474     system('git-update-ref', 'HEAD', "$ps->{branch}");
475
476     # tag accordingly
477     ptag($ps->{id}, $commitid); # private tag
478     if ($opt_T || $ps->{type} eq 't' || $ps->{type} eq 'i') {
479         tag($ps->{id}, $commitid);
480     }
481     print " * Committed $ps->{id}\n";
482     print "   + tree   $tree\n";
483     print "   + commit $commitid\n";
484     $opt_v && print "   + commit date is  $ps->{date} \n";
485     $opt_v && print "   + parents:  $par \n";
486 }
487
488 sub apply_import {
489     my $ps = shift;
490     my $bname = git_branchname($ps->{id});
491
492     `mkdir -p $tmp`;
493
494     `tla get -s --no-pristine -A $ps->{repo} $ps->{id} $tmp/import`;
495     die "Cannot get import: $!" if $?;    
496     `rsync -v --archive --delete --exclude '$git_dir' --exclude '.arch-ids' --exclude '{arch}' $tmp/import/* ./`;
497     die "Cannot rsync import:$!" if $?;
498     
499     `rm -fr $tmp/import`;
500     die "Cannot remove tempdir: $!" if $?;
501     
502
503     return 1;
504 }
505
506 sub apply_cset {
507     my $ps = shift;
508
509     `mkdir -p $tmp`;
510
511     # get the changeset
512     `tla get-changeset  -A $ps->{repo} $ps->{id} $tmp/changeset`;
513     die "Cannot get changeset: $!" if $?;
514     
515     # apply patches
516     if (`find $tmp/changeset/patches -type f -name '*.patch'`) {
517         # this can be sped up considerably by doing
518         #    (find | xargs cat) | patch
519         # but that cna get mucked up by patches
520         # with missing trailing newlines or the standard 
521         # 'missing newline' flag in the patch - possibly
522         # produced with an old/buggy diff.
523         # slow and safe, we invoke patch once per patchfile
524         `find $tmp/changeset/patches -type f -name '*.patch' -print0 | grep -zv '{arch}' | xargs -iFILE -0 --no-run-if-empty patch -p1 --forward -iFILE`;
525         die "Problem applying patches! $!" if $?;
526     }
527
528     # apply changed binary files
529     if (my @modified = `find $tmp/changeset/patches -type f -name '*.modified'`) {
530         foreach my $mod (@modified) {
531             chomp $mod;
532             my $orig = $mod;
533             $orig =~ s/\.modified$//; # lazy
534             $orig =~ s!^\Q$tmp\E/changeset/patches/!!;
535             #print "rsync -p '$mod' '$orig'";
536             `rsync -p $mod ./$orig`;
537             die "Problem applying binary changes! $!" if $?;
538         }
539     }
540
541     # bring in new files
542     `rsync --archive --exclude '$git_dir' --exclude '.arch-ids' --exclude '{arch}' $tmp/changeset/new-files-archive/* ./`;
543
544     # deleted files are hinted from the commitlog processing
545
546     `rm -fr $tmp/changeset`;
547 }
548
549
550 # =for reference
551 # A log entry looks like 
552 # Revision: moodle-org--moodle--1.3.3--patch-15
553 # Archive: arch-eduforge@catalyst.net.nz--2004
554 # Creator: Penny Leach <penny@catalyst.net.nz>
555 # Date: Wed May 25 14:15:34 NZST 2005
556 # Standard-date: 2005-05-25 02:15:34 GMT
557 # New-files: lang/de/.arch-ids/block_glossary_random.php.id
558 #     lang/de/.arch-ids/block_html.php.id
559 # New-directories: lang/de/help/questionnaire
560 #     lang/de/help/questionnaire/.arch-ids
561 # Renamed-files: .arch-ids/db_sears.sql.id db/.arch-ids/db_sears.sql.id
562 #    db_sears.sql db/db_sears.sql
563 # Removed-files: lang/be/docs/.arch-ids/release.html.id
564 #     lang/be/docs/.arch-ids/releaseold.html.id
565 # Modified-files: admin/cron.php admin/delete.php
566 #     admin/editor.html backup/lib.php backup/restore.php
567 # New-patches: arch-eduforge@catalyst.net.nz--2004/moodle-org--moodle--1.3.3--patch-15
568 # Summary: Updating to latest from MOODLE_14_STABLE (1.4.5+)
569 # Keywords:
570 #
571 # Updating yadda tadda tadda madda
572 sub parselog {
573     my $log = shift;
574     #print $log;
575
576     my (@add, @del, @mod, @ren, @kw, $sum, $msg );
577
578     if ($log =~ m/(?:\n|^)New-files:(.*?)(?=\n\w)/s ) {
579         my $files = $1;
580         @add = split(m/\s+/s, $files);
581     }
582        
583     if ($log =~ m/(?:\n|^)Removed-files:(.*?)(?=\n\w)/s ) {
584         my $files = $1;
585         @del = split(m/\s+/s, $files);
586     }
587     
588     if ($log =~ m/(?:\n|^)Modified-files:(.*?)(?=\n\w)/s ) {
589         my $files = $1;
590         @mod = split(m/\s+/s, $files);
591     }
592     
593     if ($log =~ m/(?:\n|^)Renamed-files:(.*?)(?=\n\w)/s ) {
594         my $files = $1;
595         @ren = split(m/\s+/s, $files);
596     }
597
598     $sum ='';
599     if ($log =~ m/^Summary:(.+?)$/m ) {
600         $sum = $1;
601         $sum =~ s/^\s+//;
602         $sum =~ s/\s+$//;
603     }
604
605     $msg = '';
606     if ($log =~ m/\n\n(.+)$/s) {
607         $msg = $1;
608         $msg =~ s/^\s+//;
609         $msg =~ s/\s+$//;
610     }
611
612
613     # cleanup the arrays
614     foreach my $ref ( (\@add, \@del, \@mod, \@ren) ) {
615         my @tmp = ();
616         while (my $t = pop @$ref) {
617             next unless length ($t);
618             next if $t =~ m!\{arch\}/!;
619             next if $t =~ m!\.arch-ids/!;
620             next if $t =~ m!\.arch-inventory$!;
621            # tla cat-archive-log will give us filenames with spaces as file\(sp)name - why?
622            # we can assume that any filename with \ indicates some pika escaping that we want to get rid of.
623            if  ($t =~ /\\/ ){
624                $t = `tla escape --unescaped '$t'`;
625            }
626             push (@tmp, shell_quote($t));
627         }
628         @$ref = @tmp;
629     }
630     
631     #print Dumper [$sum, $msg, \@add, \@del, \@mod, \@ren]; 
632     return       ($sum, $msg, \@add, \@del, \@mod, \@ren); 
633 }
634
635 # write/read a tag
636 sub tag {
637     my ($tag, $commit) = @_;
638  
639     if ($opt_o) {
640         $tag =~ s|/|--|g;
641     } else {
642         # don't use subdirs for tags yet, it could screw up other porcelains
643         $tag =~ s|/|,|g;
644     }
645     
646     if ($commit) {
647         open(C,">","$git_dir/refs/tags/$tag")
648             or die "Cannot create tag $tag: $!\n";
649         print C "$commit\n"
650             or die "Cannot write tag $tag: $!\n";
651         close(C)
652             or die "Cannot write tag $tag: $!\n";
653         print " * Created tag '$tag' on '$commit'\n" if $opt_v;
654     } else {                    # read
655         open(C,"<","$git_dir/refs/tags/$tag")
656             or die "Cannot read tag $tag: $!\n";
657         $commit = <C>;
658         chomp $commit;
659         die "Error reading tag $tag: $!\n" unless length $commit == 40;
660         close(C)
661             or die "Cannot read tag $tag: $!\n";
662         return $commit;
663     }
664 }
665
666 # write/read a private tag
667 # reads fail softly if the tag isn't there
668 sub ptag {
669     my ($tag, $commit) = @_;
670
671     # don't use subdirs for tags yet, it could screw up other porcelains
672     $tag =~ s|/|,|g; 
673     
674     my $tag_file = "$ptag_dir/$tag";
675     my $tag_branch_dir = dirname($tag_file);
676     mkpath($tag_branch_dir) unless (-d $tag_branch_dir);
677
678     if ($commit) {              # write
679         open(C,">",$tag_file)
680             or die "Cannot create tag $tag: $!\n";
681         print C "$commit\n"
682             or die "Cannot write tag $tag: $!\n";
683         close(C)
684             or die "Cannot write tag $tag: $!\n";
685         $rptags{$commit} = $tag 
686             unless $tag =~ m/--base-0$/;
687     } else {                    # read
688         # if the tag isn't there, return 0
689         unless ( -s $tag_file) {
690             return 0;
691         }
692         open(C,"<",$tag_file)
693             or die "Cannot read tag $tag: $!\n";
694         $commit = <C>;
695         chomp $commit;
696         die "Error reading tag $tag: $!\n" unless length $commit == 40;
697         close(C)
698             or die "Cannot read tag $tag: $!\n";
699         unless (defined $rptags{$commit}) {
700             $rptags{$commit} = $tag;
701         }
702         return $commit;
703     }
704 }
705
706 sub find_parents {
707     #
708     # Identify what branches are merging into me
709     # and whether we are fully merged
710     # git-merge-base <headsha> <headsha> should tell
711     # me what the base of the merge should be 
712     #
713     my $ps = shift;
714
715     my %branches; # holds an arrayref per branch
716                   # the arrayref contains a list of
717                   # merged patches between the base
718                   # of the merge and the current head
719
720     my @parents;  # parents found for this commit
721
722     # simple loop to split the merges
723     # per branch
724     foreach my $merge (@{$ps->{merges}}) {
725         my $branch = git_branchname($merge);
726         unless (defined $branches{$branch} ){
727             $branches{$branch} = [];
728         }
729         push @{$branches{$branch}}, $merge;
730     }
731
732     #
733     # foreach branch find a merge base and walk it to the 
734     # head where we are, collecting the merged patchsets that
735     # Arch has recorded. Keep that in @have
736     # Compare that with the commits on the other branch
737     # between merge-base and the tip of the branch (@need)
738     # and see if we have a series of consecutive patches
739     # starting from the merge base. The tip of the series
740     # of consecutive patches merged is our new parent for 
741     # that branch.
742     #
743     foreach my $branch (keys %branches) {
744
745         # check that we actually know about the branch
746         next unless -e "$git_dir/refs/heads/$branch";
747
748         my $mergebase = `git-merge-base $branch $ps->{branch}`;
749         if ($?) { 
750             # Don't die here, Arch supports one-way cherry-picking
751             # between branches with no common base (or any relationship
752             # at all beforehand)
753             warn "Cannot find merge base for $branch and $ps->{branch}";
754             next;
755         }
756         chomp $mergebase;
757
758         # now walk up to the mergepoint collecting what patches we have
759         my $branchtip = git_rev_parse($ps->{branch});
760         my @ancestors = `git-rev-list --merge-order $branchtip ^$mergebase`;
761         my %have; # collected merges this branch has
762         foreach my $merge (@{$ps->{merges}}) {
763             $have{$merge} = 1;
764         }
765         my %ancestorshave;
766         foreach my $par (@ancestors) {
767             $par = commitid2pset($par);
768             if (defined $par->{merges}) {
769                 foreach my $merge (@{$par->{merges}}) {
770                     $ancestorshave{$merge}=1;
771                 }
772             }
773         }
774         # print "++++ Merges in $ps->{id} are....\n";
775         # my @have = sort keys %have;   print Dumper(\@have);
776
777         # merge what we have with what ancestors have
778         %have = (%have, %ancestorshave);
779
780         # see what the remote branch has - these are the merges we 
781         # will want to have in a consecutive series from the mergebase
782         my $otherbranchtip = git_rev_parse($branch);
783         my @needraw = `git-rev-list --merge-order $otherbranchtip ^$mergebase`;
784         my @need;
785         foreach my $needps (@needraw) {         # get the psets
786             $needps = commitid2pset($needps);
787             # git-rev-list will also
788             # list commits merged in via earlier 
789             # merges. we are only interested in commits
790             # from the branch we're looking at
791             if ($branch eq $needps->{branch}) {
792                 push @need, $needps->{id};
793             }
794         }
795
796         # print "++++ Merges from $branch we want are....\n";
797         # print Dumper(\@need);
798
799         my $newparent;
800         while (my $needed_commit = pop @need) {
801             if ($have{$needed_commit}) {
802                 $newparent = $needed_commit;
803             } else {
804                 last; # break out of the while
805             }
806         }
807         if ($newparent) {
808             push @parents, $newparent;
809         }
810
811
812     } # end foreach branch
813
814     # prune redundant parents
815     my %parents;
816     foreach my $p (@parents) {
817         $parents{$p} = 1;
818     }
819     foreach my $p (@parents) {
820         next unless exists $psets{$p}{merges};
821         next unless ref    $psets{$p}{merges};
822         my @merges = @{$psets{$p}{merges}};
823         foreach my $merge (@merges) {
824             if ($parents{$merge}) { 
825                 delete $parents{$merge};
826             }
827         }
828     }
829     @parents = keys %parents;
830     @parents = map { " -p " . ptag($_) } @parents;
831     return @parents;
832 }
833
834 sub git_rev_parse {
835     my $name = shift;
836     my $val  = `git-rev-parse $name`;
837     die "Error: git-rev-parse $name" if $?;
838     chomp $val;
839     return $val;
840 }
841
842 # resolve a SHA1 to a known patchset
843 sub commitid2pset {
844     my $commitid = shift;
845     chomp $commitid;
846     my $name = $rptags{$commitid} 
847         || die "Cannot find reverse tag mapping for $commitid";
848     $name =~ s|,|/|;
849     my $ps   = $psets{$name} 
850         || (print Dumper(sort keys %psets)) && die "Cannot find patchset for $name";
851     return $ps;
852 }