X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=git-debrebase;h=70808da019922f01d4fb0f77bb5748d1d7647197;hp=21c0582a511fd6dd4041cce0e6abd00ab60ac0ae;hb=8900e2002df925ebdf4941d18094fc5ca408e027;hpb=79c250465c2ed53040e59975d3396ec00825f6e7 diff --git a/git-debrebase b/git-debrebase index 21c0582a..70808da0 100755 --- a/git-debrebase +++ b/git-debrebase @@ -3,7 +3,7 @@ # Script helping make fast-forwarding histories while still rebasing # upstream deltas when working on Debian packaging # -# Copyright (C)2017 Ian Jackson +# Copyright (C)2017,2018 Ian Jackson # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -18,133 +18,142 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . + # usages: -# git-debrebase status -# git-debrebase start # like ffqrebase start + debrebase launder -# git-debrebase new-upstream [stuff] # see below -# git-debrebase # does debrebase start if necessary # -# git-debrebase analyse -# git-debrebase launder # prints breakwater tip -# git-debrebase create-new-upstream-breakwater [-f] ... +# git-debrebase [] new-upstream-v0 \ +# \ +# [ ...] \ +# [...] +# +# git-debrebase [ --] [] +# git-debrebase [] analyse +# git-debrebase [] launder # prints breakwater tip etc. +# git-debrebase [] downstream-rebase-launder-v0 # experimental +# +# git-debrebase [] gbp2debrebase-v0 \ +# + +# problems / outstanding questions: +# +# * dgit push with a `3.0 (quilt)' package means doing quilt +# fixup. Usually this involves recommitting the whole patch +# series, one at a time, with dpkg-source --commit. This is +# terribly terribly slow. (Maybe this should be fixed in dgit.) +# +# * dgit push usually needs to (re)make a pseudomerge. The "first" +# git-debrebase stripped out the previous pseudomerge and could +# have remembeed the HEAD. But it's not quite clear what history +# ought to be preserved and what should be discarded. For now +# the user will have to tell dgit --overwrite. # -# is -# [,][:][+][,...] +# To fix this, do we need a new push hook for dgit ? # -# if initial comma is supplied, entries are not positional. Unspecified -# means root (and there may be only one). -# xxx want auto branch names -# xxx too complicated -# how about for now -# [+] [ [+]...] -# ? plus options -# --new-upstream-different-subtrees +# * Workflow is currently clumsy. Lots of spurious runes to type. +# There's not even a guide. # -# automatic case -# git-debrebase new-upstream -# - previous breakwater merge must be gdr-generated -# - orig set is the same as before -# - implicitly uses upstream branches according to orig set -# - not all upstream branches need be updated -# - insists on fast-forward of each branch, unless -# --force (or --force=[/]) -# branch set adjustments -# git-debrebase new-upstream --add / -# git-debrebase new-upstream --rm / -# git-debrebase new-upstream / [/ ...] -# - orig set is adjusted -# - otherwise like auto (--add is not checked for ffness, obv) -# - multiple --add and --rm may be specified -# - --add makes new upstream the last contributor -# explicit -# git-debrebase / [] [/ [] ...] -# - orig set is precisely as specified now -# - previous breakwater merge is irrelevant -# - no fast forward checks -# for now only explicit with commitids - -# implicitly uses `upstream' -# # (or multiple other branches) -# git-debrebase new-upstream \ -# [/]= - -# UPSTREAM[,[[SUBDIR:]SUBUPSTREAM] -# default for SUBDIR: is from previous upstream merge[xxx terminology] -# +# * There are no tests. # -#xxx -# when starting must record original start (for ff) -# and new rebase basis +# * new-upstream-v0 has a terrible UI. You end up with giant +# runic command lines. # -# git-ffqrebase start [BASE] -# # records previous HEAD so it can be overwritten -# # records base for future git-ffqrebase -# git-ffqrebase set-base BASE -# git-ffqrebase -# git-ffqrebase finish -# git-ffqrebase status [BRANCH] +# One consequence of the lack of richness it can need --force in +# fairly sensible situations and there is no way to tell it what +# you are really trying to do, other than just --force. There +# should be an interface with some default branch names. # -# refs/ffqrebase-prev/BRANCH BRANCH may be refs/...; if not it means -# refs/ffqrebase-base/BRANCH refs/heads/BRANCH -# zero, one, or both of these may exist +# * There should be a standard convention for the version number, +# and unfinalised or not changelog, after new-upstream. # -# git-debrebase without start, if already started, is willing -# to strip pseudomerges provided that they overwrite exactly -# the previous HEAD -# xxxx is this right ? what matters is have we pushed -# I think in fact the right answer is: -# git-debrebase always strips out pseudomerges from its branch -# a pseudomerge is put in at the time we want to push -# at that time, we make a pseudomerge of the remote tracking -# branch (if raw git) or the dgit view (if dgit) -# for raw git git-ffqrebase, do want preciseley to record -# value of remote tracking branch or our branch, on start, so we -# overwrite only things we intend to -# the previous pseudomerge check for tags and remote branches ? +# * Handing of multi-orig dgit new-upstream .dsc imports is known to +# be broken. They may be not recognised, improperly converted, or +# their conversion may be unrecognised. +# +# * Docs need writing and updating. Even README.git-debrebase +# describes a design but may not reflect the implementation. +# +# * We need to develop a plausible model that works for derivatives, +# who probably want to maintain their stack on top of Debian's. +# downstream-rebase-launder-v0 may be a starting point? use strict; +use Debian::Dgit qw(:DEFAULT :playground); +setup_sigwarn(); + use Memoize; use Carp; use POSIX; use Data::Dumper; use Getopt::Long qw(:config posix_default gnu_compat bundling); +use Dpkg::Version; +use File::FnMatch qw(:fnmatch); -use Debian::Dgit qw(:DEFAULT $wa); +our ($opt_force, $opt_noop_ok); + +our $us = qw(git-debrebase); sub badusage ($) { my ($m) = @_; die "bad usage: $m\n"; } -sub cfg ($) { - my ($k) = @_; +sub cfg ($;$) { + my ($k, $optional) = @_; $/ = "\0"; my @cmd = qw(git config -z); push @cmd, qw(--get-all) if wantarray; push @cmd, $k; - my $out = cmdoutput @cmd; + my $out = cmdoutput_errok @cmd; + if (!defined $out) { + fail "missing required git config $k" unless $optional; + return (); + } return split /\0/, $out; } memoize('cfg'); +sub dd ($) { + my ($v) = @_; + my $dd = new Data::Dumper [ $v ]; + Terse $dd 1; Indent $dd 0; Useqq $dd 1; + return Dump $dd; +} + sub get_commit ($) { my ($objid) = @_; - my $data = git_cat_file $objid, 'commit'; + my $data = (git_cat_file $objid, 'commit'); $data =~ m/(?<=\n)\n/ or die "$objid ($data) ?"; return ($`,$'); } -sub D_DEB () { return 0x1; } # debian/ (not including debian/patches/) -sub D_UPS () { return 0x2; } # upstream files -sub D_PAT_ADD () { return 0x4; } # debian/patches/ extra patches at end -sub D_PAT_OTH () { return 0x8; } # debian/patches other changes +sub D_UPS () { 0x02; } # upstream files +sub D_PAT_ADD () { 0x04; } # debian/patches/ extra patches at end +sub D_PAT_OTH () { 0x08; } # debian/patches other changes +sub D_DEB_CLOG () { 0x10; } # debian/ (not patches/ or changelog) +sub D_DEB_OTH () { 0x20; } # debian/changelog +sub DS_DEB () { D_DEB_CLOG | D_DEB_OTH; } # debian/ (not patches/) + +our $playprefix = 'debrebase'; +our $rd; +our $workarea; -our $rd = ".git/git-debrebase"; -our $ud = "$rd/work"; our @git = qw(git); +sub in_workarea ($) { + my ($sub) = @_; + changedir $workarea; + my $r = eval { $sub->(); }; + { local $@; changedir $maindir; } + die $@ if $@; +} + +sub fresh_workarea () { + $workarea = fresh_playground "$playprefix/work"; + in_workarea sub { playtree_setup }; +} + sub get_differs ($$) { my ($x,$y) = @_; # This resembles quiltify_trees_differ, in dgit, a bit. @@ -160,22 +169,25 @@ sub get_differs ($$) { my @cmd = (@git, qw(diff-tree -z --no-renames)); push @cmd, @$opts; push @cmd, "$_:" foreach $x, $y; - push @cmd, @$limits; + push @cmd, '--', @$limits; my $diffs = cmdoutput @cmd; foreach (split /\0/, $diffs) { $fn->(); } }; $rundiff->([qw(--name-only)], [], sub { - $differs |= $_ eq 'debian' ? D_DEB : D_UPS; + $differs |= $_ eq 'debian' ? DS_DEB : D_UPS; }); - if ($differs & D_DEB) { - $differs &= ~D_DEB; + if ($differs & DS_DEB) { + $differs &= ~DS_DEB; $rundiff->([qw(--name-only -r)], [qw(debian)], sub { - $differs |= $_ eq m{^debian/patches/} ? D_PAT_OTH : D_DEB; + $differs |= + m{^debian/patches/} ? D_PAT_OTH : + $_ eq 'debian/changelog' ? D_DEB_CLOG : + D_DEB_OTH; }); die "mysterious debian changes $x..$y" - unless $differs & (D_PAT_OTH|D_DEB); + unless $differs & (D_PAT_OTH|DS_DEB); } if ($differs & D_PAT_OTH) { @@ -192,11 +204,11 @@ sub get_differs ($$) { } die unless s{^debian/patches/}{}; my $ok; - if ($mode eq 'A' && !m/(?:^|\.)series$/s) { + if ($mode eq 'A' && !m/\.series$/s) { $ok = 1; } elsif ($mode eq 'M' && $_ eq 'series') { - my $x_s = git_cat_file "$x:debian/patches/series", 'blob'; - my $y_s = git_cat_file "$y:debian/patches/series", 'blob'; + my $x_s = (git_cat_file "$x:debian/patches/series", 'blob'); + my $y_s = (git_cat_file "$y:debian/patches/series", 'blob'); chomp $x_s; $x_s .= "\n"; $ok = $x_s eq substr($y_s, 0, length $x_s); } else { @@ -227,6 +239,62 @@ sub calculate_committer_authline () { return $&; } +sub rm_subdir_cached ($) { + my ($subdir) = @_; + runcmd @git, qw(rm --quiet -rf --cached --ignore-unmatch), $subdir; +} + +sub read_tree_subdir ($$) { + my ($subdir, $new_tree_object) = @_; + rm_subdir_cached $subdir; + runcmd @git, qw(read-tree), "--prefix=$subdir/", $new_tree_object; +} + +sub make_commit ($$) { + my ($parents, $message_paras) = @_; + my $tree = cmdoutput @git, qw(write-tree); + my @cmd = (@git, qw(commit-tree), $tree); + push @cmd, qw(-p), $_ foreach @$parents; + push @cmd, qw(-m), $_ foreach @$message_paras; + return cmdoutput @cmd; +} + +our @fproblem_force_opts; +our $fproblems_forced; +our $fproblems_tripped; +sub fproblem ($$) { + my ($tag,$msg) = @_; + if (grep { $_ eq $tag } @fproblem_force_opts) { + $fproblems_forced++; + print STDERR "git-debrebase: safety catch overridden (-f$tag): $msg\n"; + } else { + $fproblems_tripped++; + print STDERR "git-debrebase: safety catch tripped (-f$tag): $msg\n"; + } +} + +sub fproblems_maybe_bail () { + if ($fproblems_forced) { + printf STDERR + "%s: safety catch trips: %d overriden by individual -f options\n", + $us, $fproblems_forced; + } + if ($fproblems_tripped) { + if ($opt_force) { + printf STDERR + "%s: safety catch trips: %d overriden by global --force\n", + $us, $fproblems_tripped; + } else { + fail sprintf + "%s: safety catch trips: %d blockers (you could -f, or --force)", + $us, $fproblems_tripped; + } + } +} +sub any_fproblems () { + return $fproblems_forced || $fproblems_tripped; +} + # classify returns an info hash like this # CommitId => $objid # Hdr => # commit headers, including 1 final newline @@ -245,6 +313,7 @@ sub calculate_committer_authline () { # # Types: # Packaging +# Changelog # Upstream # AddPatches # Mixed @@ -261,33 +330,51 @@ sub calculate_committer_authline () { # # BreakwaterUpstreamMerge # has additional entry in classification result -# OrigParents = [ subset of Parents ] +# OrigParents = [ subset of Parents ] # singleton list -sub classify ($) { - my ($objid) = @_; +sub parsecommit ($;$) { + my ($objid, $p_ref) = @_; + # => hash with CommitId Hdr Msg Tree Parents + # Parents entries have only Ix CommitId + # $p_ref, if provided, must be [] and is used as a base for Parents + + $p_ref //= []; + die if @$p_ref; my ($h,$m) = get_commit $objid; my ($t) = $h =~ m/^tree (\w+)$/m or die $objid; my (@ph) = $h =~ m/^parent (\w+)$/mg; - my @p; my $r = { CommitId => $objid, Hdr => $h, Msg => $m, Tree => $t, - Parents => \@p, + Parents => $p_ref, }; foreach my $ph (@ph) { - push @p, { - Ix => $#p, + push @$p_ref, { + Ix => scalar @$p_ref, CommitId => $ph, - Differs => (get_differs $t, $ph), }; } + return $r; +} + +sub classify ($) { + my ($objid) = @_; + + my @p; + my $r = parsecommit($objid, \@p); + my $t = $r->{Tree}; + + foreach my $p (@p) { + $p->{Differs} = (get_differs $p->{CommitId}, $t), + } + printdebug "classify $objid \$t=$t \@p", (map { sprintf " %s/%#x", $_->{CommitId}, $_->{Differs} } @p), "\n"; @@ -296,9 +383,7 @@ sub classify ($) { my ($type, @rest) = @_; $r = { %$r, Type => $type, @rest }; if ($debuglevel) { - my $dd = new Data::Dumper [ $r ]; - Terse $dd 1; Indent $dd 0; Useqq $dd 1; - printdebug " = $type ".(Dump $dd)."\n"; + printdebug " = $type ".(dd $r)."\n"; } return $r; }; @@ -309,16 +394,26 @@ sub classify ($) { return $r; }; + my $claims_to_be_breakwater = + $r->{Msg} =~ m{^\[git-debrebase breakwater.*\]$}m; + if (@p == 1) { + if ($claims_to_be_breakwater) { + return $unknown->("single-parent git-debrebase breakwater \`merge'"); + } my $d = $r->{Parents}[0]{Differs}; if ($d == D_PAT_ADD) { return $classify->(qw(AddPatches)); } elsif ($d & (D_PAT_ADD|D_PAT_OTH)) { return $unknown->("edits debian/patches"); - } elsif ($d == D_DEB) { - my ($ty,$dummy) = git_cat_file "$ph[0]:debian"; + } elsif ($d & DS_DEB and !($d & ~DS_DEB)) { + my ($ty,$dummy) = git_cat_file "$p[0]{CommitId}:debian"; if ($ty eq 'tree') { - return $classify->(qw(Packaging)); + if ($d == D_DEB_CLOG) { + return $classify->(qw(Changelog)); + } else { + return $classify->(qw(Packaging)); + } } elsif ($ty eq 'missing') { return $classify->(qw(BreakwaterStart)); } else { @@ -326,7 +421,7 @@ sub classify ($) { } } elsif ($d == D_UPS) { return $classify->(qw(Upstream)); - } elsif ($d == (D_DEB|D_UPS)) { + } elsif ($d & DS_DEB and $d & D_UPS and !($d & ~(DS_DEB|D_UPS))) { return $classify->(qw(Mixed)); } elsif ($d == 0) { return $unknown->("no changes"); @@ -339,7 +434,10 @@ sub classify ($) { } my @identical = grep { !$_->{Differs} } @p; - if (@p == 2 && @identical == 1) { + if (@p == 2 && @identical == 1 && !$claims_to_be_breakwater + # breakwater merges can look like pseudomerges, if they are + # "declare" commits (ie, there are no upstream changes) + ) { my @overwritten = grep { $_->{Differs} } @p; confess "internal error $objid ?" unless @overwritten==1; return $classify->(qw(Pseudomerge), @@ -358,12 +456,12 @@ sub classify ($) { Contributor => $bytime[1]); } foreach my $p (@p) { - my ($p_h, $p_m) = get_commit $p; + my ($p_h, $p_m) = get_commit $p->{CommitId}; $p->{IsOrigin} = $p_h !~ m/^parent \w+$/m; ($p->{IsDgitImport},) = $p_m =~ m/^\[dgit import ([0-9a-z]+) .*\]$/m; } my @orig_ps = grep { ($_->{IsDgitImport}//'X') eq 'orig' } @p; - my $m2 = $m; + my $m2 = $r->{Msg}; if (!(grep { !$_->{IsOrigin} } @p) and (@orig_ps >= @p - 1) and $m2 =~ s{^\[(dgit import unpatched .*)\]$}{[was: $1]}m) { @@ -381,15 +479,28 @@ sub classify ($) { # debian/) so debian breakwater branch should be 1st parent; that # way also there's also an easy rune to look for the upstream # patches (--topo-order). - if (@p == 2 && - !$haspatches && - !$p[0]{IsOrigin} && # breakwater merge never starts with an origin - !($p[0]{Differs} & ~D_DEB) && - !($p[1]{Differs} & ~D_UPS)) { - return $classify->(qw(BreakwaterUpstreamMerge), - OrigParents => [ $p[1] ]); + + # The above tells us which way *we* will generate them. But we + # might encounter ad-hoc breakwater merges generated manually, + # which might be the other way around. In principle, in some odd + # situations, a breakwater merge might have two identical parents. + # In that case we guess which way round it is (ie, which parent + # has the upstream history). The order of the 2-iteration loop + # controls which guess we make. + + foreach my $prevbrw (qw(0 1)) { + if (@p == 2 && + !$haspatches && + !$p[$prevbrw]{IsOrigin} && # breakwater never starts with an origin + !($p[!$prevbrw]{Differs} & ~DS_DEB) && # no non-debian changess + !($p[$prevbrw]{Differs} & ~D_UPS)) { # no non-upstream changes + return $classify->(qw(BreakwaterUpstreamMerge), + OrigParents => [ $p[!$prevbrw] ]); + } } - # xxx multi-.orig upstreams + + # multi-orig upstreams are represented with a breakwater merge + # from a single upstream commit which combines the orig tarballs return $unknown->("complex merge"); } @@ -398,9 +509,11 @@ sub walk ($;$$); sub walk ($;$$) { my ($input, $nogenerate,$report) = @_; - # => ($tip, $breakwater_tip) + # => ($tip, $breakwater_tip, $last_upstream_merge_in_breakwater) # (or nothing, if $nogenerate) + printdebug "*** WALK $input ".($nogenerate//0)." ".($report//'-')."\n"; + # go through commits backwards # we generate two lists of commits to apply: # breakwater branch and upstream patches @@ -411,10 +524,11 @@ sub walk ($;$$) { my $cl; my $xmsg = sub { - my ($appendinfo) = @_; + my ($prose, $info) = @_; my $ms = $cl->{Msg}; chomp $ms; - $ms .= "\n\n[git-debrebase $appendinfo]\n"; + $info //= ''; + $ms .= "\n\n[git-debrebase$info: $prose]\n"; return (Msg => $ms); }; my $rewrite_from_here = sub { @@ -439,7 +553,9 @@ sub walk ($;$$) { if ($nogenerate) { return (undef,undef); } - die "commit $cur: Cannot cope with this commit"; + die "commit $cur: Cannot cope with this commit (d.". + (join ' ', map { sprintf "%#x", $_->{Differs} } + @{ $cl->{Parents} }). ")"; }; my $build; @@ -452,6 +568,8 @@ sub walk ($;$$) { no warnings qw(exiting); last; }; + my $last_upstream_update; + for (;;) { $cl = classify $cur; my $ty = $cl->{Type}; @@ -464,11 +582,12 @@ sub walk ($;$$) { $cur = $p0; $rewrite_from_here->(); next; - } elsif ($ty eq 'Packaging') { + } elsif ($ty eq 'Packaging' or $ty eq 'Changelog') { push @brw_cl, $cl; $cur = $p0; next; } elsif ($ty eq 'BreakwaterStart') { + $last_upstream_update = $cur; $build_start->('FirstPackaging', $cur); } elsif ($ty eq 'Upstream') { push @upp_cl, $cl; @@ -477,7 +596,7 @@ sub walk ($;$$) { } elsif ($ty eq 'Mixed') { my $queue = sub { my ($q, $wh) = @_; - my $cls = { $cl, $xmsg->("split mixed commit: $wh part") }; + my $cls = { %$cl, $xmsg->("split mixed commit: $wh part") }; push @$q, $cls; }; $queue->(\@brw_cl, "debian"); @@ -493,6 +612,7 @@ sub walk ($;$$) { $cur = $contrib; next; } elsif ($ty eq 'BreakwaterUpstreamMerge') { + $last_upstream_update = $cur; $build_start->("PreviousBreakwater", $cur); } elsif ($ty eq 'DgitImportUnpatched') { my $pm = $pseudomerges[-1]; @@ -509,6 +629,7 @@ sub walk ($;$$) { printf $report " PM=%s \@Overwr:%d", $pm, (scalar @$ovwrs) if $report; if (@$ovwrs != 1) { + printdebug "*** WALK BOMB DgitImportUnpatched\n"; return $bomb->(); } my $ovwr = $ovwrs->[0]{CommitId}; @@ -540,12 +661,14 @@ sub walk ($;$$) { push @brw_cl, { %$cl, SpecialMethod => 'DgitImportUpstreamUpdate', - $xmsg->("convert dgit import: upstream changes") + $xmsg->("convert dgit import: upstream changes", + " breakwater") }; } $prline->(" Import"); $rewrite_from_here->(); $upp_limit //= $#upp_cl; # further, deeper, patches discarded + die 'BUG $upp_limit is not used anywhere?'; $cur = $ovwr; next; } else { @@ -560,26 +683,27 @@ sub walk ($;$$) { } die "$ty ?"; } else { + printdebug "*** WALK BOMB unrecognised\n"; return $bomb->(); } } $prprdelim->(); + + printdebug "*** WALK prep done cur=$cur". + " brw $#brw_cl upp $#upp_cl proc $#processed pm $#pseudomerges\n"; + return if $nogenerate; # Now we build it back up again - workarea_fresh(); + fresh_workarea(); my $rewriting = 0; - my $rm_tree_cached = sub { - my ($subdir) = @_; - runcmd @git, qw(rm --quiet -rf --cached), $subdir; - }; my $read_tree_debian = sub { my ($treeish) = @_; - $rm_tree_cached->(qw(debian)); - runcmd @git, qw(read-tree --prefix=debian/), "$treeish:debian"; + read_tree_subdir 'debian', "$treeish:debian"; + rm_subdir_cached 'debian/patches'; }; my $read_tree_upstream = sub { my ($treeish) = @_; @@ -589,9 +713,14 @@ sub walk ($;$$) { my $committer_authline = calculate_committer_authline(); + printdebug "WALK REBUILD $build ".(scalar @processed)."\n"; + + confess "internal error" unless $build eq (pop @processed)->{CommitId}; + in_workarea sub { mkdir $rd or $!==EEXIST or die $!; my $current_method; + runcmd @git, qw(read-tree), $build; foreach my $cl (qw(Debian), (reverse @brw_cl), { SpecialMethod => 'RecordBreakwaterTip' }, qw(Upstream), (reverse @upp_cl)) { @@ -602,6 +731,8 @@ sub walk ($;$$) { my $method = $cl->{SpecialMethod} // $current_method; my @parents = ($build); my $cltree = $cl->{CommitId}; + printdebug "WALK BUILD ".($cltree//'undef'). + " $method (rewriting=$rewriting)\n"; if ($method eq 'Debian') { $read_tree_debian->($cltree); } elsif ($method eq 'Upstream') { @@ -614,20 +745,26 @@ sub walk ($;$$) { next; } elsif ($method eq 'DgitImportDebianUpdate') { $read_tree_debian->($cltree); - $rm_tree_cached->(qw(debian/patches)); + rm_subdir_cached qw(debian/patches); } elsif ($method eq 'DgitImportUpstreamUpdate') { $read_tree_upstream->($cltree); push @parents, map { $_->{CommitId} } @{ $cl->{OrigParents} }; } else { confess "$method ?"; } - $rewriting ||= $cl ne pop @processed; + if (!$rewriting) { + my $procd = (pop @processed) // 'UNDEF'; + if ($cl ne $procd) { + $rewriting = 1; + printdebug "WALK REWRITING NOW cl=$cl procd=$procd\n"; + } + } my $newtree = cmdoutput @git, qw(write-tree); my $ch = $cl->{Hdr}; $ch =~ s{^tree .*}{tree $newtree}m or confess "$ch ?"; $ch =~ s{^parent .*\n}{}m; $ch =~ s{(?=^author)}{ - map { "parent $_\n" } @parents + join '', map { "parent $_\n" } @parents }me or confess "$ch ?"; if ($rewriting) { $ch =~ s{^committer .*$}{$committer_authline}m @@ -643,29 +780,62 @@ sub walk ($;$$) { my $newcommit = cmdoutput @cmd; confess "$ch ?" unless $rewriting or $newcommit eq $cl->{CommitId}; $build = $newcommit; + if (grep { $method eq $_ } qw(DgitImportUpstreamUpdate)) { + $last_upstream_update = $cur; + } } }; - runcmd @git, qw(diff-tree --quiet), $input, $build; + my $final_check = get_differs $build, $input; + die sprintf "internal error %#x %s %s", $final_check, $build, $input + if $final_check & ~D_PAT_ADD; - return ($build, $breakwater); + my @r = ($build, $breakwater, $last_upstream_update); + printdebug "*** WALK RETURN @r\n"; + return @r } -sub get_head () { return git_rev_parse qw(HEAD); } +sub get_head () { + git_check_unmodified(); + return git_rev_parse qw(HEAD); +} sub update_head ($$$) { my ($old, $new, $mrest) = @_; - runcmd @git, qw(update-ref -m), "git-debrebase $mrest", $new, $old; + runcmd @git, qw(update-ref -m), "debrebase: $mrest", 'HEAD', $new, $old; +} + +sub update_head_checkout ($$$) { + my ($old, $new, $mrest) = @_; + update_head $old, $new, $mrest; + runcmd @git, qw(reset --hard); +} + +sub update_head_postlaunder ($$$) { + my ($old, $tip, $reflogmsg) = @_; + return if $tip eq $old; + print "git-debrebase: laundered (head was $old)\n"; + update_head $old, $tip, $reflogmsg; + # no tree changes except debian/patches + runcmd @git, qw(rm --quiet --ignore-unmatch -rf debian/patches); } sub cmd_launder () { - badusage "no arguments to launder allowed"; + badusage "no arguments to launder allowed" if @ARGV; my $old = get_head(); - my ($tip,$breakwater) = walk $old; - update_head $old, $tip, 'launder'; - # no tree changes except debian/patches - runcmd @git, qw(rm --quiet -rf debian/patches); + my ($tip,$breakwater,$last_upstream_merge) = walk $old; + update_head_postlaunder $old, $tip, 'launder'; printf "# breakwater tip\n%s\n", $breakwater; + printf "# working tip\n%s\n", $tip; + printf "# last upstream merge\n%s\n", $last_upstream_merge; +} + +sub defaultcmd_rebase () { + my $old = get_head(); + my ($tip,$breakwater) = walk $old; + update_head_postlaunder $old, $tip, 'launder for rebase'; + @ARGV = qw(-i) unless @ARGV; # make configurable + runcmd @git, qw(rebase), @ARGV, $breakwater; } sub cmd_analyse () { @@ -675,23 +845,418 @@ sub cmd_analyse () { if (defined $old) { $old = git_rev_parse $old; } else { - $old = get_head(); + $old = git_rev_parse 'HEAD'; } my ($dummy,$breakwater) = walk $old, 1,*STDOUT; STDOUT->error and die $!; } -GetOptions("D+" => \$debuglevel) or die badusage "bad options\n"; +sub record_ffq_prev () { + # => ('status', "message") + # 'status' may be + # written message is undef + # exists + # detached + # weird-symref + # notbranch + # if not ff from some branch we should be ff from, is an fproblem + # if "written", will have printed something about that to stdout, + # and also some messages about ff checks + my $current = git_get_symref(); + return ('detached', 'detached HEAD') unless defined $current; + return ('weird-symref', 'HEAD symref is not to refs/') + unless $current =~ m{^refs/}; + my $ffq_prev = "refs/$ffq_refprefix/$'"; + + my $currentval = get_head(); + + my $exists = git_get_ref $ffq_prev; + return ('exists',"$ffq_prev already exists") if $exists; + + return ('not-branch', 'HEAD symref is not to refs/heads/') + unless $current =~ m{^refs/heads/}; + my $branch = $'; + + my @check_specs = split /\;/, (cfg "branch.$branch.ffq-ffrefs",1) // '*'; + my %checked; + + my $check = sub { + my ($lrref, $desc) = @_; + my $invert; + for my $chk (@check_specs) { + my $glob = $chk; + $invert = $glob =~ s{^[^!]}{}; + last if fnmatch $glob, $lrref; + } + return if $invert; + my $lrval = git_get_ref $lrref; + return unless defined $lrval; + + if (is_fast_fwd $lrval, $currentval) { + print "OK, you are ahead of $lrref\n" or die $!; + $checked{$lrref} = 1; + } if (is_fast_fwd $currentval, $lrval) { + $checked{$lrref} = -1; + fproblem 'behind', "you are behind $lrref, divergence risk"; + } else { + $checked{$lrref} = -1; + fproblem 'diverged', "you have diverged from $lrref"; + } + }; + + my $merge = cfg "branch.$branch.merge",1; + if (defined $merge && $merge =~ m{^refs/heads/}) { + my $rhs = $'; + my $check_remote = sub { + my ($remote, $desc) = (@_); + return unless defined $remote; + $check->("refs/remotes/$remote/$rhs", $desc); + }; + $check_remote->((cfg "branch.$branch.remote",1), + 'remote fetch/merge branch'); + $check_remote->((cfg "branch.$branch.pushRemote",1) // + (cfg "branch.$branch.pushDefault",1), + 'remote push branch'); + } + if ($branch =~ m{^dgit/}) { + $check->("remotes/dgit/$branch", 'remote dgit branch'); + } elsif ($branch =~ m{^master$}) { + $check->("remotes/dgit/dgit/sid", 'remote dgit branch for sid'); + } + + fproblems_maybe_bail(); + runcmd @git, qw(update-ref -m), "record current head for preservation", + $ffq_prev, $currentval, $git_null_obj; + print "Recorded current head for preservation\n" or die $!; + return ('written', undef); +} + +sub cmd_new_upstream_v0 () { + # automatically and unconditionally launders before rebasing + # if rebase --abort is used, laundering has still been done + + my %pieces; + + badusage "need NEW-VERSION UPS-COMMITTISH" unless @ARGV >= 2; + + # parse args - low commitment + my $new_version = (new Dpkg::Version scalar(shift @ARGV), check => 1); + my $new_upstream_version = $new_version->version(); + + my $new_upstream = git_rev_parse shift @ARGV; + + my $piece = sub { + my ($n, @x) = @_; # may be '' + my $pc = $pieces{$n} //= { + Name => $n, + Desc => ($n ? "upstream piece \`$n'" : "upstream (main piece"), + }; + while (my $k = shift @x) { $pc->{$k} = shift @x; } + $pc; + }; + + my @newpieces; + my $newpiece = sub { + my ($n, @x) = @_; # may be '' + my $pc = $piece->($n, @x, NewIx => (scalar @newpieces)); + push @newpieces, $pc; + }; + + $newpiece->('', + OldIx => 0, + New => $new_upstream, + ); + while (@ARGV && $ARGV[0] !~ m{^-}) { + my $n = shift @ARGV; + + badusage "for each EXTRA-UPS-NAME need EXTRA-UPS-COMMITISH" + unless @ARGV && $ARGV[0] !~ m{^-}; + + my $c = git_rev_parse shift @ARGV; + die unless $n =~ m/^$extra_orig_namepart_re$/; + $newpiece->($n, New => $c); + } + + # now we need to investigate the branch this generates the + # laundered version but we don't switch to it yet + my $old_head = get_head(); + my ($old_laundered_tip,$old_bw,$old_upstream_update) = walk $old_head; + + my $old_bw_cl = classify $old_bw; + my $old_upstream_update_cl = classify $old_upstream_update; + confess unless $old_upstream_update_cl->{OrigParents}; + my $old_upstream = parsecommit + $old_upstream_update_cl->{OrigParents}[0]{CommitId}; + + $piece->('', Old => $old_upstream->{CommitId}); + + if ($old_upstream->{Msg} =~ m{^\[git-debrebase }m) { + if ($old_upstream->{Msg} =~ + m{^\[git-debrebase upstream-combine \.((?: $extra_orig_namepart_re)+)\:.*\]$}m + ) { + my @oldpieces = ('', split / /, $1); + my $parentix = -1 + scalar @{ $old_upstream->{Parents} }; + foreach my $i (0..$#oldpieces) { + my $n = $oldpieces[$i]; + $piece->($n, Old => $old_upstream->{CommitId}.'^'.$parentix); + } + } else { + fproblem 'upstream-confusing', + "previous upstream $old_upstream->{CommitId} is from". + " git-debrebase but not an \`upstream-combine' commit"; + } + } + + foreach my $pc (values %pieces) { + if (!$pc->{Old}) { + fproblem 'upstream-new-piece', + "introducing upstream piece \`$pc->{Name}'"; + } elsif (!$pc->{New}) { + fproblem 'upstream-rm-piece', + "dropping upstream piece \`$pc->{Name}'"; + } elsif (!is_fast_fwd $pc->{Old}, $pc->{New}) { + fproblem 'upstream-not-ff', + "not fast forward: $pc->{Name} $pc->{Old}..$pc->{New}"; + } + } + + printdebug "%pieces = ", (dd \%pieces), "\n"; + printdebug "\@newpieces = ", (dd \@newpieces), "\n"; + + fproblems_maybe_bail(); + + my $new_bw; + + fresh_workarea(); + in_workarea sub { + my @upstream_merge_parents; + + if (!any_fproblems()) { + push @upstream_merge_parents, $old_upstream->{CommitId}; + } + + foreach my $pc (@newpieces) { # always has '' first + if ($pc->{Name}) { + read_tree_subdir $pc->{Name}, $pc->{New}; + } else { + runcmd @git, qw(read-tree), $pc->{New}; + } + push @upstream_merge_parents, $pc->{New}; + } + + # index now contains the new upstream + + if (@newpieces > 1) { + # need to make the upstream subtree merge commit + $new_upstream = make_commit \@upstream_merge_parents, + [ "Combine upstreams for $new_upstream_version", + ("[git-debrebase upstream-combine . ". + (join " ", map { $_->{Name} } @newpieces[1..$#newpieces]). + ": new upstream]"), + ]; + } + + # $new_upstream is either the single upstream commit, or the + # combined commit we just made. Either way it will be the + # "upstream" parent of the breakwater special merge. + + read_tree_subdir 'debian', "$old_bw:debian"; + + # index now contains the breakwater merge contents + $new_bw = make_commit [ $old_bw, $new_upstream ], + [ "Update to upstream $new_upstream_version", + "[git-debrebase breakwater: new upstream $new_upstream_version, merge]", + ]; + + # Now we have to add a changelog stanza so the Debian version + # is right. + die if unlink "debian"; + die $! unless $!==ENOENT or $!==ENOTEMPTY; + unlink "debian/changelog" or $!==ENOENT or die $!; + mkdir "debian" or die $!; + open CN, ">", "debian/changelog" or die $!; + my $oldclog = git_cat_file ":debian/changelog"; + $oldclog =~ m/^($package_re) \(\S+\) / or + fail "cannot parse old changelog to get package name"; + my $p = $1; + print CN <{Type}"; + my $keep = 0; + my $p0 = $cl->{Parents}[0]{CommitId}; + my $next; + if ($cl->{Type} eq 'Pseudomerge') { + print " ^".($cl->{Contributor}{Ix}+1); + $next = $cl->{Contributor}{CommitId}; + } elsif ($cl->{Type} eq 'AddPatches' or + $cl->{Type} eq 'Changelog') { + print " strip"; + $next = $p0; + } else { + print " keep"; + $next = $p0; + $keep = 1; + } + print "\n"; + if ($keep) { + $topmost_keep //= $current; + } else { + die "to-be stripped changes not on top of the branch\n" + if $topmost_keep; + } + $current = $next; + } + if ($topmost_keep eq $old_head) { + print "unchanged\n"; + } else { + print "updating to $topmost_keep\n"; + update_head_checkout + $old_head, $topmost_keep, + 'downstream-rebase-launder-v0'; + } +} + +GetOptions("D+" => \$debuglevel, + 'noop-ok', => \$opt_noop_ok, + 'f=s' => \@fproblem_force_opts, + 'force!') or die badusage "bad options\n"; initdebug('git-debrebase '); enabledebug if $debuglevel; my $toplevel = cmdoutput @git, qw(rev-parse --show-toplevel); chdir $toplevel or die "chdir $toplevel: $!"; -my $cmd = shift @ARGV; -my $cmdfn = $cmd; -$cmdfn =~ y/-/_/; -$cmdfn = ${*::}{"cmd_$cmdfn"}; +$rd = fresh_playground "$playprefix/misc"; -$cmdfn or badusage "unknown git-debrebase sub-operation $cmd"; -$cmdfn->(); +if (!@ARGV || $ARGV[0] =~ m{^-}) { + defaultcmd_rebase(); +} else { + my $cmd = shift @ARGV; + my $cmdfn = $cmd; + $cmdfn =~ y/-/_/; + $cmdfn = ${*::}{"cmd_$cmdfn"}; + + $cmdfn or badusage "unknown git-debrebase sub-operation $cmd"; + $cmdfn->(); +}