my $cmd = [ 'git', "--git-dir=$fgrp->{cur_dst}",
qw(update-ref --stdin -z) ];
my $lei = $fgrp->{lei};
- $lei->qerr("# @$cmd");
- my $opt = { 0 => $r, 2 => $lei->{2} };
- my $pid = spawn($cmd, undef, $opt);
+ my $pack = PublicInbox::OnDestroy->new($$, \&pack_dst, $fgrp);
+ start_cmd($fgrp, $cmd, { 0 => $r, 2 => $lei->{2} }, $pack);
close $r or die "close(r): $!";
+ return if $fgrp->{dry_run};
for my $ref (keys %dst) {
my $new = delete $src{$ref};
my $old = $dst{$ref};
upr($lei, $w, 'create', $ref, $oid);
}
close($w) or warn "E: close(update-ref --stdin): $! (need git 1.8.5+)\n";
- my $pack = PublicInbox::OnDestroy->new($$, \&pack_dst, $fgrp);
- $LIVE->{$pid} = [ \&reap_cmd, $fgrp, $cmd, $pack ];
}
sub pack_dst { # packs lightweight satellite repos
my ($fgrp) = @_;
pack_refs($fgrp, $fgrp->{cur_dst});
+ delete($fgrp->{-fini}) // die 'BUG: no {-fini}'; # call v1_done
}
sub pack_refs {
my ($self, $git_dir) = @_;
- do_reap($self);
- return if !keep_going($self);
my $cmd = [ 'git', "--git-dir=$git_dir", qw(pack-refs --all --prune) ];
- $self->{lei}->qerr("# @$cmd");
- return if $self->{dry_run};
- my $opt = { 2 => $self->{lei}->{2} };
- $LIVE->{spawn($cmd, undef, $opt)} = [ \&reap_cmd, $self, $cmd ];
+ start_cmd($self, $cmd, { 2 => $self->{lei}->{2} });
}
sub fgrpv_done {
my ($fgrpv) = @_;
return if !$LIVE;
- my $pid;
my $first = $fgrpv->[0] // die 'BUG: no fgrpv->[0]';
return if !keep_going($first);
pack_refs($first, $first->{-osdir}); # objstore refs always packed
my $rn = $fgrp->{-remote};
my %opt = ( 2 => $fgrp->{lei}->{2} );
- my $update_ref = $fgrp->{dry_run} ? undef :
- PublicInbox::OnDestroy->new($$, \&fgrp_update, $fgrp);
+ my $update_ref = PublicInbox::OnDestroy->new($$,
+ \&fgrp_update, $fgrp);
my $src = [ 'git', "--git-dir=$fgrp->{-osdir}", 'for-each-ref',
"--format=refs/%(refname:lstrip=3)%00%(objectname)",
"refs/remotes/$rn/" ];
- do_reap($fgrp);
- $fgrp->{lei}->qerr("# @$src >SRC");
- if ($update_ref) {
- open(my $fh, '+>', undef) or die "open(src): $!";
- $pid = spawn($src, undef, { %opt, 1 => $fh });
- $fgrp->{srcfh} = $fh;
- $LIVE->{$pid} = [ \&reap_cmd, $fgrp, $src, $update_ref ]
- }
+ open(my $sfh, '+>', undef) or die "open(src): $!";
+ $fgrp->{srcfh} = $sfh;
+ start_cmd($fgrp, $src, { %opt, 1 => $sfh }, $update_ref);
my $dst = [ 'git', "--git-dir=$fgrp->{cur_dst}", 'for-each-ref',
'--format=%(refname)%00%(objectname)' ];
- do_reap($fgrp);
- $fgrp->{lei}->qerr("# @$dst >DST");
- if ($update_ref) {
- open(my $fh, '+>', undef) or die "open(dst): $!";
- $pid = spawn($dst, undef, { %opt, 1 => $fh });
- $fgrp->{dstfh} = $fh;
- $LIVE->{$pid} = [ \&reap_cmd, $fgrp, $dst, $update_ref ]
- }
+ open(my $dfh, '+>', undef) or die "open(dst): $!";
+ $fgrp->{dstfh} = $dfh;
+ start_cmd($fgrp, $dst, { %opt, 1 => $dfh }, $update_ref);
}
}
qw(--no-tags --multiple));
};
push(@fetch, "-j$j") if $j;
- my $pid;
while (my ($osdir, $fgrpv) = each %$todo) {
my $f = "$osdir/config";
$f, '--unset-all', "remotes.$grp"];
$self->{lei}->qerr("# @$cmd");
if (!$self->{dry_run}) {
- $pid = spawn($cmd, undef, { 2 => $self->{lei}->{2} });
+ my $pid = spawn($cmd, undef, { 2 => $self->{lei}->{2} });
waitpid($pid, 0) // die "waitpid: $!";
die "E: @$cmd: \$?=$?" if ($? && ($? >> 8) != 5);
}
$cmd = [ @git, "--git-dir=$osdir", @fetch, $grp ];
- do_reap($self);
- $self->{lei}->qerr("# @$cmd");
my $end = PublicInbox::OnDestroy->new($$, \&fgrpv_done, $fgrpv);
- return if $self->{dry_run};
- $pid = spawn($cmd, undef, $opt);
- $LIVE->{$pid} = [ \&reap_cmd, $self, $cmd, $end ];
+ start_cmd($self, $cmd, $opt, $end);
}
}
}
sub fp_done {
- my ($self, $go_fetch) = @_;
+ my ($self, $cb, @arg) = @_;
return if !keep_going($self);
my $fh = delete $self->{-show_ref} // die 'BUG: no show-ref output';
seek($fh, SEEK_SET, 0) or die "seek(show_ref): $!";
$self->{-ent} // die 'BUG: no -ent';
my $A = $self->{-ent}->{fingerprint} // die 'BUG: no fingerprint';
my $B = sha1_hex(do { local $/; <$fh> } // die("read(show_ref): $!"));
- return if $A ne $B; # $go_fetch->DESTROY fires
- $go_fetch->cancel;
+ return $cb->($self, @arg) if $A ne $B;
$self->{lei}->qerr("# $self->{-key} up-to-date");
}
-sub cmp_fp_fetch {
- my ($self, $go_fetch) = @_;
- # $go_fetch is either resume_fetch or fgrp_enqueue
- my $new = $self->{-ent}->{fingerprint} // die 'BUG: no fingerprint';
+sub cmp_fp_do {
+ my ($self, $cb, @arg) = @_;
+ # $cb is either resume_fetch or fgrp_enqueue
+ $self->{-ent} // return $cb->($self, @arg);
+ my $new = $self->{-ent}->{fingerprint} // return $cb->($self, @arg);
my $key = $self->{-key} // die 'BUG: no -key';
if (my $cur_ent = $self->{-local_manifest}->{$key}) {
# runs go_fetch->DESTROY run if eq
- return $go_fetch->cancel if $cur_ent->{fingerprint} eq $new;
+ return if $cur_ent->{fingerprint} eq $new;
}
my $dst = $self->{cur_dst} // $self->{dst};
my $cmd = ['git', "--git-dir=$dst", 'show-ref'];
my $opt = { 2 => $self->{lei}->{2} };
open($opt->{1}, '+>', undef) or die "open(tmp): $!";
$self->{-show_ref} = $opt->{1};
- my $done = PublicInbox::OnDestroy->new($$, \&fp_done, $self, $go_fetch);
+ my $done = PublicInbox::OnDestroy->new($$, \&fp_done, $self, $cb, @arg);
start_cmd($self, $cmd, $opt, $done);
}
-sub resume_fetch_maybe {
- my ($self, $uri, $fini) = @_;
- my $go_fetch = PublicInbox::OnDestroy->new($$, \&resume_fetch, @_);
- cmp_fp_fetch($self, $go_fetch) if $self->{-ent} &&
- defined($self->{-ent}->{fingerprint});
-}
-
sub resume_fetch {
my ($self, $uri, $fini) = @_;
return if !keep_going($self);
start_cmd($self, $cmd, $opt, $fini);
}
-sub fgrp_enqueue_maybe {
- my ($self, $fgrp) = @_;
- my $enq = PublicInbox::OnDestroy->new($$, \&fgrp_enqueue, $self, $fgrp);
- cmp_fp_fetch($self, $enq) if $self->{-ent} &&
- defined($self->{-ent}->{fingerprint});
- # $enq->DESTROY calls fgrp_enqueue otherwise
-}
-
sub fgrp_enqueue {
- my ($self, $fgrp) = @_;
- return if !keep_going($self);
- my $opt = { 2 => $self->{lei}->{2} };
+ my ($fgrp) = @_;
+ return if !keep_going($fgrp);
+ my $opt = { 2 => $fgrp->{lei}->{2} };
# --no-tags is required to avoid conflicts
my $u = $fgrp->{-uri} // die 'BUG: no {-uri}';
my $rn = $fgrp->{-remote} // die 'BUG: no {-remote}';
for ("url=$u", "fetch=+refs/*:refs/remotes/$rn/*", 'tagopt=--no-tags') {
my @kv = split(/=/, $_, 2);
$kv[0] = "remote.$rn.$kv[0]";
- $self->{dry_run} ? $self->{lei}->qerr("# @cmd @kv") :
+ $fgrp->{dry_run} ? $fgrp->{lei}->qerr("# @cmd @kv") :
run_die([@cmd, @kv], undef, $opt);
}
- push @{$self->{fgrp_todo}->{$fgrp->{-osdir}}}, $fgrp;
+ $fgrp->{fgrp_todo} // die 'BUG: no fgrp_todo';
+ push @{$fgrp->{fgrp_todo}->{$fgrp->{-osdir}}}, $fgrp;
}
sub clone_v1 {
my $resume = -d $dst;
if (my $fgrp = forkgroup_prep($self, $uri)) {
$fgrp->{-fini} = $fini;
- $resume ? fgrp_enqueue_maybe($self, $fgrp) :
- fgrp_enqueue($self, $fgrp);
+ $resume ? cmp_fp_do($fgrp, \&fgrp_enqueue) : fgrp_enqueue($fgrp)
} elsif ($resume) {
- resume_fetch_maybe($self, $uri, $fini);
+ cmp_fp_do($self, \&resume_fetch, $uri, $fini);
} else { # normal clone
my $cmd = [ @{$self->{-torsocks}},
clone_cmd($lei, my $opt = {}), "$uri", $dst ];