X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=589fa901af95f5b1158f850b205e9defc20331ac;hp=f4831c3c5b6c4f1a8a23cf58a1ebfeb0c074a7ce;hb=332806a67a034c88c2884b516ce2aaf8b317dd25;hpb=bc3be36a946aeb6485259be594645c3c3d69550f diff --git a/git-debrebase b/git-debrebase index f4831c3c..589fa901 100755 --- a/git-debrebase +++ b/git-debrebase @@ -36,6 +36,8 @@ use Dpkg::Version; use File::FnMatch qw(:fnmatch); use File::Copy; +$debugcmd_when_debuglevel = 2; + our ($usage_message) = <<'END'; usages: git-debrebase [] [--|-i ] @@ -49,10 +51,12 @@ See git-debrebase(1), git-debrebase(5), dgit-maint-debrebase(7) (in dgit). END our ($opt_force, $opt_noop_ok, @opt_anchors); -our ($opt_defaultcmd_interactive); +our ($opt_defaultcmd_interactive, $opt_save_wreckage); our $us = qw(git-debrebase); +our $wrecknoteprefix = 'refs/debrebase-wreckage'; + $|=1; sub badusage ($) { @@ -129,6 +133,21 @@ sub fresh_workarea () { in_workarea sub { playtree_setup }; } +sub run_ref_updates_now ($$) { + my ($mrest, $updates) = @_; + # @$updates is a list of lines for git-update-ref, without \ns + + my @upd_cmd = (git_update_ref_cmd "debrebase: $mrest", qw(--stdin)); + debugcmd '>|', @upd_cmd; + open U, "|-", @upd_cmd or die $!; + foreach (@$updates) { + printdebug ">= ", $_, "\n"; + print U $_, "\n" or die $!; + } + printdebug ">\$\n"; + close U or failedcmd @upd_cmd; +} + our $snags_forced = 0; our $snags_tripped = 0; our $snags_summarised = 0; @@ -143,16 +162,7 @@ sub run_deferred_updates ($) { confess 'dangerous internal error' unless all_snags_summarised(); - my @upd_cmd = (git_update_ref_cmd "debrebase: $mrest", qw(--stdin)); - debugcmd '>|', @upd_cmd; - open U, "|-", @upd_cmd or die $!; - foreach (@deferred_updates) { - printdebug ">= ", $_, "\n"; - print U $_, "\n" or die $!; - } - printdebug ">\$\n"; - close U or failedcmd @upd_cmd; - + run_ref_updates_now $mrest, \@deferred_updates; print $_, "\n" foreach @deferred_update_messages; @deferred_updates = (); @@ -226,7 +236,7 @@ sub get_differs ($$) { unless $differs & (D_PAT_ADD|D_PAT_OTH); } - printdebug sprintf "get_differs %s, %s = %#x\n", $x, $y, $differs; + printdebug sprintf "get_differs %s %s = %#x\n", $x, $y, $differs; return $differs; } @@ -255,6 +265,24 @@ sub read_tree_subdir ($$) { runcmd @git, qw(read-tree), "--prefix=$subdir/", $new_tree_object; } +sub read_tree_debian ($) { + my ($treeish) = @_; + read_tree_subdir 'debian', "$treeish:debian"; + rm_subdir_cached 'debian/patches'; +} + +sub read_tree_upstream ($;$$) { + my ($treeish, $keep_patches, $tree_with_debian) = @_; + # if $tree_with_debian is supplied, will use that for debian/ + # otherwise will save and restore it. + my $debian = + $tree_with_debian ? "$tree_with_debian:debian" + : cmdoutput @git, qw(write-tree --prefix=debian/); + runcmd @git, qw(read-tree), $treeish; + read_tree_subdir 'debian', $debian; + rm_subdir_cached 'debian/patches' unless $keep_patches; +}; + sub make_commit ($$) { my ($parents, $message_paras) = @_; my $tree = cmdoutput @git, qw(write-tree); @@ -310,6 +338,278 @@ sub any_snags () { return $snags_forced || $snags_tripped; } +sub gbp_pq_export ($$$) { + my ($bname, $base, $tip) = @_; + # must be run in a workarea. $bname and patch-queue/$bname + # ought not to exist. Leaves you on patch-queue/$bname with + # the patches staged but not committed. + printdebug "gbp_pq_export $bname $base $tip\n"; + runcmd @git, qw(checkout -q -b), $bname, $base; + runcmd @git, qw(checkout -q -b), "patch-queue/$bname", $tip; + my @gbp_cmd = (qw(gbp pq export)); + my $r = system shell_cmd 'exec >../gbp-pq-err 2>&1', @gbp_cmd; + if ($r) { + { local ($!,$?); copy('../gbp-pq-err', \*STDERR); } + failedcmd @gbp_cmd; + } + runcmd @git, qw(add -f debian/patches) if stat_exists 'debian/patches'; +} + + +# xxx allow merge resolution separately from laundering, before git merge +# +# xxx general gdr docs highlight forbidden things +# xxx general gdr docs list allowable things ? +# xxx general gdr docs explicitly forbid some rebase +# +# xxx provide a way for the user to help +# xxx (eg, provide wreckage provide way to continue) + +# later/rework? +# use git-format-patch? +# our own patch identification algorithm? +# this is an alternative strategy + +sub merge_failed ($$) { + my ($wrecknotes, $emsg) = @_; + my @m; + push @m, "Merge resolution failed: $emsg"; + + $opt_save_wreckage //= do { + my $c = cfg 'git-debrebase.merge.save-wreckage', 1; + # ^ xxx documentation + $c && $c =~ m/^[1ty]/; + }; + + if ($opt_save_wreckage) { + my @updates; + git_for_each_ref("$wrecknoteprefix/*", sub { + my ($objid,$objtype,$fullrefname,$reftail) = @_; + push @updates, "delete $fullrefname"; + }); + keys %$wrecknotes; + while (my ($k,$v) = each %$wrecknotes) { + push @updates, "create $wrecknoteprefix/$k $v"; + } + run_ref_updates_now "merge failed", \@updates; + push @m, "Wreckage left in $wrecknoteprefix/* as requested."; + } + push @m, "See git-debrebase(1) section FAILED MERGES for suggestions."; + # ^ xxx this section does not yet exist + fail join '', map { "$_\n" } @m; +} + +sub mwrecknote ($$$) { + my ($wrecknotes, $reftail, $commitish) = @_; + confess unless defined $commitish; + printdebug "mwrecknote $reftail $commitish\n"; + $wrecknotes->{$reftail} = $commitish; +} + +sub merge_series ($$$;@) { + my ($newbase, $wrecknotes, $base_q, @input_qs) = @_; + # $base_q{SeriesBase} $input_qs[]{SeriesBase} + # $base_q{SeriesTip} $input_qs[]{SeriesTip} + # ^ specifies several patch series (currently we only support exactly 2) + # return value is a commit which is the result of + # merging the two versions of the same topic branch + # $input_q[0] and $input_q[1] + # with respect to the old version + # $base_q + # all onto $newbase. + + # Creates, in *_q, a key MR for its private use + + printdebug "merge_series newbase=$newbase\n"; + + $input_qs[$_]{MR}{S} = $_ foreach (0..$#input_qs); + $base_q->{MR}{S} = 'base'; + + my %prereq; + # $prereq{}{} = 1 or absent + # $prereq{}{} exists or not (even later) + + my $result; + + my $mwrecknote = sub { &mwrecknote($wrecknotes, @_); }; + + local $workarea = fresh_playground "$playprefix/merge"; + my $seriesfile = "debian/patches/series"; + in_workarea sub { + playtree_setup(); + foreach my $q ($base_q, reverse @input_qs) { + my $s = $q->{MR}{S}; + gbp_pq_export "p-$s", $q->{SeriesBase}, $q->{SeriesTip}; + my @earlier; + if (open S, $seriesfile) { + while (my $patch = ) { + chomp $patch or die $!; + $prereq{$patch} //= {}; + foreach my $earlier (@earlier) { + $prereq{$patch}{$earlier}{$s}++ and die; + } + push @earlier, $patch; + stat "debian/patches/$patch" or die "$patch ?"; + } + S->error and die "$seriesfile $!"; + close S; + } else { + die "$seriesfile $!" unless $!==ENOENT; + } + read_tree_upstream $newbase, 1; + my $pec = make_commit [ grep { defined } $base_q->{MR}{PEC} ], [ + "Convert $s to patch queue for merging", + "[git-debrebase merge-innards patch-queue import:". + " $q->{SeriesTip}]" + ]; + printdebug "merge_series pec $pec "; + runcmd @git, qw(rm -q --ignore-unmatch --cached), $seriesfile; + $pec = make_commit [ $pec ], [ + "Drop series file from $s to avoid merge trouble", + "[git-debrebase merge-innards patch-queue prep:". + " $q->{SeriesTip}]" + ]; + + read_tree_debian $newbase; + if (@earlier) { + read_tree_subdir 'debian/patches', "$pec:debian/patches"; + } else { + rm_subdir_cached 'debian/patches'; + } + $pec = make_commit [ $pec ], [ + "Update debian/ (excluding patches) to final to avoid re-merging", + "debian/ was already merged and we need to just take that.", + "[git-debrebase merge-innards patch-queue packaging:". + " $q->{SeriesTip}]" + ]; + + printdebug "pec' $pec\n"; + runcmd @git, qw(reset -q --hard), $pec; + $q->{MR}{PEC} = $pec; + $mwrecknote->("$q->{LeftRight}-patchqueue", $pec); + } + # now, because of reverse, we are on $input_q->{MR}{OQC} + runcmd @git, qw(checkout -q -b merge); + printdebug "merge_series merging...\n"; + my @mergecmd = (@git, qw(merge --quiet --no-edit), "p-1"); + debugcmd '+', @mergecmd; + $!=0; $?=-1; + if (system @mergecmd) { + failedcmd @mergecmd; + } + + printdebug "merge_series merge ok, series...\n"; + # We need to construct a new series file + # Firstly, resolve prereq + foreach my $f (sort keys %prereq) { + printdebug "merge_series patch\t$f\t"; + if (!stat_exists "debian/patches/$f") { + print DEBUG " drop\n" if $debuglevel; + # git merge deleted it; that's how we tell it's not wanted + delete $prereq{$f}; + next; + } + print DEBUG " keep\n" if $debuglevel; + foreach my $g (sort keys %{ $prereq{$f} }) { + my $gfp = $prereq{$f}{$g}; + printdebug "merge_series prereq\t$f\t-> $g\t"; + if (!!$gfp->{0} == !!$gfp->{1} + ? $gfp->{0} + : !$gfp->{base}) { + print DEBUG "\tkeep\n" if $debuglevel; + } else { + print DEBUG "\tdrop\n" if $debuglevel; + delete $prereq{$f}{$g}; + } + } + } + + my $unsat = sub { + my ($f) = @_; + return scalar keys %{ $prereq{$f} }; + }; + + my $nodate = time + 1; + my %authordate; + # $authordate{}; + my $authordate = sub { + my ($f) = @_; + $authordate{$f} //= do { + open PF, "<", "debian/patches/$f" or die "$f $!"; + while () { + return $nodate if m/^$/; + last if s{^Date: }{}; + } + chomp; + return cmdoutput qw(date +%s -d), $_; + }; + }; + + open NS, '>', $seriesfile or die $!; + + while (keys %prereq) { + my $best; + foreach my $try (sort keys %prereq) { + if ($best) { + next if ( + $unsat->($try) <=> $unsat->($best) or + $authordate->($try) <=> $authordate->($best) or + $try cmp $best + ) >= 0; + } + $best = $try; + } + printdebug "merge_series series next $best\n"; + print NS "$best\n" or die $!; + delete $prereq{$best}; + foreach my $gp (values %prereq) { + delete $gp->{$best}; + } + } + + runcmd @git, qw(add), $seriesfile; + runcmd @git, qw(commit --quiet -m), 'Merged patch queue form'; + $mwrecknote->('merged-patchqueue', git_rev_parse 'HEAD'); + + printdebug "merge_series series gbp pq import\n"; + runcmd qw(gbp pq import); + + # OK now we are on patch-queue/merge, and we need to rebase + # onto the intended parent and drop the patches from each one + + printdebug "merge_series series ok, building...\n"; + my $build = $newbase; + my @lcmd = (@git, qw(rev-list --reverse merge..patch-queue/merge)); + foreach my $c (grep /./, split /\n/, cmdoutput @lcmd) { + my $commit = git_cat_file $c, 'commit'; + printdebug "merge_series series ok, building $c\n"; + read_tree_upstream $c, 0, $newbase; + my $tree = cmdoutput @git, qw(write-tree); + $commit =~ s{^parent (\S+)$}{parent $build}m or confess; + $commit =~ s{^tree (\S+)$}{tree $tree}m or confess; + open C, ">", "../mcommit" or die $!; + print C $commit or die $!; + close C or die $!; + $build = cmdoutput @git, qw(hash-object -w -t commit ../mcommit); + } + $result = $build; + $mwrecknote->('merged-result', $result); + + runcmd @git, qw(update-ref refs/heads/result), $result; + + runcmd @git, qw(checkout -q -b debug); + runcmd @git, qw(commit --allow-empty -q -m M-INDEX); + runcmd @git, qw(add .); + runcmd @git, qw(commit --allow-empty -q -m M-WORKTREE); + my $mdebug = git_rev_parse 'HEAD'; + printdebug sprintf "merge_series done debug=%s\n", $mdebug; + $mwrecknote->('merged-debug', $mdebug); + }; + printdebug "merge_series returns $result\n"; + return $result; +} + # classify returns an info hash like this # CommitId => $objid # Hdr => # commit headers, including 1 final newline @@ -567,11 +867,44 @@ sub classify ($) { OrigParents => \@orig_ps); } - return $unknown->("complex merge"); + if (@p == 2 and + $r->{Msg} =~ m{^\[git-debrebase merged-breakwater.*\]$}m) { + # xxx ^ metadata tag needs adding to (5) + return $classify->("MergedBreakwaters"); + } + if ($r->{Msg} =~ m{^\[(git-debrebase|dgit)[: ].*\]$}m) { + return $unknown->("unknown kind of merge from $1"); + } + if (@p > 2) { + return $unknown->("octopus merge"); + } + + if (!$ENV{GIT_DEBREBASE_EXPERIMENTAL_MERGE}) { + return $unknown->("general two-parent merge"); + } + + return $classify->("VanillaMerge"); } -sub keycommits ($;$$$$) { - my ($head, $furniture, $unclean, $trouble, $fatal) = @_; +sub keycommits ($;$$$$$); + +sub mergedbreakwaters_anchor ($) { + my ($cl) = @_; + my $best_anchor; + foreach my $p (@{ $cl->{Parents} }) { + my ($panchor, $pbw) = keycommits $p->{CommitId}, + undef,undef,undef,undef, 1; + $best_anchor = $panchor + if !defined $best_anchor + or is_fast_fwd $best_anchor, $panchor; + fail "inconsistent anchors in merged-breakwaters $p->{CommitId}" + unless is_fast_fwd $panchor, $best_anchor; + } + return $best_anchor; +} + +sub keycommits ($;$$$$$) { + my ($head, $furniture, $unclean, $trouble, $fatal, $claimed_bw) = @_; # => ($anchor, $breakwater) # $unclean->("unclean-$tagsfx", $msg, $cl) @@ -587,6 +920,8 @@ sub keycommits ($;$$$$) { # $fatal is for unprocessable commits, and should normally cause # a failure. If ignored, agaion, (undef, undef) is returned. # + # If $claimed_bw, this is supposed to be a breakwater commit. + # # If a callback is undef, fail is called instead. # If a callback is defined but false, the situation is ignored. # Callbacks may say: @@ -594,6 +929,7 @@ sub keycommits ($;$$$$) { # if the answer is no longer wanted. my ($anchor, $breakwater); + $breakwater = $head if $claimed_bw; my $clogonly; my $cl; my $found_pm; @@ -606,6 +942,13 @@ sub keycommits ($;$$$$) { return unless $cb; $cb->("unclean-$tagsfx", $why, $cl, $mainwhy); }; + my $found_anchor = sub { + ($anchor) = @_; + $breakwater //= $clogonly; + $breakwater //= $head; + no warnings qw(exiting); + last; + }; for (;;) { $cl = classify $head; my $ty = $cl->{Type}; @@ -619,10 +962,7 @@ sub keycommits ($;$$$$) { } elsif ($ty eq 'Anchor' or $ty eq 'TreatAsAnchor' or $ty eq 'BreakwaterStart') { - $anchor = $head; - $breakwater //= $clogonly; - $breakwater //= $head; - last; + $found_anchor->($head); } elsif ($ty eq 'Upstream') { $x->($unclean, 'ordering', "packaging change ($breakwater) follows upstream change"," (eg $head)") @@ -650,6 +990,12 @@ sub keycommits ($;$$$$) { " ($head)"); return (undef,undef); } + } elsif ($ty eq 'VanillaMerge') { + $x->($trouble, 'vanillamerge', + "found vanilla merge"," ($head)"); + return (undef,undef); + } elsif ($ty eq 'MergedBreakwaters') { + $found_anchor->(mergedbreakwaters_anchor $cl); } else { $x->($fatal, 'unprocessable', "found unprocessable commit, cannot cope: $cl->{Why}", @@ -661,14 +1007,15 @@ sub keycommits ($;$$$$) { return ($anchor, $breakwater); } -sub walk ($;$$); -sub walk ($;$$) { +sub walk ($;$$$); +sub walk ($;$$$) { my ($input, - $nogenerate,$report) = @_; + $nogenerate,$report, $report_lprefix) = @_; # => ($tip, $breakwater_tip, $last_anchor) # (or nothing, if $nogenerate) printdebug "*** WALK $input ".($nogenerate//0)." ".($report//'-')."\n"; + $report_lprefix //= ''; # go through commits backwards # we generate two lists of commits to apply: @@ -700,7 +1047,7 @@ sub walk ($;$$) { my $prline = sub { return unless $report; - print $report $prdelim, @_; + print $report $prdelim, $report_lprefix, @_; $prdelim = "\n"; }; @@ -729,10 +1076,18 @@ sub walk ($;$$) { no warnings qw(exiting); last; }; + my $nomerge = sub { + my ($emsg) = @_; + merge_failed $cl->{MergeWreckNotes}, $emsg; + }; + + my $mwrecknote = sub { &mwrecknote($cl->{MergeWreckNotes}, @_); }; + my $last_anchor; for (;;) { $cl = classify $cur; + $cl->{MergeWreckNotes} //= {}; my $ty = $cl->{Type}; my $st = $cl->{SubType}; $prline->("$cl->{CommitId} $cl->{Type}"); @@ -832,6 +1187,188 @@ sub walk ($;$$) { return $bomb->(); } die "$ty ?"; + } elsif ($ty eq 'MergedBreakwaters') { + $last_anchor = mergedbreakwaters_anchor $cl; + $build_start->(' MergedBreakwaters', $cur); + last; + } elsif ($ty eq 'VanillaMerge') { + # User may have merged unstitched branch(es). We will + # have now lost what ffq-prev was then (since the later + # pseudomerge may introduce further changes). The effect + # of resolving such a merge is that we may have to go back + # further in history to find a merge base, since the one + # which was reachable via ffq-prev is no longer findable. + # This is suboptimal, but if it all works we'll have done + # the right thing. + # xxx we should warn the user in the docs about this + + my $ok=1; + my $best_anchor; + # We expect to find a dominating anchor amongst the + # inputs' anchors. That will be the new anchor. + # + # More complicated is finding a merge base for the + # breakwaters. We need a merge base that is a breakwater + # commit. The ancestors of breakwater commits are more + # breakwater commits and possibly upstream commits and the + # ancestors of those upstream. Upstreams might have + # arbitrary ancestors. But any upstream commit U is + # either included in both anchors, in which case the + # earlier anchor is a better merge base than any of U's + # ancestors; or U is not included in the older anchor, in + # which case U is not an ancestor of the vanilla merge at + # all. So no upstream commit, nor any ancestor thereof, + # is a best merge base. As for non-breakwater Debian + # commits: these are never ancestors of any breakwater. + # + # So any best merge base as found by git-merge-base + # is a suitable breakwater anchor. Usually there will + # be only one. + + printdebug "*** MERGE\n"; + + my @bwbcmd = (@git, qw(merge-base)); + my @ibcmd = (@git, qw(merge-base --all)); + my $might_be_in_bw = 1; + + my $ps = $cl->{Parents}; + + $mwrecknote->('vanilla-merge', $cl->{CommitId}); + + foreach my $p (@$ps) { + $prline->(" VanillaMerge ".$p->{Ix}); + $prprdelim->(); + my ($ptip, $pbw, $panchor) = + walk $p->{CommitId}, 0, $report, + $report_lprefix.' '; + $p->{Laundered} = $p->{SeriesTip} = $ptip; + $p->{Breakwater} = $p->{SeriesBase} = $pbw; + $p->{Anchor} = $panchor; + + my $lr = $p->{LeftRight} = (qw(left right))[$p->{Ix}]; + $mwrecknote->("$lr-input", $p->{CommitId}); + + my $mwrecknote_parent = sub { + my ($which) = @_; + $mwrecknote->("$lr-".(lc $which), $p->{$which}); + }; + $mwrecknote_parent->('Laundered'); + $mwrecknote_parent->('Breakwater'); + $mwrecknote_parent->('Anchor'); + + $best_anchor = $panchor if + !defined $best_anchor or + is_fast_fwd $best_anchor, $panchor; + + printdebug " MERGE BA best=".($best_anchor//'-'). + " p=$panchor\n"; + } + + $mwrecknote->('result-anchor', $best_anchor); + + foreach my $p (@$ps) { + $prline->(" VanillaMerge ".$p->{Ix}); + if (!is_fast_fwd $p->{Anchor}, $best_anchor) { + $nomerge->('divergent anchors'); + } elsif ($p->{Anchor} eq $best_anchor) { + print $report " SameAnchor" if $report; + } else { + print $report " SupersededAnchor" if $report; + } + if ($p->{Breakwater} eq $p->{CommitId}) { + # this parent commit was its own breakwater, + # ie it is part of the breakwater + print $report " Breakwater" if $report; + } else { + $might_be_in_bw = 0; + } + push @bwbcmd, $p->{Breakwater}; + push @ibcmd, $p->{CommitId}; + } + + if ($ok && $might_be_in_bw) { + # We could rewrite this to contaion the metadata + # declaring it to be MergedBreakwaters, but + # unnecessarily rewriting a merge seems unhelpful. + $prline->(" VanillaMerge MergedBreakwaters"); + $last_anchor = $best_anchor; + $build_start->('MergedBreakwaters', $cur); + } + + my $bwb = cmdoutput @bwbcmd; + + # OK, now we have a breakwater base, but we need the merge + # base for the interchange branch because we need the delta + # queue. + # + # This a the best merge base of our inputs which has the + # breakwater merge base as an ancestor. + + my @ibs = + grep /./, + split /\n/, + cmdoutput @ibcmd; + + @ibs or confess 'internal error, expected anchor at least ?'; + + my $ib; + my $ibleaf; + foreach my $tibix (0..$#ibs) { + my $tib = $ibs[$tibix]; + my $ff = is_fast_fwd $bwb, $tib; + my $ok = !$ff ? 'rej' : $ib ? 'extra' : 'ok'; + my $tibleaf = "interchange-mbcand-$ok-$tibix"; + $mwrecknote->($tibleaf, $tib); + next unless $ff; + next if $ib; + $ib = $tib; + $ibleaf = $tibleaf; + } + + $ib or $nomerge->("no suitable interchange merge base"); + + $prline->(" VanillaMerge Base"); + $prprdelim->(); + my ($btip, $bbw, $banchor) = eval { + walk $ib, 0, $report, $report_lprefix.' '; + }; + $nomerge->("walking interchange branch merge base ($ibleaf): ". + $@) if length $@; + + $mwrecknote->("mergebase-laundered", $btip); + $mwrecknote->("mergebase-breakwater", $bbw); + $mwrecknote->("mergebase-anchor", $banchor); + + my $ibinfo = { SeriesTip => $btip, + SeriesBase => $bbw, + Anchor => $banchor, + LeftRight => 'mergebase' }; + + $bbw eq $bwb + or $nomerge->("interchange merge-base ($ib)'s". + " breakwater ($bbw)". + " != breakwaters' merge-base ($bwb)"); + + grep { $_->{Anchor} eq $ibinfo->{Anchor} } @$ps + or $nomerge->("interchange merge-base ($ib)'s". + " anchor ($ibinfo->{SeriesBase})". + " != any merge input's anchor (". + (join ' ', map { $_->{Anchor} } @$ps). + ")"); + + $cl->{MergeInterchangeBaseInfo} = $ibinfo; + $cl->{MergeBestAnchor} = $best_anchor; + push @brw_cl, { + %$cl, + SpecialMethod => 'MergeCreateMergedBreakwaters', + $xmsg->('constructed from vanilla merge', + ' merged-breakwater'), + }; + push @upp_cl, { + %$cl, + SpecialMethod => 'MergeMergeSeries', + }; + $build_start->('MergeBreakwaters', $cur); } else { printdebug "*** WALK BOMB unrecognised\n"; return $bomb->(); @@ -850,15 +1387,9 @@ sub walk ($;$$) { my $rewriting = 0; - my $read_tree_debian = sub { - my ($treeish) = @_; - read_tree_subdir 'debian', "$treeish:debian"; - rm_subdir_cached 'debian/patches'; - }; my $read_tree_upstream = sub { my ($treeish) = @_; - runcmd @git, qw(read-tree), $treeish; - $read_tree_debian->($build); + read_tree_upstream $treeish, 0, $build; }; $#upp_cl = $upp_limit if defined $upp_limit; @@ -886,7 +1417,7 @@ sub walk ($;$$) { printdebug "WALK BUILD ".($cltree//'undef'). " $method (rewriting=$rewriting)\n"; if ($method eq 'Debian') { - $read_tree_debian->($cltree); + read_tree_debian($cltree); } elsif ($method eq 'Upstream') { $read_tree_upstream->($cltree); } elsif ($method eq 'StartRewrite') { @@ -896,13 +1427,52 @@ sub walk ($;$$) { $breakwater = $build; next; } elsif ($method eq 'DgitImportDebianUpdate') { - $read_tree_debian->($cltree); + read_tree_debian($cltree); } elsif ($method eq 'DgitImportUpstreamUpdate') { confess unless $rewriting; my $differs = (get_differs $build, $cltree); next unless $differs & D_UPS; $read_tree_upstream->($cltree); push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} }; + } elsif ($method eq 'MergeCreateMergedBreakwaters') { + print "Found a general merge, will try to tidy it up.\n"; + $rewriting = 1; + $read_tree_upstream->($cl->{MergeBestAnchor}); + $read_tree_upstream->($cl->{MergeBestAnchor}); + read_tree_debian($cltree); + @parents = map { $_->{Breakwater} } @{ $cl->{Parents} }; + } elsif ($method eq 'MergeMergeSeries') { + print "Running merge resolution for $cl->{CommitId}...\n"; + $build = merge_series + $build, $cl->{MergeWreckNotes}, + $cl->{MergeInterchangeBaseInfo}, + @{ $cl->{Parents} }; + $last_anchor = $cl->{MergeBestAnchor}; + + # Check for mismerges: + my $check = sub { + my ($against, $allow, $what) = @_; + my $differs = get_differs $build, $against; + $nomerge->(sprintf + "merge misresolved: %s are not the same (%s %s d.%#x)", + $what, $against, $build, $differs) + if $differs & ~($allow | D_PAT_ADD); + }; + + # Breakwater changes which were in each side of the + # merge will have been incorporated into the + # MergeCreateMergedBreakwaters output. Because the + # upstream series was rebased onto the new breakwater, + # so should all of the packaging changes which were in + # the input. + $check->($input, D_UPS, 'debian files'); + + # Upstream files are merge_series, which ought to + # have been identical to the original merge. + $check->($cl->{CommitId}, DS_DEB, 'upstream files'); + + print "Merge resolution successful.\n"; + next; } else { confess "$method ?"; } @@ -941,7 +1511,7 @@ sub walk ($;$$) { }; my $final_check = get_differs $build, $input; - die sprintf "internal error %#x %s %s", $final_check, $build, $input + die sprintf "internal error %#x %s %s", $final_check, $input, $build if $final_check & ~D_PAT_ADD; my @r = ($build, $breakwater, $last_anchor); @@ -1136,7 +1706,7 @@ sub record_ffq_prev_deferred () { push @deferred_updates, "update $ffq_prev $currentval $git_null_obj"; push @deferred_updates, "delete $gdrlast"; - push @deferred_update_messages, "Recorded current head for preservation"; + push @deferred_update_messages, "Recorded previous head for preservation"; return ('deferred', undef); } @@ -1593,6 +2163,9 @@ sub cmd_conclude () { } sub cmd_scrap () { + if (currently_rebasing()) { + runcmd @git, qw(rebase --abort); + } my ($ffq_prev, $gdrlast, $ffq_prev_commitish) = ffq_prev_info(); if (!$ffq_prev_commitish) { fail "No ongoing git-debrebase session." unless $opt_noop_ok; @@ -1614,15 +2187,7 @@ sub make_patches_staged ($) { my ($secret_head, $secret_bw, $last_anchor) = walk $head; fresh_workarea(); in_workarea sub { - runcmd @git, qw(checkout -q -b bw), $secret_bw; - runcmd @git, qw(checkout -q -b patch-queue/bw), $secret_head; - my @gbp_cmd = (qw(gbp pq export)); - my $r = system shell_cmd 'exec >../gbp-pq-err 2>&1', @gbp_cmd; - if ($r) { - { local ($!,$?); copy('../gbp-pq-err', \*STDERR); } - failedcmd @gbp_cmd; - } - runcmd @git, qw(add -f debian/patches); + gbp_pq_export 'bw', $secret_bw, $secret_head; }; } @@ -2064,6 +2629,7 @@ getoptions_main 'anchor=s' => \@opt_anchors, '--dgit=s' => \($dgit[0]), 'force!', + '--save-wreckage', \$opt_save_wreckage, '-i:s' => sub { my ($opt,$val) = @_; badusage "git-debrebase: no cuddling to -i for git-rebase"