-# Copyright (C) 2020-2021 all contributors <meta@public-inbox.org>
+# Copyright (C) all contributors <meta@public-inbox.org>
# License: AGPL-3.0+ <https://www.gnu.org/licenses/agpl-3.0.txt>
# Detached/external index cross inbox search indexing support
use v5.10.1;
use parent qw(PublicInbox::ExtSearch PublicInbox::Lock);
use Carp qw(croak carp);
+use Scalar::Util qw(blessed);
use Sys::Hostname qw(hostname);
use POSIX qw(strftime);
use File::Glob qw(bsd_glob GLOB_NOSORT);
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->{-dangerous} = 1 if $opt->{dangerous};
$self->{oidx} = $oidx;
$self
}
$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
+ return if $xr3->[0]->[2] ne $new_smsg->oidbin; # loser
# replace the old smsg with the more boosted one
$new_smsg->{num} = $smsg->{num};
$req->{self}->{oidx}->add_overview($req->{eml}, $new_smsg);
}
+sub remove_doc ($$) {
+ my ($self, $docid) = @_;
+ $self->{oidx}->delete_by_num($docid);
+ $self->{oidx}->eidxq_del($docid);
+ $self->idx_shard($docid)->ipc_do('xdb_remove', $docid);
+}
+
+sub _unref_doc ($$$$$;$) {
+ my ($sync, $docid, $ibx, $xnum, $oidbin, $eml) = @_;
+ my $smsg;
+ if (ref($docid)) {
+ $smsg = $docid;
+ $docid = $smsg->{num};
+ }
+ if (defined($oidbin) && defined($xnum) && blessed($ibx) && $ibx->over) {
+ my $smsg = $ibx->over->get_art($xnum);
+ if ($smsg && $smsg->oidbin eq $oidbin) {
+ carp("BUG: (non-fatal) ".$ibx->eidx_key.
+ " #$xnum $smsg->{blob} still valid");
+ return;
+ }
+ }
+ my $s = 'DELETE FROM xref3 WHERE oidbin = ?';
+ $s .= ' AND ibx_id = ?' if defined($ibx);
+ $s .= ' AND xnum = ?' if defined($xnum);
+ my $del = $sync->{self}->{oidx}->dbh->prepare_cached($s);
+ my $col = 0;
+ $del->bind_param(++$col, $oidbin, SQL_BLOB);
+ $del->bind_param(++$col, $ibx->{-ibx_id}) if $ibx;
+ $del->bind_param(++$col, $xnum) if defined($xnum);
+ $del->execute;
+ my $xr3 = $sync->{self}->{oidx}->get_xref3($docid);
+ if (scalar(@$xr3) == 0) { # all gone
+ remove_doc($sync->{self}, $docid);
+ } else { # enqueue for reindex of remaining messages
+ if ($ibx) {
+ my $ekey = $ibx->{-gc_eidx_key} // $ibx->eidx_key;
+ my $idx = $sync->{self}->idx_shard($docid);
+ $idx->ipc_do('remove_eidx_info', $docid, $ekey, $eml);
+ } # else: we can't remove_eidx_info in reindex-only path
+
+ # replace invalidated blob ASAP with something which should be
+ # readable since we may commit the transaction on checkpoint.
+ # eidxq processing will re-apply boost
+ $smsg //= $sync->{self}->{oidx}->get_art($docid);
+ my $hex = unpack('H*', $oidbin);
+ if ($smsg && $smsg->{blob} eq $hex) {
+ $xr3->[0] =~ /:([a-f0-9]{40,}+)\z/ or
+ die "BUG: xref $xr3->[0] has no OID";
+ $sync->{self}->{oidx}->update_blob($smsg, $1);
+ }
+ # yes, add, we'll need to re-apply boost
+ $sync->{self}->{oidx}->eidxq_add($docid);
+ }
+ @$xr3
+}
+
sub do_xpost ($$) {
my ($req, $smsg) = @_;
my $self = $req->{self};
my $docid = $smsg->{num};
- my $idx = $self->idx_shard($docid);
my $oid = $req->{oid};
my $xibx = $req->{ibx};
my $eml = $req->{eml};
- my $eidx_key = $xibx->eidx_key;
if (my $new_smsg = $req->{new_smsg}) { # 'm' on cross-posted message
+ my $eidx_key = $xibx->eidx_key;
my $xnum = $req->{xnum};
$self->{oidx}->add_xref3($docid, $xnum, $oid, $eidx_key);
+ my $idx = $self->idx_shard($docid);
$idx->ipc_do('add_eidx_info', $docid, $eidx_key, $eml);
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,
- \$rm_eidx_info);
- if ($nr == 0) {
- $self->{oidx}->eidxq_del($docid);
- $idx->ipc_do('xdb_remove', $docid);
- } elsif ($rm_eidx_info) {
- $idx->ipc_do('remove_eidx_info',
- $docid, $eidx_key, $eml);
- $self->{oidx}->eidxq_add($docid); # yes, add
- }
+ } else { # 'd' no {xnum}
+ $self->git->async_wait_all;
+ $oid = pack('H*', $oid);
+ _unref_doc($req, $docid, $xibx, undef, $oid, $eml);
}
}
do_finalize($req);
}
-sub _blob_missing ($$) { # called when $smsg->{blob} is bad
+sub _blob_missing ($$) { # called when a known $smsg->{blob} is gone
my ($req, $smsg) = @_;
- my $self = $req->{self};
- 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});
- $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});
- }
+ # xnum and ibx are unknown, we only call this when an entry from
+ # /ei*/over.sqlite3 is bad, not on entries from xap*/over.sqlite3
+ $req->{self}->git->async_wait_all;
+ _unref_doc($req, $smsg, undef, undef, $smsg->oidbin);
}
sub ck_existing { # git->cat_async callback
# is the messages visible in the inbox currently being indexed?
# return the number if so
-sub cur_ibx_xnum ($$) {
- my ($req, $bref) = @_;
+sub cur_ibx_xnum ($$;$) {
+ my ($req, $bref, $mismatch) = @_;
my $ibx = $req->{ibx} or die 'BUG: current {ibx} missing';
$req->{eml} = PublicInbox::Eml->new($bref);
my ($id, $prev);
while (my $x = $ibx->over->next_by_mid($mid, \$id, \$prev)) {
return $x->{num} if $x->{blob} eq $req->{oid};
+ push @$mismatch, $x if $mismatch;
}
}
undef;
blob => $oid,
}, 'PublicInbox::Smsg';
$new_smsg->set_bytes($$bref, $size);
- defined($req->{xnum} = cur_ibx_xnum($req, $bref)) or return;
++${$req->{nr}};
+ my $mismatch = [];
+ $req->{xnum} = cur_ibx_xnum($req, $bref, $mismatch) // do {
+ warn "# deleted\n";
+ warn "# mismatch $_->{blob}\n" for @$mismatch;
+ ${$req->{latest_cmt}} = $req->{cur_cmt} //
+ die "BUG: {cur_cmt} unset ($oid)\n";
+ return;
+ };
do_step($req);
}
undef;
}
-sub gc_unref_doc ($$$$) {
- my ($self, $ibx_id, $eidx_key, $docid) = @_;
- 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};
- 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";
- }
- } else {
- warn "I: remove #$docid $eidx_key @oid\n";
- $self->idx_shard($docid)->ipc_do('xdb_remove', $docid);
- }
-}
-
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 = ?
+SELECT docid,xnum,oidbin FROM xref3 WHERE ibx_id = ?
EOM
$ibx_ck = $self->{oidx}->dbh->prepare(<<EOM);
SELECT ibx_id,eidx_key FROM inboxes
while (my ($ibx_id, $eidx_key) = $ibx_ck->fetchrow_array) {
next if $self->{ibx_map}->{$eidx_key};
$self->{midx}->remove_eidx_key($eidx_key);
- warn "I: deleting messages for $eidx_key...\n";
+ warn "# deleting messages for $eidx_key...\n";
$x3_doc->execute($ibx_id);
- while (defined(my $docid = $x3_doc->fetchrow_array)) {
- gc_unref_doc($self, $ibx_id, $eidx_key, $docid);
+ my $ibx = { -ibx_id => $ibx_id, -gc_eidx_key => $eidx_key };
+ while (my ($docid, $xnum, $oid) = $x3_doc->fetchrow_array) {
+ my $r = _unref_doc($sync, $docid, $ibx, $xnum, $oid);
+ $oid = unpack('H*', $oid);
+ $r = $r ? 'unref' : 'remove';
+ warn "# $r #$docid $eidx_key $oid\n";
if (checkpoint_due($sync)) {
$x3_doc = $ibx_ck = undef;
reindex_checkpoint($self, $sync);
$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";
+ warn "# removing $key\n";
$self->{oidx}->dbh->do(<<'', undef, $key);
DELETE FROM eidx_meta WHERE key = ?
}
- warn "I: $eidx_key removed\n";
+ warn "# $eidx_key removed\n";
}
}
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;
+ warn "# eliminated $nr stale xref3 entries\n" if $nr != 0;
reindex_checkpoint($self, $sync) if checkpoint_due($sync);
# fixup from old bugs:
$nr = $self->{oidx}->dbh->do(<<'');
DELETE FROM over WHERE num > 0 AND num NOT IN (SELECT docid FROM xref3)
- warn "I: eliminated $nr stale over entries\n" if $nr != 0;
+ warn "# eliminated $nr stale over entries\n" if $nr != 0;
+ reindex_checkpoint($self, $sync) if checkpoint_due($sync);
+
+ $nr = $self->{oidx}->dbh->do(<<'');
+DELETE FROM eidxq WHERE docid NOT IN (SELECT num FROM over)
+
+ warn "# eliminated $nr stale reindex queue entries\n" if $nr != 0;
reindex_checkpoint($self, $sync) if checkpoint_due($sync);
my ($cur) = $self->{oidx}->dbh->selectrow_array(<<EOM);
SELECT MIN(num) FROM over WHERE num > 0
EOM
$cur // return; # empty
- my ($r, $n, %active);
+ my ($r, $n, %active_shards);
$nr = 0;
while (1) {
$r = $self->{oidx}->dbh->selectcol_arrayref(<<"", undef, $cur);
for my $i ($cur..($n - 1)) {
my $idx = idx_shard($self, $i);
$idx->ipc_do('xdb_remove_quiet', $i);
- $active{$idx} = $idx;
+ $active_shards{$idx} = $idx;
}
$cur = $n + 1;
}
if (checkpoint_due($sync)) {
- for my $idx (values %active) {
+ for my $idx (values %active_shards) {
$nr += $idx->ipc_do('nr_quiet_rm')
}
- %active = ();
+ %active_shards = ();
reindex_checkpoint($self, $sync);
}
}
- warn "I: eliminated $nr stale Xapian documents\n" if $nr != 0;
+ warn "# eliminated $nr stale Xapian documents\n" if $nr != 0;
}
sub eidx_gc {
next_check => now() + 10,
checkpoint_unlocks => 1,
-opt => $opt,
+ self => $self,
};
$self->idx_init($opt); # acquire lock via V2Writable::_idx_init
eidx_gc_scan_inboxes($self, $sync);
}
return if $nr == 1; # likely, all good
+ $self->git->async_wait_all;
warn "W: #$docid split into $nr due to deduplication change\n";
my @todo;
for my $ary (values %$by_chash) {
for my $x (reverse @$ary) {
warn "removing #$docid xref3 $x->{blob}\n";
- my $n = $self->{oidx}->remove_xref3($docid, $x->{blob});
+ my $bin = $x->oidbin;
+ my $n = _unref_doc($sync, $docid, undef, undef, $bin);
die "BUG: $x->{blob} invalidated #$docid" if $n == 0;
}
my $x = pop(@$ary) // die "BUG: #$docid {by_chash} empty";
my $expect_oid = $req->{xr3r}->[$req->{ix}]->[2];
my $docid = $orig_smsg->{num};
if (is_bad_blob($oid, $type, $size, $expect_oid)) {
- my $remain = $self->{oidx}->remove_xref3($docid, $expect_oid);
+ my $oidbin = pack('H*', $expect_oid);
+ my $remain = _unref_doc($sync, $docid, undef, undef, $oidbin);
if ($remain == 0) {
- warn "W: #$docid gone or corrupted\n";
- $self->idx_shard($docid)->ipc_do('xdb_remove', $docid);
+ warn "W: #$docid ($oid) gone or corrupt\n";
} elsif (my $next_oid = $req->{xr3r}->[++$req->{ix}]->[2]) {
$self->git->cat_async($next_oid, \&_reindex_oid, $req);
} else {
- warn "BUG: #$docid gone (UNEXPECTED)\n";
- $self->idx_shard($docid)->ipc_do('xdb_remove', $docid);
+ warn "BUG: #$docid ($oid) gone (UNEXPECTED)\n";
}
return;
}
warn <<"";
BUG? #$docid $smsg->{blob} is not referenced by inboxes during reindex
- $self->{oidx}->delete_by_num($docid);
- $self->idx_shard($docid)->ipc_do('xdb_remove', $docid);
+ remove_doc($self, $docid);
return;
}
return $locked if $locked eq $cur;
}
my ($pid, $time, $euid, $ident) = split(/-/, $cur, 4);
- my $t = strftime('%Y-%m-%d %k:%M:%S', gmtime($time));
+ my $t = strftime('%Y-%m-%d %k:%M %z', localtime($time));
+ local $self->{current_info} = 'eidxq';
if ($euid == $> && $ident eq host_ident) {
- if (kill(0, $pid)) {
- warn <<EOM; return;
-I: PID:$pid (re)indexing Xapian since $t, it will continue our work
+ kill(0, $pid) and warn <<EOM and return;
+# PID:$pid (re)indexing since $t, it will continue our work
EOM
- }
if ($!{ESRCH}) {
- warn "I: eidxq_lock is stale ($cur), clobbering\n";
+ warn "# eidxq_lock is stale ($cur), clobbering\n";
return _eidxq_take($self);
}
warn "E: kill(0, $pid) failed: $!\n"; # fall-through:
sub eidxq_process ($$) { # for reindexing
my ($self, $sync) = @_;
- return unless $self->{cfg};
-
- return unless eidxq_lock_acquire($self);
+ local $self->{current_info} = 'eidxq process';
+ return unless ($self->{cfg} && eidxq_lock_acquire($self));
my $dbh = $self->{oidx}->dbh;
my $tot = $dbh->selectrow_array('SELECT COUNT(*) FROM eidxq') or return;
${$sync->{nr}} = 0;
xnum => $xsmsg->{num},
# {mids} and {chash} will be filled in at _reindex_unseen
};
- warn "I: reindex_unseen ${\$ibx->eidx_key}:$req->{xnum}:$req->{oid}\n";
+ warn "# reindex_unseen ${\$ibx->eidx_key}:$req->{xnum}:$req->{oid}\n";
$self->git->cat_async($xsmsg->{blob}, \&_reindex_unseen, $req);
}
-sub _unref_stale ($$$$$) {
- my ($sync, $docid, $ibx, $xnum, $oidbin) = @_;
- my $del = $sync->{self}->{oidx}->dbh->prepare_cached(<<'');
-DELETE FROM xref3 WHERE ibx_id = ? AND xnum = ? AND oidbin = ?
-
- $del->bind_param(1, $ibx->{-ibx_id});
- $del->bind_param(2, $xnum);
- $del->bind_param(3, $oidbin, SQL_BLOB);
- $del->execute;
- my $xr3 = $sync->{self}->{oidx}->get_xref3($docid, 1);
- my $idx = $sync->{self}->idx_shard($docid);
- if (scalar(@$xr3) == 0) { # all gone
- $sync->{self}->{oidx}->delete_by_num($docid);
- $sync->{self}->{oidx}->eidxq_del($docid);
- $idx->ipc_do('xdb_remove', $docid);
- } else { # enqueue for reindex of remaining messages
- $idx->ipc_do('remove_eidx_info', $docid, $ibx->eidx_key);
- $sync->{self}->{oidx}->eidxq_add($docid); # yes, add
- }
-}
-
sub _unref_stale_range ($$$) {
my ($sync, $ibx, $lt_or_gt) = @_;
my $r;
$r = $sync->{self}->{oidx}->dbh->selectall_arrayref(
<<EOS, undef, $ibx->{-ibx_id});
SELECT docid,xnum,oidbin FROM xref3
-WHERE ibx_id = ? AND xnum $lt_or_gt LIMIT $lim
+WHERE ibx_id = ? AND $lt_or_gt LIMIT $lim
EOS
return if $sync->{quit};
for (@$r) { # hopefully rare, not worth optimizing:
my ($docid, $xnum, $oidbin) = @$_;
my $hex = unpack('H*', $oidbin);
warn("# $xnum:$hex (#$docid): stale\n");
- _unref_stale($sync, $docid, $ibx, $xnum, $oidbin);
+ _unref_doc($sync, $docid, $ibx, $xnum, $oidbin);
}
} while (scalar(@$r) == $lim);
1;
my $slice = 10000;
my $opt = { limit => $slice };
my ($beg, $end) = (1, $slice);
- my $err = sync_inbox($self, $sync, $ibx) and return;
- my $max = $ibx->over->max;
+ my $ekey = $ibx->eidx_key;
+ my ($max, $max0);
+ do {
+ $max0 = $ibx->mm->num_highwater;
+ sync_inbox($self, $sync, $ibx) and return; # warned
+ $max = $ibx->mm->num_highwater;
+ return if $sync->{quit};
+ } while ($max > $max0 &&
+ warn("# $ekey moved $max0..$max, resyncing..\n"));
$end = $max if $end > $max;
# first, check if we missed any messages in target $ibx
my $msgs;
my $pr = $sync->{-opt}->{-progress};
- my $ekey = $ibx->eidx_key;
local $sync->{-regen_fmt} = "$ekey checking %u/$max\n";
${$sync->{nr}} = 0;
my $fast = $sync->{-opt}->{fast};
- my $dsu; # _unref_stale_range (< $lo) called
+ my $usr; # _unref_stale_range (< $lo) called
my ($lo, $hi);
while (scalar(@{$msgs = $ibx->over->query_xover($beg, $end, $opt)})) {
${$sync->{nr}} = $beg;
reindex_checkpoint($self, $sync); # release lock
}
($lo, $hi) = ($msgs->[0]->{num}, $msgs->[-1]->{num});
- $dsu //= _unref_stale_range($sync, $ibx, "< $lo");
+ $usr //= _unref_stale_range($sync, $ibx, "xnum < $lo");
my $x3a = $self->{oidx}->dbh->selectall_arrayref(
<<"", undef, $ibx_id, $lo, $hi);
SELECT xnum,oidbin,docid FROM xref3 WHERE
for my $num (@$docids) {
$self->{oidx}->eidxq_add($num);
}
- return if $sync->{quit};
}
+ return if $sync->{quit};
}
- return if $sync->{quit};
next unless scalar keys %x3m;
+ $self->git->async_wait_all; # wait for reindex_unseen
# eliminate stale/mismatched entries
my %mismatch = map { $_->{num} => $_->{blob} } @$msgs;
my ($xnum, $hex) = unpack('JH*', $k);
my $bin = pack('H*', $hex);
my $exp = $mismatch{$xnum};
+ if (defined $exp) {
+ my $smsg = $ibx->over->get_art($xnum) // next;
+ # $xnum may be expired by another process
+ if ($smsg->{blob} eq $hex) {
+ warn <<"";
+BUG: (non-fatal) $ekey #$xnum $smsg->{blob} still matches (old exp: $exp)
+
+ next;
+ } # else: continue to unref
+ }
my $m = defined($exp) ? "mismatch (!= $exp)" : 'stale';
warn("# $xnum:$hex (#@$docids): $m\n");
for my $i (@$docids) {
- _unref_stale($sync, $i, $ibx, $xnum, $bin);
+ _unref_doc($sync, $i, $ibx, $xnum, $bin);
}
+ return if $sync->{quit};
}
}
- _unref_stale_range($sync, $ibx, "> $hi") if defined($hi);
+ defined($hi) and ($hi < $max) and
+ _unref_stale_range($sync, $ibx, "xnum > $hi AND xnum <= $max");
}
sub _reindex_inbox ($$$) {
my $oidx = $self->{oidx};
for my $smsg (@$ary) {
my $gone = $smsg->{num};
- $oidx->merge_xref3($keep->{num}, $gone, $smsg->{blob});
- $self->idx_shard($gone)->ipc_do('xdb_remove', $gone);
- $oidx->delete_by_num($gone);
+ $oidx->merge_xref3($keep->{num}, $gone, $smsg->oidbin);
+ remove_doc($self, $gone);
}
}
}
$self->git->cleanup;
my $mode = 0644;
my $ALL = $self->git->{git_dir}; # topdir/ALL.git
- my ($has_new, $alt, $seen);
+ my ($has_new, $alt, $seen, $prune, $prune_nr);
if ($opt->{-private}) { # LeiStore
my $local = "$self->{topdir}/local"; # lei/store
$self->{mg} //= PublicInbox::MultiGit->new($self->{topdir},
} else { # extindex has no epochs
$self->{mg} //= PublicInbox::MultiGit->new($self->{topdir},
'ALL.git');
- ($alt, $seen) = $self->{mg}->read_alternates(\$mode,
- $opt->{-idx_gc});
+ $prune = $opt->{-idx_gc} ? \$prune_nr : undef;
+ ($alt, $seen) = $self->{mg}->read_alternates(\$mode, $prune);
PublicInbox::Import::init_bare($ALL);
}
}
$new .= "$d\n";
}
- ($has_new || $new ne '') and
+ ($has_new || $prune_nr || $new ne '') and
$self->{mg}->write_alternates($mode, $alt, $new);
$git_midx and $self->with_umask(sub {
my @cmd = ('multi-pack-index');