nntp: make XOVER, XHDR, OVER, HDR and NEWNEWS faster

While SQLite is faster than Xapian for some queries we
use, it sucks at handling OFFSET.  Fortunately, we do
not need offsets when retrieving sorted results and
can bake it into the query.

For inbox.comp.version-control.git (v1 Xapian),
XOVER and XHDR are over 20x faster.

rename+rewrite test using Benchmark module

There'll be more performance-related tests in the future.

t/thread-all.t: modernize test to support modern inboxes

We'll be adding more tests in the same vein as this
to improve NNTP performance.

over: speedup get_thread by avoiding JOIN

JOIN operations on SQLite can be disasterously slow.
This reduces per-message pages with the thread overview
at the bottom of those pages from over 800ms to ~60ms.
In comparison, the v1 code took around 70-80ms using
Xapian on my machine.

www: rework query responses to avoid COUNT in SQLite

In many cases, we do not care about the total number of
messages.  It's a rather expensive operation in SQLite
(Xapian only provides an estimate).

For LKML, this brings top-level /$INBOX/ loading time from
~375ms to around 60ms on my system.  Days ago, this operation
was taking 800-900ms(!) for me before introducing the SQLite
overview DB.

t/over: test empty Subject: line matching

We need to ensure we don't match NULL 'sid' columns in the
`over' table.

v2writable: simplify barrier vs checkpoints

searchidx_checkpoint was too convoluted and confusing.
Since barrier is mostly the same thing; use that instead
and add an fsync option for the overview DB.

replace Xapian skeleton with SQLite overview DB

This ought to provide better performance and scalability
which is less dependent on inbox size.  Xapian does not
seem optimized for some queries used by the WWW homepage,
Atom feeds, XOVER and NEWNEWS NNTP commands.

This can actually make Xapian optional for NNTP usage,
and allow more functionality to work without Xapian
installed.

Indexing performance was extremely bad at first, but
DBI::Profile helped me optimize away problematic queries.

search: reduce columns stored in Xapian

We can store :bytes and :lines in doc_data since we never
sort or search by them.  We don't have much use for the Date:
stamp at the moment, either.

scripts/import_vger_from_mbox: set address properly

For objects like Inbox; the '-' prefixed hash keys are
probably intended for auto-generated/hidden parameters.

truncate Message-IDs and References consistently

We need to stop ghost messages from generating longer
Message-IDs than Xapian can handle with terms.

v2writable: fix parallel termination

I was too aggressively disabling parallelization to speed up
the test suite and broke this :x  Re-enable parallelization
for the v2reindex test so we can catch it later.

v2: one file, really

We need to ensure there is only one file in the top-level tree
at any commit so the "add; remove; add;" sequence on the same
message is detected properly.

Otherwise, git will not detect the second "add" unless
a second message is added to history.

Deletes are now stored in "d" (and not "D" or "_/D") at the
top-level, now.  There's no need to have a "_" to reduce churn
as "m" and "d" should never co-exist.  It's now lowercased to
make it easier-to-distinguish from "D" in git-log output.

searchidx: correct warning for over-vivification

We will vivify multiple ghosts if a message has multiple
Message-IDs.

v2: respect core.sharedRepository in git configs

Ensure -convert and -compact do not make repositories
unreadable on live servers.

t/v2writable: use simplify permissions reading

We have Git::qx nowadays.

search: move permissions handling to InboxWritable

We'll be making sure V2Writable uses this.

convert: avoid redundant "done\n" statement for fast-import

This bug was hidden due to timing problems with eatmydata or
running with tmpfs for TMPDIR.

msgtime: parse 3-digit years properly

Some folks had bad mail clients which generated 3-digit years
around Y2K...

feed: optimize query for feeds, too

This is a smaller improvement than the landing /$INBOX/ page
because full message bodies are shown; but still saves around
100ms for my system with LKML.

view: drop load_results

It's no longer necessary to have this since load_expand
now populates $smsg->mid with the "preferred" Message-ID.
This saves around 10ms on the homepage for me.

view: speed up homepage loading time with date clamp

This saves over 400ms on my system with the full LKML
with over 2.8 million messages.

v2writable: go backwards through alternate Message-IDs

This is consistent with how we internally generate new
Message-IDs to break conflicts and allows ->reindex to
succeed while walking backwards through history

wwwstream: flesh out clone instructions for v2

Relying solely on git for v2 repos is probably not
so useful, so add pointers to public-inbox-init/index
commands.

v2writable: convert some fatal reindex errors to warnings

By supporting purge and allowing users to delete git partitions,
we can open up ourselves to gaps and un-reindexible data.  Let
that be.

v2writable: allow gaps in git partitions

Somebody may only care about the most recent history,
so allow -init and -index to operate quietly on missing
partitions.

search: warn on reopens and die on total failure

-watch on a busy/giant Maildir caused too many Xapian
errors while attempting to browse.

mda: support v2 inboxes

I mainly focus on -watch for mirroring busy mailing lists, but
using -mda should remain an option.

public-inbox-compact: new tool for driving xapian-compact

Having multiple Xapian partitions is mostly pointless after
the initial import.  We can compact all the partitions into
one while keeping the skeleton separate.

v2writable: initializing an existing inbox is idempotent

And we do not want to start making confused repos if somebody
leaves out "-V2" the second time around.

import: run_die supports redirects as spawn does

We'll be using it in more future tests and scripts.

search: retry_reopen on first_smsg_by_mid

This was causing errors while attempting to load messages via
the WWW interface while mass-importing LKML.  While we're at it,
remove unnecessary eval from lookup_article.

view: get rid of some unnecessary imports

We no longer need some of these old subroutines which
assumed a single Message-ID for each message.

www: cleanup expensive fallback for legacy URLs

Back in the day, we compressed long Message-IDs to SHA-1
hexdigests for the URL.  This now redirects to a 301 in
the hopes we can remove these checks some day to reduce
overhead.

mbox: avoid extracting Message-ID for linkification

We can avoid a small amount of overhead and use the "preferred"
Message-ID based on what is in the SearchMsg object.

v2writable: cleanup: get rid of unused fields

The layout of this structure ended up being a bit different
and the read-only access is handled through the ::Inbox class,
instead.

search: move find_doc_ids to searchidx

We do not need this subroutine for read-only use in Search.pm

search: get rid of most lookup_* subroutines

Too many similar functions doing the same basic thing was
redundant and misleading, especially since Message-ID is
no longer treated as a truly unique identifier.

For displaying threads in the HTML, this makes it clear
that we favor the primary Message-ID mapped to an NNTP
article number if a message cannot be found.

search: cleanup uniqueness checking

The only Xapian term which should be unique is the NNTP article
number; so we no longer need find_unique_doc_id.

v2writable: support purging messages from git entirely

Purging existing messages is fairly straightforward since we can
take advantage of Xapian and lookup the git object_id with it.

Unfortunately, purging an already "removed" message (which is
no longer in Xapian) is not as easy and we'll need to expose
->purge_oids to purge by the git object_id (currently SHA-1).

Furthermore, we expire reflogs and prune in hopes a dumb HTTP
client won't get the object.

public-inbox-convert: tool for converting old to new inboxes

This should make it easier to let users perform comparisons and
migrate to v2 if needed.

searchmsg: document why we store To: and Cc: for NNTP

Otherwise I would forget and be tempted to remove them.

www: fix attachment downloads for conflicted Message-IDs

By using the "primary" Message-ID in WwwAttach, we can avoid
conflicts in the links we use for downloading attachments.

lookup by Message-ID favors the "primary" one

The Message-ID mapped to an NNTP article number is stronger,
so we will favor that for attachment lookups.

v2writable: append, instead of prepending generated Message-ID

The original Message-ID is still the most important when
discussing with other recipients who do not rely on a message
flowing through public-inbox.  So whatever Message-ID we use
to deduplicate internally will be secondary and less important.

All of our front-end v2 code is order-independent, so we won't
let the message count against us, that way.

www: remove unnecessary ghost checks

We do not need to care about ghosts at multiple call sites; they
cannot have a {blob} field and we've stored the blob field in
Xapian since SCHEMA_VERSION=13.

www: support cloning individual v2 git partitions

This will require multiple client invocations, but should reduce
load on the server and make it easier for readers to only clone
the latest data.

Unfortunately, supporting a cloneurl file for externally-hosted
repos will be more difficult as we cannot easily know if the
clones use v1 or v2 repositories, or how many git partitions
they have.

githttpbackend: avoid infinite loop on generic PSGI servers

We must detect EOF when reading a POST body with standard PSGI servers.
This does not affect deployments using the standard public-inbox-httpd;
but most smaller inboxes should be able to get away using a generic
PSGI server.

http: fix modification of read-only value

This fails in the rare case we get a partial send() on "\r\n"
when writing chunked HTTP responses out.

view: depend on SearchMsg for Message-ID

Since we need to handle messages with multiple and duplicate
Message-ID headers, our thread skeleton display must account
for that.

Since we have a "preferred" Message-ID in case of conflicts,
use it as the UUID in an Atom feed so readers do not get
confused by conflicts.

searchview: remove unnecessary imports from MID module

We do not need many of these, anymore.

www: get rid of unnecessary 'inbox' name reference

We use the actual Inbox object everywhere else and don't
need the name of the inbox separated from the object.

v2writable: warn on unseen deleted files

It would be a bug to have deleted files marked but not
seen in our histories.

searchidx: warn about vivifying multiple ghosts

This should help us detect bugs sooner in case we have
space waste problems.

view: permalink (per-message) view shows multiple messages

This needs tests and further refinement, but current tests pass.

feed: fix new.html for v2

I forget this endpoint is still accessible (even if not linked).
This also simplifies new.html all around and removes some unused
clutter from the old days while we're at it.

t/psgi_v2: minimal test for Atom feed and t.mbox.gz

Some test coverage is better than none, here.

search: reopen DB if each_smsg_by_mid fails

This gives more-up-to-date data in case and allows us
to avoid reopening in more places ourselves.

www: $MESSAGE_ID/raw endpoint supports "duplicates"

Since v2 supports duplicate messages, we need to support
looking up different messages with the same Message-Id.
Fortunately, our "raw" endpoint has always been mboxrd,
so users won't need to change their parsing tools.

import: consolidate mid prepend logic, here

This also quiets down warnings from -watch when spam training
happens on messages without Message-Id.

feed: $INBOX/new.atom endpoint supports v2 inboxes

We can no longer rely on tree name lookups for v2.  This also
optimizes v1 by relying on git blob object_id lookups while
avoiding process spawning overhead for "git log".

v2writable: DEBUG_DIFF respects $TMPDIR

The File::Temp API is a bit tricky and needs TMPDIR explicitly
enabled if a template is given.

v2writable: clarify header cleanups

We want to make it clear to the code and DEBUG_DIFF users
that we do not introduce messages with unsuitable headers
into public archives.

v2writable: add NNTP article number regeneration support

Allow best-effort regeneration of NNTP article numbers from
cloned git repositories in addition to indexing Xapian Article
numbers will not remain consistent when we add purge support,
though.

t/altid.t: extra tests for mid_set

I'll be relying on some of this behavior for regenerating NNTP
article numbers off fresh clones.

v2writable: support reindexing Xapian

This still requires a msgmap.sqlite3 file to exist, but
it allows us to tweak Xapian indexing rules and reindex
the Xapian database online while -watch is running.

fix syntax warnings

I keep forgetting to run "make syntax"

msgmap: add tmp_clone to create an anonymous copy

This will be used to keep track of Message-ID <-> NNTP Article
numbers to prevent article number reuse when reindexing.

use both Date: and Received: times

We want to rely on Date: to sort messages within individual
threads since it keeps messages from git-send-email(1) sorted.
However, since developers occasionally have the clock set
wrong on their machines, sort overall messages by the newest
date in a Received: header so the landing page isn't forever
polluted by messages from the future.

This also gives us determinism for commit times in most cases,
as we'll used the Received: timestamp there, as well.

InboxWritable: add mbox/maildir parsing + import logic

This will make it easier to as well as supporting future
Filter API users.  It allows simplifying our ad-hoc
import_vger_from_mbox script.

import: discard all the same headers as MDA

Reduce the places where we have duplicate logic for discarding
unwanted headers.

introduce InboxWritable class

This code will be shared with future mass-import tools.

content_id: do not take Message-Id into account

If we need to use content_id, we've already lost hope
in relying on Message-Id as a differentiator.  This
prevents duplicates from showing up repeatedly with
-watch when Message-Ids are reused and we generate
new Message-Ids to disambiguate.

v2writable: remove "resent" message for duplicate Message-IDs

public-inbox-watch gets restarted on reboots and whatnot, so
it could get pointlessly noisy.  This message was only useful
during initial development and imports.

v2writable: add DEBUG_DIFF env support

This can help us track down some differences during import,
if needed.

scripts/import_vger_from_mbox: filter out same headers as MDA

Perhaps we should filter these headers out in Import

v2writable: allow disabling parallelization

While parallel processes improves import speed for initial
imports; they are probably not necessary for daily mail imports
via WatchMaildir and certainly not for public-inbox-init.  Save
some memory for daily use and even helps improve readability of
some subroutines by showing which methods they call remotely.

searchidxpart: s/barrier/remote_barrier/

Be consistent with our "remote_" prefix for other IPC subs

watchmaildir: support v2 repositories

Unfortunately this gives up some minor performance tweaks we
made to avoid reforking import processes.

v2writable: ensure ->done is idempotent

This matches Import::done behavior

t/watch_maildir: note the reason for FIFO creation

I had to dig through commit history for this and we should
better document our tests (along with everything else).

Lock: new base class for writable lockers

This reduces code duplication needed for locking and
and hopefully makes things easier to understand.

index: s/GIT_DIR/REPO_DIR/

No functional changes, yet, but this makes future changes
easier-to-read.

import: enable locking under v2

Instead of using ssoma-based locking, enable locking via Import
for now.

v2writable: test for idempotent removals

This will make reindexing easier.

import: switch to URL-safe Base64 for Message-IDs

Hexdigests are too long and shorter Message-IDs are easier
to deal with.

import: force Message-ID generation for v1 here

This allows us to share code for generating Message-IDs
between v1 and v2 repos.

For v1, this introduces a slight incompatibility in message
removal iff the original message lacked a Message-ID AND
the training request came from a message which did not
pass through the public-inbox:

The workaround for this would be to reuse the bad message from
the archive itself.

watchmaildir: use content_digest to generate Message-Id

This can probably be moved to Import for code reuse.

mid: mid_mime uses v2-compatible mids function

This allows us to be more consistent in dealing with completely
empty Message-Ids.

import: implement barrier operation for v1 repos

This will allow WatchMaildir to use ->barrier operations instead
of reaching inside for nchg.  This also ensures dumb HTTP
clients can see changes to V2 repos immediately.

import: (v2): write deletes to a separate '_' subdirectory

In the future, we may store "purged" content IDs or other
uncommon stuff under "_/" of the git tree.  This keeps the
top-level tree small and more amenable to deltafication.
This helps the the common case where "m" is most commonly
changed file at the top level.

Also, use 'D' instead of 'd' since it matches git's '--raw'
output format.

import: (v2) delete writes the blob into history in subdir

This makes it easier to audit deletes with "git log -p" and
prevents an unstable specification of "content_id" from being
stored in history.

This should be cost-free if done in the same partition (and even
cheaper than before as it introduces no new blobs).  It does
have a higher cost across partitions, but is probably irrelevant
given the typical ham:spam ratio.

skeleton: barrier init requires a lock

Writing to the main skeleton pipe requires a lock since it's
shared with partition processes.

v2writable: implement remove correctly

We need to hide removals from anybody hitting the search engine.

search: allow ->reopen to be chainable

Makes life a little easier for V2Writable...

searchidx: do not delete documents while iterating

Followup-to: ebb59815035b42c2
  ("searchidx: do not modify Xapian DB while iterating")

v2writable: remove unnecessary idx_init call

We no longer need it with ->barrier working

use string ref for Email::Simple->new

Email::Simple is slightly faster this way, and Email::MIME
and PublicInbox::MIME both wrap that.

v2writable: support "barrier" operation to avoid reforking

Stopping and starting a bunch of processes to look up duplicates
or removals is inefficient.  Take advantage of checkpointing
in "git fast-import" and transactions in Xapian and SQLite.

content_id: use Sender header if From is not available

We will be using Sender: in more places if the From: header
is not available, this is one of them.

Followup-to: ("import: fall back to Sender for extracting name and email")