-# 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};
$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 ($req, $smsg) = @_;
# 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
- my $oidbin = pack('H*', $smsg->{blob});
$req->{self}->git->async_wait_all;
- _unref_doc($req, $smsg, undef, undef, $oidbin);
+ _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);
}
for my $ary (values %$by_chash) {
for my $x (reverse @$ary) {
warn "removing #$docid xref3 $x->{blob}\n";
- my $bin = pack('H*', $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 $oidbin = pack('H*', $expect_oid);
my $remain = _unref_doc($sync, $docid, undef, undef, $oidbin);
if ($remain == 0) {
- warn "W: #$docid gone or corrupted\n";
+ 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";
+ warn "BUG: #$docid ($oid) gone (UNEXPECTED)\n";
}
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
+I: PID:$pid (re)indexing since $t, it will continue our work
EOM
}
if ($!{ESRCH}) {
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;
$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 $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
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_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});
+ $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');