X-Git-Url: http://www.git.stargrave.org/?a=blobdiff_plain;f=lib%2FPublicInbox%2FSearchIdx.pm;h=0824db03c113a5d001b846b3f4c115ae1a3d7de2;hb=59b3f7584817735a69b45388fd2d4c40750cf6e4;hp=f8155ecc0f916a8733ce96cca50686882112bef4;hpb=04ba9f9f26e15989944baa0204072f54c00d781f;p=public-inbox.git diff --git a/lib/PublicInbox/SearchIdx.pm b/lib/PublicInbox/SearchIdx.pm index f8155ecc..0824db03 100644 --- a/lib/PublicInbox/SearchIdx.pm +++ b/lib/PublicInbox/SearchIdx.pm @@ -4,31 +4,52 @@ # # Indexes mail with Xapian and our (SQLite-based) ::Msgmap for use # with the web and NNTP interfaces. This index maintains thread -# relationships for use by Mail::Thread. This writes to the search -# index. +# relationships for use by PublicInbox::SearchThread. +# This writes to the search index. package PublicInbox::SearchIdx; use strict; use warnings; use Fcntl qw(:flock :DEFAULT); -use Email::MIME; +use PublicInbox::MIME; use Email::MIME::ContentType; $Email::MIME::ContentType::STRICT_PARAMS = 0; use base qw(PublicInbox::Search); use PublicInbox::MID qw/mid_clean id_compress mid_mime/; use PublicInbox::MsgIter; use Carp qw(croak); +use POSIX qw(strftime); require PublicInbox::Git; -*xpfx = *PublicInbox::Search::xpfx; -use constant MAX_MID_SIZE => 244; # max term size - 1 in Xapian use constant { + MAX_MID_SIZE => 244, # max term size - 1 in Xapian PERM_UMASK => 0, OLD_PERM_GROUP => 1, OLD_PERM_EVERYBODY => 2, PERM_GROUP => 0660, PERM_EVERYBODY => 0664, + BATCH_BYTES => 1_000_000, + DEBUG => !!$ENV{DEBUG}, }; +my %GIT_ESC = ( + a => "\a", + b => "\b", + f => "\f", + n => "\n", + r => "\r", + t => "\t", + v => "\013", +); + +sub git_unquote ($) { + my ($s) = @_; + return $s unless ($s =~ /\A"(.*)"\z/); + $s = $1; + $s =~ s/\\([abfnrtv])/$GIT_ESC{$1}/g; + $s =~ s/\\([0-7]{1,3})/chr(oct($1))/ge; + $s; +} + sub new { my ($class, $inbox, $creat) = @_; my $git_dir = $inbox; @@ -71,7 +92,6 @@ sub _xdb_acquire { require File::Path; _lock_acquire($self); File::Path::mkpath($dir); - $self->{batch_size} = 100; $flag = Search::Xapian::DB_CREATE_OR_OPEN; } $self->{xdb} = Search::Xapian::WritableDatabase->new($dir, $flag); @@ -95,19 +115,155 @@ sub _lock_release { close $lockfh or die "close failed: $!\n"; } -sub add_val { +sub add_val ($$$) { my ($doc, $col, $num) = @_; $num = Search::Xapian::sortable_serialise($num); $doc->add_value($col, $num); } +sub add_values ($$$) { + my ($smsg, $bytes, $num) = @_; + + my $ts = $smsg->ts; + my $doc = $smsg->{doc}; + add_val($doc, &PublicInbox::Search::TS, $ts); + + defined($num) and add_val($doc, &PublicInbox::Search::NUM, $num); + + defined($bytes) and add_val($doc, &PublicInbox::Search::BYTES, $bytes); + + add_val($doc, &PublicInbox::Search::LINES, + $smsg->{mime}->body_raw =~ tr!\n!\n!); + + my $yyyymmdd = strftime('%Y%m%d', gmtime($ts)); + add_val($doc, PublicInbox::Search::YYYYMMDD, $yyyymmdd); +} + +sub index_users ($$) { + my ($tg, $smsg) = @_; + + my $from = $smsg->from; + my $to = $smsg->to; + my $cc = $smsg->cc; + + $tg->index_text($from, 1, 'A'); # A - author + $tg->increase_termpos; + $tg->index_text($to, 1, 'XTO') if $to ne ''; + $tg->increase_termpos; + $tg->index_text($cc, 1, 'XCC') if $cc ne ''; + $tg->increase_termpos; +} + +sub index_text_inc ($$$) { + my ($tg, $text, $pfx) = @_; + $tg->index_text($text, 1, $pfx); + $tg->increase_termpos; +} + +sub index_old_diff_fn { + my ($tg, $seen, $fa, $fb) = @_; + + # no renames or space support for traditional diffs, + # find the number of leading common paths to strip: + my @fa = split('/', $fa); + my @fb = split('/', $fb); + while (scalar(@fa) && scalar(@fb)) { + $fa = join('/', @fa); + $fb = join('/', @fb); + if ($fa eq $fb) { + index_text_inc($tg, $fa,'XDFN') unless $seen->{$fa}++; + return 1; + } + shift @fa; + shift @fb; + } + 0; +} + +sub index_diff ($$$) { + my ($tg, $lines, $doc) = @_; + my %seen; + my $in_diff; + foreach (@$lines) { + if ($in_diff && s/^ //) { # diff context + index_text_inc($tg, $_, 'XDFCTX'); + } elsif (/^-- $/) { # email signature begins + $in_diff = undef; + } elsif (m!^diff --git ("?a/.+) ("?b/.+)\z!) { + my ($fa, $fb) = ($1, $2); + my $fn = (split('/', git_unquote($fa), 2))[1]; + index_text_inc($tg, $fn, 'XDFN') unless $seen{$fn}++; + $fn = (split('/', git_unquote($fb), 2))[1]; + index_text_inc($tg, $fn, 'XDFN') unless $seen{$fn}++; + $in_diff = 1; + # traditional diff: + } elsif (m/^diff -(.+) (\S+) (\S+)$/) { + my ($opt, $fa, $fb) = ($1, $2, $3); + # only support unified: + next unless $opt =~ /[uU]/; + $in_diff = index_old_diff_fn($tg, \%seen, $fa, $fb); + } elsif (m!^--- ("?a/.+)!) { + my $fn = (split('/', git_unquote($1), 2))[1]; + index_text_inc($tg, $fn, 'XDFN') unless $seen{$fn}++; + $in_diff = 1; + } elsif (m!^\+\+\+ ("?b/.+)!) { + my $fn = (split('/', git_unquote($1), 2))[1]; + index_text_inc($tg, $fn, 'XDFN') unless $seen{$fn}++; + $in_diff = 1; + } elsif (/^--- (\S+)/) { + $in_diff = $1; + } elsif (defined $in_diff && /^\+\+\+ (\S+)/) { + $in_diff = index_old_diff_fn($tg, \%seen, $in_diff, $1); + } elsif ($in_diff && s/^\+//) { # diff added + index_text_inc($tg, $_, 'XDFB'); + } elsif ($in_diff && s/^-//) { # diff removed + index_text_inc($tg, $_, 'XDFA'); + } elsif (m!^index ([a-f0-9]+)\.\.([a-f0-9]+)!) { + my ($ba, $bb) = ($1, $2); + index_git_blob_id($doc, 'XDFPRE', $ba); + index_git_blob_id($doc, 'XDFPOST', $bb); + $in_diff = 1; + } elsif (/^@@ (?:\S+) (?:\S+) @@\s*$/) { + # traditional diff w/o -p + } elsif (/^@@ (?:\S+) (?:\S+) @@\s*(\S+.*)$/) { + # hunk header context + index_text_inc($tg, $1, 'XDFHH'); + # ignore the following lines: + } elsif (/^(?:dis)similarity index/) { + } elsif (/^(?:old|new) mode/) { + } elsif (/^(?:deleted|new) file mode/) { + } elsif (/^(?:copy|rename) (?:from|to) /) { + } elsif (/^(?:dis)?similarity index /) { + } elsif (/^\\ No newline at end of file/) { + } elsif (/^Binary files .* differ/) { + } elsif ($_ eq '') { + $in_diff = undef; + } else { + warn "non-diff line: $_\n" if DEBUG && $_ ne ''; + $in_diff = undef; + } + } +} + +sub index_body ($$$) { + my ($tg, $lines, $doc) = @_; + my $txt = join("\n", @$lines); + $tg->index_text($txt, !!$doc, $doc ? 'XNQ' : 'XQUOT'); + $tg->increase_termpos; + # does it look like a diff? + if ($doc && $txt =~ /^(?:diff|---|\+\+\+) /ms) { + $txt = undef; + index_diff($tg, $lines, $doc); + } + @$lines = (); +} + sub add_message { my ($self, $mime, $bytes, $num, $blob) = @_; # mime = Email::MIME object my $db = $self->{xdb}; my ($doc_id, $old_tid); my $mid = mid_clean(mid_mime($mime)); - my $ct_msg = $mime->header('Content-Type') || 'text/plain'; eval { die 'Message-ID too long' if length($mid) > MAX_MID_SIZE; @@ -115,73 +271,70 @@ sub add_message { if ($smsg) { # convert a ghost to a regular message # it will also clobber any existing regular message - $doc_id = $smsg->doc_id; + $doc_id = $smsg->{doc_id}; $old_tid = $smsg->thread_id; } $smsg = PublicInbox::SearchMsg->new($mime); my $doc = $smsg->{doc}; - $doc->add_term(xpfx('mid') . $mid); + $doc->add_term('Q' . $mid); my $subj = $smsg->subject; if ($subj ne '') { my $path = $self->subject_path($subj); - $doc->add_term(xpfx('path') . id_compress($path)); + $doc->add_term('XPATH' . id_compress($path)); } - add_val($doc, &PublicInbox::Search::TS, $smsg->ts); - - defined($num) and - add_val($doc, &PublicInbox::Search::NUM, $num); - - defined($bytes) and - add_val($doc, &PublicInbox::Search::BYTES, $bytes); - - add_val($doc, &PublicInbox::Search::LINES, - $mime->body_raw =~ tr!\n!\n!); + add_values($smsg, $bytes, $num); my $tg = $self->term_generator; $tg->set_document($doc); $tg->index_text($subj, 1, 'S') if $subj; $tg->increase_termpos; - $tg->index_text($subj) if $subj; - $tg->increase_termpos; - $tg->index_text($smsg->from); - $tg->increase_termpos; + index_users($tg, $smsg); msg_iter($mime, sub { my ($part, $depth, @idx) = @{$_[0]}; - my $ct = $part->content_type || $ct_msg; + my $ct = $part->content_type || 'text/plain'; + my $fn = $part->filename; + if (defined $fn && $fn ne '') { + $tg->index_text($fn, 1, 'XFN'); + } - # account for filter bugs... - $ct =~ m!\btext/plain\b!i or return; + return if $ct =~ m!\btext/x?html\b!i; + + my $s = eval { $part->body_str }; + if ($@) { + if ($ct =~ m!\btext/plain\b!i) { + # Try to assume UTF-8 because Alpine + # seems to do wacky things and set + # charset=X-UNKNOWN + $part->charset_set('UTF-8'); + $s = eval { $part->body_str }; + $s = $part->body if $@; + } + } + defined $s or return; my (@orig, @quot); my $body = $part->body; - $part->body_set(''); my @lines = split(/\n/, $body); while (defined(my $l = shift @lines)) { - if ($l =~ /^\s*>/) { + if ($l =~ /^>/) { + index_body($tg, \@orig, $doc) if @orig; push @quot, $l; } else { + index_body($tg, \@quot, 0) if @quot; push @orig, $l; } } - if (@quot) { - $tg->index_text(join("\n", @quot), 0); - @quot = (); - $tg->increase_termpos; - } - if (@orig) { - $tg->index_text(join("\n", @orig)); - @orig = (); - $tg->increase_termpos; - } + index_body($tg, \@quot, 0) if @quot; + index_body($tg, \@orig, $doc) if @orig; }); link_message($self, $smsg, $old_tid); - $tg->index_text($mid, 1); + $tg->index_text($mid, 1, 'XMID'); $doc->set_data($smsg->to_doc_data($blob)); if (my $altid = $self->{-altid}) { @@ -213,8 +366,12 @@ sub remove_message { $mid = mid_clean($mid); eval { - $doc_id = $self->find_unique_doc_id('mid', $mid); - $db->delete_document($doc_id) if defined $doc_id; + $doc_id = $self->find_unique_doc_id('Q' . $mid); + if (defined $doc_id) { + $db->delete_document($doc_id); + } else { + warn "cannot remove non-existent <$mid>\n"; + } }; if ($@) { @@ -252,15 +409,14 @@ sub link_message { my ($self, $smsg, $old_tid) = @_; my $doc = $smsg->{doc}; my $mid = $smsg->mid; - my $mime = $smsg->mime; + my $mime = $smsg->{mime}; my $hdr = $mime->header_obj; - my $refs = $hdr->header_raw('References'); - my @refs = $refs ? ($refs =~ /<([^>]+)>/g) : (); - if (my $irt = $hdr->header_raw('In-Reply-To')) { - # last References should be $irt - # we will de-dupe later - push @refs, mid_clean($irt); - } + + # last References should be IRT, but some mail clients do things + # out of order, so trust IRT over References iff IRT exists + my @refs = ($hdr->header_raw('References'), + $hdr->header_raw('In-Reply-To')); + @refs = ((join(' ', @refs)) =~ /<([^>]+)>/g); my $tid; if (@refs) { @@ -278,6 +434,7 @@ sub link_message { push @refs, $ref; } } + if (@refs) { $smsg->{references} = '<'.join('> <', @refs).'>'; @@ -293,9 +450,9 @@ sub link_message { merge_threads($self, $tid, $ptid); } } else { - $tid = $self->next_thread_id; + $tid = defined $old_tid ? $old_tid : $self->next_thread_id; } - $doc->add_term(xpfx('thread') . $tid); + $doc->add_term('G' . $tid); } sub index_blob { @@ -303,6 +460,16 @@ sub index_blob { $self->add_message($mime, $bytes, $num, $blob); } +sub index_git_blob_id { + my ($doc, $pfx, $objid) = @_; + + my $len = length($objid); + for (my $len = length($objid); $len >= 7; ) { + $doc->add_term($pfx.$objid); + $objid = substr($objid, 0, --$len); + } +} + sub unindex_blob { my ($self, $mime) = @_; my $mid = eval { mid_clean(mid_mime($mime)) }; @@ -311,7 +478,12 @@ sub unindex_blob { sub index_mm { my ($self, $mime) = @_; - $self->{mm}->mid_insert(mid_clean(mid_mime($mime))); + my $mid = mid_clean(mid_mime($mime)); + my $mm = $self->{mm}; + my $num = $mm->mid_insert($mid); + + # fallback to num_for since filters like RubyLang set the number + defined $num ? $num : $mm->num_for($mid); } sub unindex_mm { @@ -349,7 +521,7 @@ sub do_cat_mail { my $str = $git->cat_file($blob, $sizeref); # fixup bugs from import: $$str =~ s/\A[\r\n]*From [^\r\n]*\r?\n//s; - Email::MIME->new($str); + PublicInbox::MIME->new($str); }; $@ ? undef : $mime; } @@ -359,6 +531,15 @@ sub index_sync { with_umask($self, sub { $self->_index_sync($opts) }); } +sub batch_adjust ($$$$) { + my ($max, $bytes, $batch_cb, $latest) = @_; + $$max -= $bytes; + if ($$max <= 0) { + $$max = BATCH_BYTES; + $batch_cb->($latest, 1); + } +} + sub rlog { my ($self, $log, $add_cb, $del_cb, $batch_cb) = @_; my $hex = '[a-f0-9]'; @@ -368,23 +549,21 @@ sub rlog { my $git = $self->{git}; my $latest; my $bytes; - my $max = $self->{batch_size}; # may be undef + my $max = BATCH_BYTES; local $/ = "\n"; my $line; while (defined($line = <$log>)) { if ($line =~ /$addmsg/o) { my $blob = $1; my $mime = do_cat_mail($git, $blob, \$bytes) or next; + batch_adjust(\$max, $bytes, $batch_cb, $latest); $add_cb->($self, $mime, $bytes, $blob); } elsif ($line =~ /$delmsg/o) { my $blob = $1; - my $mime = do_cat_mail($git, $blob) or next; + my $mime = do_cat_mail($git, $blob, \$bytes) or next; + batch_adjust(\$max, $bytes, $batch_cb, $latest); $del_cb->($self, $mime); } elsif ($line =~ /^commit ($h40)/o) { - if (defined $max && --$max <= 0) { - $max = $self->{batch_size}; - $batch_cb->($latest, 1); - } $latest = $1; } } @@ -505,9 +684,9 @@ sub create_ghost { my $tid = $self->next_thread_id; my $doc = Search::Xapian::Document->new; - $doc->add_term(xpfx('mid') . $mid); - $doc->add_term(xpfx('thread') . $tid); - $doc->add_term(xpfx('type') . 'ghost'); + $doc->add_term('Q' . $mid); + $doc->add_term('G' . $tid); + $doc->add_term('T' . 'ghost'); my $smsg = PublicInbox::SearchMsg->wrap($doc, $mid); $self->{xdb}->add_document($doc); @@ -518,15 +697,14 @@ sub create_ghost { sub merge_threads { my ($self, $winner_tid, $loser_tid) = @_; return if $winner_tid == $loser_tid; - my ($head, $tail) = $self->find_doc_ids('thread', $loser_tid); - my $thread_pfx = xpfx('thread'); + my ($head, $tail) = $self->find_doc_ids('G' . $loser_tid); my $db = $self->{xdb}; for (; $head != $tail; $head->inc) { my $docid = $head->get_docid; my $doc = $db->get_document($docid); - $doc->remove_term($thread_pfx . $loser_tid); - $doc->add_term($thread_pfx . $winner_tid); + $doc->remove_term('G' . $loser_tid); + $doc->add_term('G' . $winner_tid); $db->replace_document($docid, $doc); } } @@ -583,7 +761,7 @@ sub with_umask { my $rv = eval { $cb->() }; my $err = $@; umask $old; - die $err if $@; + die $err if $err; $rv; }