use Sys::Hostname qw(hostname);
use POSIX qw(strftime);
use File::Glob qw(bsd_glob GLOB_NOSORT);
+use PublicInbox::MultiGit;
use PublicInbox::Search;
use PublicInbox::SearchIdx qw(prepare_stack is_ancestor is_bad_blob);
use PublicInbox::OverIdx;
topdir => $dir,
creat => $opt->{creat},
ibx_map => {}, # (newsgroup//inboxdir) => $ibx
- ibx_cfg => [], # by config section order
+ ibx_active => [], # by config section order
+ ibx_known => [], # by config section order
indexlevel => $l,
transact_bytes => 0,
total_bytes => 0,
parallel => 1,
lock_path => "$dir/ei.lock",
}, __PACKAGE__;
- $self->{shards} = $self->count_shards || nproc_shards($opt->{creat});
+ $self->{shards} = $self->count_shards ||
+ nproc_shards({ nproc => $opt->{jobs} });
my $oidx = PublicInbox::OverIdx->new("$self->{xpfx}/over.sqlite3");
$self->{-no_fsync} = $oidx->{-no_fsync} = 1 if !$opt->{fsync};
$self->{oidx} = $oidx;
}
sub attach_inbox {
- my ($self, $ibx) = @_;
+ my ($self, $ibx, $types) = @_;
$self->{ibx_map}->{$ibx->eidx_key} //= do {
- delete $self->{-ibx_ary}; # invalidate cache
- push @{$self->{ibx_cfg}}, $ibx;
+ delete $self->{-ibx_ary_known}; # invalidate cache
+ delete $self->{-ibx_ary_active}; # invalidate cache
+ $types //= [ qw(active known) ];
+ for my $t (@$types) {
+ push @{$self->{"ibx_$t"}}, $ibx;
+ }
$ibx;
}
}
sub _ibx_attach { # each_inbox callback
- my ($ibx, $self) = @_;
- attach_inbox($self, $ibx);
+ my ($ibx, $self, $types) = @_;
+ attach_inbox($self, $ibx, $types);
}
sub attach_config {
- my ($self, $cfg) = @_;
+ my ($self, $cfg, $ibxs) = @_;
$self->{cfg} = $cfg;
- $cfg->each_inbox(\&_ibx_attach, $self);
+ my $types;
+ if ($ibxs) {
+ for my $ibx (@$ibxs) {
+ $self->{ibx_map}->{$ibx->eidx_key} //= do {
+ push @{$self->{ibx_active}}, $ibx;
+ push @{$self->{ibx_known}}, $ibx;
+ $ibx;
+ }
+ }
+ # invalidate cache
+ delete $self->{-ibx_ary_known};
+ delete $self->{-ibx_ary_active};
+ $types = [ 'known' ];
+ }
+ $types //= [ qw(known active) ];
+ $cfg->each_inbox(\&_ibx_attach, $self, $types);
}
sub check_batch_limit ($) {
${$req->{need_checkpoint}} = 1 if $n >= $self->{batch_bytes};
}
+sub apply_boost ($$) {
+ my ($req, $smsg) = @_;
+ my $id2pos = $req->{id2pos}; # index in ibx_sorted
+ my $xr3 = $req->{self}->{oidx}->get_xref3($smsg->{num}, 1);
+ @$xr3 = sort {
+ $id2pos->{$a->[0]} <=> $id2pos->{$b->[0]}
+ ||
+ $a->[1] <=> $b->[1] # break ties with {xnum}
+ } @$xr3;
+ my $new_smsg = $req->{new_smsg};
+ return if $xr3->[0]->[2] ne pack('H*', $new_smsg->{blob}); # loser
+
+ # replace the old smsg with the more boosted one
+ $new_smsg->{num} = $smsg->{num};
+ $new_smsg->populate($req->{eml}, $req);
+ $req->{self}->{oidx}->add_overview($req->{eml}, $new_smsg);
+}
+
sub do_xpost ($$) {
my ($req, $smsg) = @_;
my $self = $req->{self};
my $xnum = $req->{xnum};
$self->{oidx}->add_xref3($docid, $xnum, $oid, $eidx_key);
$idx->ipc_do('add_eidx_info', $docid, $eidx_key, $eml);
- check_batch_limit($req);
+ apply_boost($req, $smsg) if $req->{boost_in_use};
} else { # 'd'
my $rm_eidx_info;
my $nr = $self->{oidx}->remove_xref3($docid, $oid, $eidx_key,
my $xref3 = $self->{oidx}->get_xref3($smsg->{num});
my @keep = grep(!/:$smsg->{blob}\z/, @$xref3);
if (@keep) {
+ warn "E: $smsg->{blob} gone, removing #$smsg->{num}\n";
$keep[0] =~ /:([a-f0-9]{40,}+)\z/ or
die "BUG: xref $keep[0] has no OID";
my $oidhex = $1;
$self->{oidx}->remove_xref3($smsg->{num}, $smsg->{blob});
- my $upd = $self->{oidx}->update_blob($smsg, $oidhex);
- my $saved = $self->{oidx}->get_art($smsg->{num});
+ $self->{oidx}->update_blob($smsg, $oidhex) or warn <<EOM;
+E: #$smsg->{num} gone ($smsg->{blob} => $oidhex)
+EOM
} else {
+ warn "E: $smsg->{blob} gone, removing #$smsg->{num}\n";
$self->{oidx}->delete_by_num($smsg->{num});
}
}
sub gc_unref_doc ($$$$) {
my ($self, $ibx_id, $eidx_key, $docid) = @_;
- my $dbh = $self->{oidx}->dbh;
-
+ my $remain = 0;
# for debug/info purposes, oids may no longer be accessible
+ my $dbh = $self->{oidx}->dbh;
my $sth = $dbh->prepare_cached(<<'', undef, 1);
SELECT oidbin FROM xref3 WHERE docid = ? AND ibx_id = ?
$sth->execute($docid, $ibx_id);
my @oid = map { unpack('H*', $_->[0]) } @{$sth->fetchall_arrayref};
-
- $dbh->prepare_cached(<<'')->execute($docid, $ibx_id);
-DELETE FROM xref3 WHERE docid = ? AND ibx_id = ?
-
- my $remain = $self->{oidx}->get_xref3($docid);
- if (scalar(@$remain)) {
+ for my $oid (@oid) {
+ $remain += $self->{oidx}->remove_xref3($docid, $oid, $eidx_key);
+ }
+ if ($remain) {
$self->{oidx}->eidxq_add($docid); # enqueue for reindex
for my $oid (@oid) {
warn "I: unref #$docid $eidx_key $oid\n";
}
}
-sub eidx_gc {
- my ($self, $opt) = @_;
- $self->{cfg} or die "E: GC requires ->attach_config\n";
- $opt->{-idx_gc} = 1;
- $self->idx_init($opt); # acquire lock via V2Writable::_idx_init
-
- my $dbh = $self->{oidx}->dbh;
- $dbh->do('PRAGMA case_sensitive_like = ON'); # only place we use LIKE
- my $x3_doc = $dbh->prepare('SELECT docid FROM xref3 WHERE ibx_id = ?');
- my $ibx_ck = $dbh->prepare('SELECT ibx_id,eidx_key FROM inboxes');
- my $lc_i = $dbh->prepare(<<'');
-SELECT key FROM eidx_meta WHERE key LIKE ? ESCAPE ?
-
+sub eidx_gc_scan_inboxes ($$) {
+ my ($self, $sync) = @_;
+ my ($x3_doc, $ibx_ck);
+restart:
+ $x3_doc = $self->{oidx}->dbh->prepare(<<EOM);
+SELECT docid FROM xref3 WHERE ibx_id = ?
+EOM
+ $ibx_ck = $self->{oidx}->dbh->prepare(<<EOM);
+SELECT ibx_id,eidx_key FROM inboxes
+EOM
$ibx_ck->execute;
while (my ($ibx_id, $eidx_key) = $ibx_ck->fetchrow_array) {
next if $self->{ibx_map}->{$eidx_key};
$x3_doc->execute($ibx_id);
while (defined(my $docid = $x3_doc->fetchrow_array)) {
gc_unref_doc($self, $ibx_id, $eidx_key, $docid);
+ if (checkpoint_due($sync)) {
+ $x3_doc = $ibx_ck = undef;
+ reindex_checkpoint($self, $sync);
+ goto restart;
+ }
}
- $dbh->prepare_cached(<<'')->execute($ibx_id);
+ $self->{oidx}->dbh->do(<<'', undef, $ibx_id);
DELETE FROM inboxes WHERE ibx_id = ?
# drop last_commit info
my $pat = $eidx_key;
$pat =~ s/([_%\\])/\\$1/g;
+ $self->{oidx}->dbh->do('PRAGMA case_sensitive_like = ON');
+ my $lc_i = $self->{oidx}->dbh->prepare(<<'');
+SELECT key FROM eidx_meta WHERE key LIKE ? ESCAPE ?
+
$lc_i->execute("lc-%:$pat//%", '\\');
while (my ($key) = $lc_i->fetchrow_array) {
next if $key !~ m!\Alc-v[1-9]+:\Q$eidx_key\E//!;
warn "I: removing $key\n";
- $dbh->prepare_cached(<<'')->execute($key);
+ $self->{oidx}->dbh->do(<<'', undef, $key);
DELETE FROM eidx_meta WHERE key = ?
}
-
warn "I: $eidx_key removed\n";
}
+}
- # it's not real unless it's in `over', we use parallelism here,
- # shards will be reading directly from over, so commit
- $self->{oidx}->commit_lazy;
- $self->{oidx}->begin_lazy;
-
- for my $idx (@{$self->{idx_shards}}) {
- warn "I: cleaning up shard #$idx->{shard}\n";
- $idx->shard_over_check($self->{oidx});
- }
- my $nr = $dbh->do(<<'');
+sub eidx_gc_scan_shards ($$) { # TODO: use for lei/store
+ my ($self, $sync) = @_;
+ my $nr = $self->{oidx}->dbh->do(<<'');
DELETE FROM xref3 WHERE docid NOT IN (SELECT num FROM over)
warn "I: eliminated $nr stale xref3 entries\n" if $nr != 0;
+ # fixup from old bugs:
+ $nr = $self->{oidx}->dbh->do(<<'');
+DELETE FROM over WHERE num NOT IN (SELECT docid FROM xref3)
+
+ warn "I: eliminated $nr stale over entries\n" if $nr != 0;
+
+ my ($cur) = $self->{oidx}->dbh->selectrow_array(<<EOM);
+SELECT MIN(num) FROM over
+EOM
+ my ($max) = $self->{oidx}->dbh->selectrow_array(<<EOM);
+SELECT MAX(num) FROM over
+EOM
+ my $exists;
+restart:
+ $exists = $self->{oidx}->dbh->prepare(<<EOM);
+SELECT COUNT(num) FROM over WHERE num = ?
+EOM
+ for (; $cur <= $max; $cur++) {
+ $exists->execute($cur);
+ next if $exists->fetchrow_array != 0;
+ $self->idx_shard($cur)->ipc_do('xdb_remove_quiet', $cur);
+ if (checkpoint_due($sync)) {
+ $exists = undef;
+ reindex_checkpoint($self, $sync);
+ goto restart;
+ }
+ }
+}
+
+sub eidx_gc {
+ my ($self, $opt) = @_;
+ $self->{cfg} or die "E: GC requires ->attach_config\n";
+ $opt->{-idx_gc} = 1;
+ my $sync = {
+ need_checkpoint => \(my $need_checkpoint = 0),
+ check_intvl => 10,
+ next_check => now() + 10,
+ checkpoint_unlocks => 1,
+ -opt => $opt,
+ };
+ $self->idx_init($opt); # acquire lock via V2Writable::_idx_init
+ eidx_gc_scan_inboxes($self, $sync);
+ eidx_gc_scan_shards($self, $sync);
done($self);
}
my ($self, $sync, $smsg) = @_;
my $ibx_id = delete($smsg->{ibx_id}) // die '{ibx_id} unset';
my $pos = $sync->{id2pos}->{$ibx_id} // die "$ibx_id no pos";
- $self->{-ibx_ary}->[$pos] // die "BUG: ibx for $smsg->{blob} not mapped"
+ $self->{-ibx_ary_known}->[$pos] //
+ die "BUG: ibx for $smsg->{blob} not mapped"
}
sub _fd_constrained ($) {
chomp($soft = `sh -c 'ulimit -n'`);
}
if (defined($soft)) {
- my $want = scalar(@{$self->{-ibx_ary}}) + 64; # estimate
+ # $want is an estimate
+ my $want = scalar(@{$self->{ibx_active}}) + 64;
my $ret = $want > $soft;
if ($ret) {
warn <<EOF;
undef;
}
-sub ibx_sorted ($) {
- my ($self) = @_;
- $self->{-ibx_ary} //= do {
+sub ibx_sorted ($$) {
+ my ($self, $type) = @_;
+ $self->{"-ibx_ary_$type"} //= do {
# highest boost first, stable for config-ordering tiebreaker
use sort 'stable';
[ sort {
($b->{boost} // 0) <=> ($a->{boost} // 0)
- } @{$self->{ibx_cfg}} ];
+ } @{$self->{'ibx_'.$type} // die "BUG: $type unknown"} ];
}
}
+sub prep_id2pos ($) {
+ my ($self) = @_;
+ my %id2pos;
+ my $pos = 0;
+ $id2pos{$_->{-ibx_id}} = $pos++ for (@{ibx_sorted($self, 'known')});
+ \%id2pos;
+}
+
sub eidxq_process ($$) { # for reindexing
my ($self, $sync) = @_;
+ return unless $self->{cfg};
return unless eidxq_lock_acquire($self);
my $dbh = $self->{oidx}->dbh;
my $max = $dbh->selectrow_array('SELECT MAX(docid) FROM eidxq');
$pr->("Xapian indexing $min..$max (total=$tot)\n");
}
- $sync->{id2pos} //= do {
- my %id2pos;
- my $pos = 0;
- $id2pos{$_->{-ibx_id}} = $pos++ for (@{ibx_sorted($self)});
- \%id2pos;
- };
+ $sync->{id2pos} //= prep_id2pos($self);
my ($del, $iter);
restart:
$del = $dbh->prepare('DELETE FROM eidxq WHERE docid = ?');
$fetching = $min = $docid;
my $smsg = $ibx->over->get_art($xnum);
- my $oidhex = unpack('H*', $oidbin);
my $err;
if (!$smsg) {
$err = 'stale';
- } elsif ($smsg->{blob} ne $oidhex) {
+ } elsif (pack('H*', $smsg->{blob}) ne $oidbin) {
$err = "mismatch (!= $smsg->{blob})";
} else {
next; # likely, all good
}
# current_info already has eidx_key
+ my $oidhex = unpack('H*', $oidbin);
warn "$xnum:$oidhex (#$docid): $err\n";
my $del = $self->{oidx}->dbh->prepare_cached(<<'');
DELETE FROM xref3 WHERE ibx_id = ? AND xnum = ? AND oidbin = ?
sub eidx_reindex {
my ($self, $sync) = @_;
+ return unless $self->{cfg};
# acquire eidxq_lock early because full reindex takes forever
# and incremental -extindex processes can run during our checkpoints
warn "E: aborting --reindex\n";
return;
}
- for my $ibx (@{ibx_sorted($self)}) {
+ for my $ibx (@{ibx_sorted($self, 'active')}) {
_reindex_inbox($self, $sync, $ibx);
last if $sync->{quit};
}
my ($iter, $cur_mid);
my $min_id = 0;
my $idx = 0;
- local $sync->{-regen_fmt} = "dedupe %u/".$self->{oidx}->max."\n";
+ my ($max_id) = $self->{oidx}->dbh->selectrow_array(<<EOS);
+SELECT MAX(id) FROM msgid
+EOS
+ local $sync->{-regen_fmt} = "dedupe %u/$max_id\n";
# note: we could write this query more intelligently,
# but that causes lock contention with read-only processes
};
$self->git->cat_async($smsg->{blob}, \&dd_smsg, $dd);
}
- # need to wait on every single one
+ # need to wait on every single one @smsg contents can get
+ # invalidated inside dd_smsg for messages with multiple
+ # Message-IDs.
$self->git->async_wait_all;
if (checkpoint_due($sync)) {
local $SIG{QUIT} = $quit;
local $SIG{INT} = $quit;
local $SIG{TERM} = $quit;
- for my $ibx (@{ibx_sorted($self)}) {
+ for my $ibx (@{ibx_sorted($self, 'known')}) {
$ibx->{-ibx_id} //= $self->{oidx}->ibx_id($ibx->eidx_key);
}
+
+ if (scalar(grep { defined($_->{boost}) } @{$self->{ibx_known}})) {
+ $sync->{id2pos} //= prep_id2pos($self);
+ $sync->{boost_in_use} = 1;
+ }
+
if (my $msgids = delete($opt->{dedupe})) {
local $sync->{checkpoint_unlocks} = 1;
eidx_dedupe($self, $sync, $msgids);
# don't use $_ here, it'll get clobbered by reindex_checkpoint
if ($opt->{scan} // 1) {
- for my $ibx (@{ibx_sorted($self)}) {
+ for my $ibx (@{ibx_sorted($self, 'active')}) {
last if $sync->{quit};
sync_inbox($self, $sync, $ibx);
}
$self->git->cleanup;
my $mode = 0644;
- my $ALL = $self->git->{git_dir}; # ALL.git
- my $old = -d $ALL;
+ my $ALL = $self->git->{git_dir}; # topdir/ALL.git
+ my ($has_new, $alt, $seen);
if ($opt->{-private}) { # LeiStore
+ my $local = "$self->{topdir}/local"; # lei/store
+ $self->{mg} //= PublicInbox::MultiGit->new($self->{topdir},
+ 'ALL.git', 'local');
$mode = 0600;
- if (!$old) {
- umask 077; # don't bother restoring
+ unless (-d $ALL) {
+ umask 077; # don't bother restoring for lei
PublicInbox::Import::init_bare($ALL);
$self->git->qx(qw(config core.sharedRepository 0600));
}
- } else {
- PublicInbox::Import::init_bare($ALL) unless $old;
- }
- my $info_dir = "$ALL/objects/info";
- my $alt = "$info_dir/alternates";
- my (@old, @new, %seen); # seen: st_dev + st_ino
- if (-e $alt) {
- open(my $fh, '<', $alt) or die "open $alt: $!";
- $mode = (stat($fh))[2] & 07777;
- while (my $line = <$fh>) {
- chomp(my $d = $line);
-
- # expand relative path (/local/ stuff)
- substr($d, 0, 3) eq '../' and
- $d = "$ALL/objects/$d";
- if (my @st = stat($d)) {
- next if $seen{"$st[0]\0$st[1]"}++;
- } else {
- warn "W: stat($d) failed (from $alt): $!\n";
- next if $opt->{-idx_gc};
- }
- push @old, $line;
- }
+ ($alt, $seen) = $self->{mg}->read_alternates(\$mode);
+ $has_new = $self->{mg}->merge_epochs($alt, $seen);
+ } else { # extindex has no epochs
+ $self->{mg} //= PublicInbox::MultiGit->new($self->{topdir},
+ 'ALL.git');
+ ($alt, $seen) = $self->{mg}->read_alternates(\$mode,
+ $opt->{-idx_gc});
+ PublicInbox::Import::init_bare($ALL);
}
- # for LeiStore, and possibly some mirror-only state
- if (opendir(my $dh, my $local = "$self->{topdir}/local")) {
- # highest numbered epoch first
- for my $n (sort { $b <=> $a } map { substr($_, 0, -4) + 0 }
- grep(/\A[0-9]+\.git\z/, readdir($dh))) {
- my $d = "$local/$n.git/objects"; # absolute path
- if (my @st = stat($d)) {
- next if $seen{"$st[0]\0$st[1]"}++;
- # favor relative paths for rename-friendliness
- push @new, "../../local/$n.git/objects\n";
- } else {
- warn "W: stat($d) failed: $!\n";
- }
- }
- }
# git-multi-pack-index(1) can speed up "git cat-file" startup slightly
- my $dh;
my $git_midx = 0;
my $pd = "$ALL/objects/pack";
- if (!mkdir($pd) && $!{EEXIST} && opendir($dh, $pd)) {
- # drop stale symlinks
+ if (opendir(my $dh, $pd)) { # drop stale symlinks
while (defined(my $dn = readdir($dh))) {
if ($dn =~ /\.(?:idx|pack|promisor|bitmap|rev)\z/) {
my $f = "$pd/$dn";
unlink($f) if -l $f && !-e $f;
}
}
- undef $dh;
+ } elsif ($!{ENOENT}) {
+ mkdir($pd) or die "mkdir($pd): $!";
+ } else {
+ die "opendir($pd): $!";
}
- for my $ibx (@{ibx_sorted($self)}) {
+ my $new = '';
+ for my $ibx (@{ibx_sorted($self, 'active')}) {
# create symlinks for multi-pack-index
$git_midx += symlink_packs($ibx, $pd);
# add new lines to our alternates file
- my $line = $ibx->git->{git_dir} . "/objects\n";
- chomp(my $d = $line);
+ my $d = $ibx->git->{git_dir} . '/objects';
+ next if exists $alt->{$d};
if (my @st = stat($d)) {
- next if $seen{"$st[0]\0$st[1]"}++;
+ next if $seen->{"$st[0]\0$st[1]"}++;
} else {
warn "W: stat($d) failed (from $ibx->{inboxdir}): $!\n";
next if $opt->{-idx_gc};
}
- push @new, $line;
- }
- if (scalar @new) {
- push @old, @new;
- my $o = \@old;
- PublicInbox::V2Writable::write_alternates($info_dir, $mode, $o);
+ $new .= "$d\n";
}
+ ($has_new || $new ne '') and
+ $self->{mg}->write_alternates($mode, $alt, $new);
$git_midx and $self->with_umask(sub {
my @cmd = ('multi-pack-index');
push @cmd, '--no-progress' if ($opt->{quiet}//0) > 1;
$self->with_umask(\&_idx_init, $self, $opt);
$self->{oidx}->begin_lazy;
$self->{oidx}->eidx_prep;
- $self->{midx}->create_xdb if @new;
+ $self->{midx}->create_xdb if $new ne '';
}
sub _watch_commit { # PublicInbox::DS::add_timer callback
my $pr = $self->{-watch_sync}->{-opt}->{-progress};
$pr->('reloading ...') if $pr;
delete $self->{-resync_queue};
- delete $self->{-ibx_ary};
- $self->{ibx_cfg} = [];
+ delete $self->{-ibx_ary_known};
+ delete $self->{-ibx_ary_active};
+ $self->{ibx_known} = [];
+ $self->{ibx_active} = [];
%{$self->{ibx_map}} = ();
delete $self->{-watch_sync}->{id2pos};
my $cfg = PublicInbox::Config->new;
sub eidx_resync_start ($) { # -extindex --watch SIGUSR1 handler
my ($self) = @_;
- $self->{-resync_queue} //= [ @{ibx_sorted($self)} ];
+ $self->{-resync_queue} //= [ @{ibx_sorted($self, 'active')} ];
PublicInbox::DS::requeue($self); # trigger our ->event_step
}
sub eidx_watch { # public-inbox-extindex --watch main loop
my ($self, $opt) = @_;
- local %SIG = %SIG;
+ local @SIG{keys %SIG} = values %SIG;
for my $sig (qw(HUP USR1 TSTP QUIT INT TERM)) {
$SIG{$sig} = sub { warn "SIG$sig ignored while scanning\n" };
}
require PublicInbox::Sigfd;
my $idler = PublicInbox::InboxIdle->new($self->{cfg});
if (!$self->{cfg}) {
- $idler->watch_inbox($_) for (@{ibx_sorted($self)});
+ $idler->watch_inbox($_) for (@{ibx_sorted($self, 'active')});
+ }
+ for my $ibx (@{ibx_sorted($self, 'active')}) {
+ $ibx->subscribe_unlock(__PACKAGE__, $self)
}
- $_->subscribe_unlock(__PACKAGE__, $self) for (@{ibx_sorted($self)});
my $pr = $opt->{-progress};
$pr->("performing initial scan ...\n") if $pr;
my $sync = eidx_sync($self, $opt); # initial sync
};
my $quit = PublicInbox::SearchIdx::quit_cb($sync);
$sig->{QUIT} = $sig->{INT} = $sig->{TERM} = $quit;
- my $sigfd = PublicInbox::Sigfd->new($sig,
- $PublicInbox::Syscall::SFD_NONBLOCK);
- %SIG = (%SIG, %$sig) if !$sigfd;
local $self->{-watch_sync} = $sync; # for ->on_inbox_unlock
- if (!$sigfd) {
- # wake up every second to accept signals if we don't
- # have signalfd or IO::KQueue:
- PublicInbox::DS::sig_setmask($oldset);
- PublicInbox::DS->SetLoopTimeout(1000);
- }
PublicInbox::DS->SetPostLoopCallback(sub { !$sync->{quit} });
$pr->("initial scan complete, entering event loop\n") if $pr;
- PublicInbox::DS->EventLoop; # calls InboxIdle->event_step
+ # calls InboxIdle->event_step:
+ PublicInbox::DS::event_loop($sig, $oldset);
done($self);
}