X-Git-Url: http://www.git.stargrave.org/?a=blobdiff_plain;f=lib%2FPublicInbox%2FSolverGit.pm;h=eea59b6ddbda047496fe4917517fe4b3c6c53bdb;hb=48d4fdb2acbf8cf05dcb357df53b0d658f88fe39;hp=a13ae9e51fba3d1ddfa13ced17806eb809234f21;hpb=65323f060a3db731bb9fafa004336eeb4bbb8f00;p=public-inbox.git

diff --git a/lib/PublicInbox/SolverGit.pm b/lib/PublicInbox/SolverGit.pm
index a13ae9e5..eea59b6d 100644
--- a/lib/PublicInbox/SolverGit.pm
+++ b/lib/PublicInbox/SolverGit.pm
@@ -10,12 +10,12 @@
 package PublicInbox::SolverGit;
 use strict;
 use warnings;
-use File::Temp qw();
+use File::Temp 0.19 ();
 use Fcntl qw(SEEK_SET);
 use PublicInbox::Git qw(git_unquote git_quote);
-use PublicInbox::Spawn qw(spawn popen_rd);
 use PublicInbox::MsgIter qw(msg_iter msg_part_text);
 use PublicInbox::Qspawn;
+use PublicInbox::Tmpfile;
 use URI::Escape qw(uri_escape_utf8);
 
 # POSIX requires _POSIX_ARG_MAX >= 4096, and xargs is required to
@@ -44,6 +44,7 @@ my $MAX_PATCH = 9999;
 #	smsg => PublicInbox::SearchMsg object containing diff
 #	path_a => pre-image path
 #	path_b => post-image path
+#	n => numeric path of the patch (relative to worktree)
 # }
 
 # don't bother if somebody sends us a patch with these path components,
@@ -62,14 +63,15 @@ sub ERR ($$) {
 	die $err;
 }
 
-# look for existing blobs already in git repos
+# look for existing objects already in git repos
 sub solve_existing ($$) {
 	my ($self, $want) = @_;
 	my $oid_b = $want->{oid_b};
+	my $have_hints = scalar keys %$want > 1;
 	my @ambiguous; # Array of [ git, $oids]
 	foreach my $git (@{$self->{gits}}) {
 		my ($oid_full, $type, $size) = $git->check($oid_b);
-		if (defined($type) && $type eq 'blob') {
+		if (defined($type) && (!$have_hints || $type eq 'blob')) {
 			return [ $git, $oid_full, $type, int($size) ];
 		}
 
@@ -84,7 +86,8 @@ sub solve_existing ($$) {
 		# push @ambiguous, [ $git, @oids ];
 
 		dbg($self, "`$oid_b' ambiguous in " .
-				join("\n\t", $git->pub_urls) . "\n" .
+				join("\n\t", $git->pub_urls($self->{psgi_env}))
+                                . "\n" .
 				join('', map { "$_ blob\n" } @oids));
 	}
 	scalar(@ambiguous) ? \@ambiguous : undef;
@@ -120,8 +123,9 @@ sub extract_diff ($$$$$) {
 
 
 			# start writing the diff out to a tempfile
-			my $pn = ++$self->{tot};
-			open($tmp, '>', $self->{tmp}->dirname . "/$pn") or
+			my $path = ++$self->{tot};
+			$di->{n} = $path;
+			open($tmp, '>', $self->{tmp}->dirname . "/$path") or
 							die "open(tmp): $!";
 
 			push @$hdr_lines, $l;
@@ -178,7 +182,7 @@ sub filename_query ($) {
 	join('', map { qq( dfn:"$_") } split(/\.\./, $_[0]));
 }
 
-sub find_extract_diff ($$$) {
+sub find_extract_diffs ($$$) {
 	my ($self, $ibx, $want) = @_;
 	my $srch = $ibx->search or return;
 
@@ -204,16 +208,17 @@ sub find_extract_diff ($$$) {
 	}
 
 	my $msgs = $srch->query($q, { relevance => 1 });
-	my $re = qr/\Aindex ($pre[a-f0-9]*)\.\.($post[a-f0-9]*)(?: (\d+))?/;
+	my $re = qr/\Aindex ($pre[a-f0-9]*)\.\.($post[a-f0-9]*)(?: ([0-9]+))?/;
 
-	my $di;
+	my @di;
 	foreach my $smsg (@$msgs) {
 		$ibx->smsg_mime($smsg) or next;
 		msg_iter(delete($smsg->{mime}), sub {
-			$di ||= extract_diff($self, $_[0], $re, $ibx, $smsg);
+			my $di = extract_diff($self, $_[0], $re, $ibx, $smsg);
+			push @di, $di if defined($di);
 		});
-		return $di if $di;
 	}
+	@di ? \@di : undef;
 }
 
 sub prepare_index ($) {
@@ -234,13 +239,13 @@ sub prepare_index ($) {
 	my $path_a = $di->{path_a} or die "BUG: path_a missing for $oid_full";
 	my $mode_a = $di->{mode_a} || extract_old_mode($di);
 
-	open my $in, '+>', undef or die "open: $!";
+	my $in = tmpfile("update-index.$oid_full") or die "tmpfile: $!";
 	print $in "$mode_a $oid_full\t$path_a\0" or die "print: $!";
 	$in->flush or die "flush: $!";
 	sysseek($in, 0, 0) or die "seek: $!";
 
 	dbg($self, 'preparing index');
-	my $rdr = { 0 => fileno($in) };
+	my $rdr = { 0 => fileno($in), -hold => $in };
 	my $cmd = [ qw(git update-index -z --index-info) ];
 	my $qsp = PublicInbox::Qspawn->new($cmd, $self->{git_env}, $rdr);
 	$qsp->psgi_qx($self->{psgi_env}, undef, sub {
@@ -421,6 +426,23 @@ sub start_ls_files ($$) {
 	});
 }
 
+sub oids_same_ish ($$) {
+	(index($_[0], $_[1]) == 0) || (index($_[1], $_[0]) == 0);
+}
+
+sub skip_identical ($$$) {
+	my ($self, $patches, $cur_oid_b) = @_;
+	while (my $nxt = $patches->[0]) {
+		if (oids_same_ish($cur_oid_b, $nxt->{oid_b})) {
+			dbg($self, 'skipping '.di_url($self, $nxt).
+				" for $cur_oid_b");
+			shift @$patches;
+		} else {
+			return;
+		}
+	}
+}
+
 sub do_git_apply ($) {
 	my ($self) = @_;
 	my $dn = $self->{tmp}->dirname;
@@ -428,20 +450,23 @@ sub do_git_apply ($) {
 
 	# we need --ignore-whitespace because some patches are CRLF
 	my @cmd = (qw(git -C), $dn, qw(apply --cached --ignore-whitespace
-			--whitespace=warn --verbose));
+			--unidiff-zero --whitespace=warn --verbose));
 	my $len = length(join(' ', @cmd));
 	my $total = $self->{tot};
 	my $di; # keep track of the last one for "git ls-files"
+	my $prv_oid_b;
 
 	do {
 		my $i = ++$self->{nr};
 		$di = shift @$patches;
 		dbg($self, "\napplying [$i/$total] " . di_url($self, $di) .
 			"\n" . join('', @{$di->{hdr_lines}}));
-		my $path = $total + 1 - $i;
+		my $path = $di->{n};
 		$len += length($path) + 1;
 		push @cmd, $path;
-	} while (@$patches && $len < $ARG_SIZE_MAX);
+		$prv_oid_b = $di->{oid_b};
+	} while (@$patches && $len < $ARG_SIZE_MAX &&
+		 !oids_same_ish($patches->[0]->{oid_b}, $prv_oid_b));
 
 	my $rdr = { 2 => 1 };
 	my $qsp = PublicInbox::Qspawn->new(\@cmd, $self->{git_env}, $rdr);
@@ -449,7 +474,16 @@ sub do_git_apply ($) {
 		my ($bref) = @_;
 		dbg($self, $$bref);
 		if (my $err = $qsp->{err}) {
-			ERR($self, "git apply error: $err");
+			my $msg = "git apply error: $err";
+			my $nxt = $patches->[0];
+			if ($nxt && oids_same_ish($nxt->{oid_b}, $prv_oid_b)) {
+				dbg($self, $msg);
+				dbg($self, 'trying '.di_url($self, $nxt));
+			} else {
+				ERR($self, $msg);
+			}
+		} else {
+			skip_identical($self, $patches, $di->{oid_b});
 		}
 		eval { start_ls_files($self, $di) };
 		ERR($self, $@) if $@;
@@ -480,10 +514,11 @@ sub resolve_patch ($$) {
 		die "Loop detected solving $cur_want\n";
 	}
 	if (my $existing = solve_existing($self, $want)) {
+		my ($found_git, undef, $type, undef) = @$existing;
 		dbg($self, "found $cur_want in " .
-			join("\n", $existing->[0]->pub_urls));
+			join("\n", $found_git->pub_urls($self->{psgi_env})));
 
-		if ($cur_want eq $self->{oid_want}) { # all done!
+		if ($cur_want eq $self->{oid_want} || $type ne 'blob') {
 			eval { delete($self->{user_cb})->($existing) };
 			die "E: $@" if $@;
 			return;
@@ -494,15 +529,16 @@ sub resolve_patch ($$) {
 
 	# scan through inboxes to look for emails which results in
 	# the oid we want:
-	my $di;
 	foreach my $ibx (@{$self->{inboxes}}) {
-		$di = find_extract_diff($self, $ibx, $want) or next;
+		my $diffs = find_extract_diffs($self, $ibx, $want) or next;
 
-		unshift @{$self->{patches}}, $di;
-		dbg($self, "found $cur_want in ".di_url($self, $di));
+		unshift @{$self->{patches}}, @$diffs;
+		dbg($self, "found $cur_want in ".
+			join("\n\t", map { di_url($self, $_) } @$diffs));
 
 		# good, we can find a path to the oid we $want, now
 		# lets see if we need to apply more patches:
+		my $di = $diffs->[0];
 		my $src = $di->{oid_a};
 
 		unless ($src =~ /\A0+\z/) {
@@ -540,6 +576,7 @@ sub new {
 }
 
 # recreate $oid_want using $hints
+# hints keys: path_a, path_b, oid_a
 # Calls {user_cb} with: [ ::Git object, oid_full, type, size, di (diff_info) ]
 # with found object, or undef if nothing was found
 # Calls {user_cb} with a string error on fatal errors
@@ -558,7 +595,7 @@ sub solve ($$$$$) {
 	$self->{todo} = [ { %$hints, oid_b => $oid_want } ];
 	$self->{patches} = []; # [ $di, $di, ... ]
 	$self->{found} = {}; # { abbr => [ ::Git, oid, type, size, $di ] }
-	$self->{tmp} = File::Temp->newdir('solver.tmp-XXXXXXXX', TMPDIR => 1);
+	$self->{tmp} = File::Temp->newdir("solver.$oid_want-XXXXXXXX", TMPDIR => 1);
 
 	dbg($self, "solving $oid_want ...");
 	my $step_cb = step_cb($self);