searchidx: don't index Base-85 w/ CRLF endings

I encountered a false positive search result from a CRLF message
with a Base-85 patch in it.  It turns out our Base-85 filtering
code didn't account for the possibility of "\r" showing up in
patch messages, so just ignore all trailing spaces (not just
horizontal spaces) in index_diff().

While we're at it, exclude horizontal whitespace and CR
consistently from Base-85-looking quoted text in
index_body_text(), too, since I'm sure there's messages with
CRCRLF in the wild, too...

cfgwr: fix non-libgit2 case

libgit2 isn't installed on all my test machines, and the
addition of libgit2 support was careless in that it failed to
test the non-libgit2 case thoroughly :x

Fixes: a8073f6c (lg2: use cfgwr_commit to write to configs using libgit2, 2025-02-15)

lg2: use cfgwr_commit to write to configs using libgit2

libgit2 allows us to avoid process spawning overhead when
writing to the config file.  While the performance difference is
unlikely to matter in real-world use, it should improve
maintainability of tests by allowing us to write tests with
`public-inbox-init' with a smaller performance penalty (as
opposed to using `PublicInbox::IO::write_file' to setup
configs).

rename Gcf2 -> Lg2 for general libgit2 use

We'll be exploring libgit2 for writing (and possibly reading) config
files, so the `gcf2' (git-cat-file-2) name isn't appropriate
anymore for the package name.  We'll still keep `gcf2_' for
subroutine names related to git-cat-file-like behavior.

cfgwrite: new module to batch commit writes

Hoisting git config writing code into a separate module will
make it easier to use libgit2 to avoid process spawning overhead
in a future change.

t/watch_v1_v2_mix_no_modify: load PublicInbox::Config

For testing with TEST_RUN_MODE=0 (which spawns new processes
instead of reusing them), we can't rely on packages being loaded
by subprocesses influencing the main Perl process.  Thus we must
load PublicInbox::Config explicitly to prevent failures with
this run mode.

test_common: key2sub: detect syntax errors early

Instead of attempting to use an `undef' $sub as a coderef;
detect compile errors early and die immediately if `eval'
raises an exception.

import: clobber $? if global init.defaultBranch fails

We don't want $? influencing further error checking downstream,
such as thw _wq_done_wait call in public-inbox-clone when
git-config(1) invocations which set $?=0 are replaced with
in-process libgit2 config function calls.

edit: use autodie and favor flush over autoflush

Using a single ->flush reduces iops for the (default) non-raw
case and autodie for `open' makes error messages more
consistent.

favor run_wait() over CORE::system()

run_wait() can use vfork(2) which saves memory in large
processes, such as public-inbox-extindex when dealing with giant
messages.  While vfork is unlikely to matter for real-world uses
of public-inbox-edit, PublicInbox::Spawn is a sunk cost treewide
our `make check-run' test target avoids spawning new Perl
processes for most things in script/*, so there can be a small
savings for testing.

imap_searchqp: avoid occasional P::RD hint spew

It turns out Inline::C::Parser::RecDescent increments $::RD_HINT
when Inline::C rebuilds are necessary, thus causing verbose log
spew on bogus IMAP search queries in our own use of
Parse::RecDescent.  So, local-ize $::RD_HINT as we do with other
$::RD_* vars to avoid Inline::C influencing our IMAP query
parsing.

Triggering the increment of $::RD_HINT via
Inline::C::Parser::RecDescent may be achieved by forcing an
Inline::C rebuild, such as clearing the contents of
~/.cache/public-inbox/inline-c/* or
$ENV{PERL_INLINE_DIRECTORY}/* (but leaving one of those
top-level directories to trigger Inline::C rebuilds.  This bug
mainly manifested in t/imap_searchqp.t under the `make
check-run' test target which reuses existing processes to speed
up tests, though it could manifest in real-world -imapd (and
-netd) usage if the process spawning the daemon built Inline::C
code.

daemon: make xap_helper socket non-blocking

A non-blocking socket for public-facing searches is ideal on
overloaded servers which receive more searches than it can
handle in a short time span.  A non-blocking socket here
prevents a sendmsg(2) call from blocking the main event loop
and ensures non-search requests can still be processed even
if all xap_helper subprocesses are overwhelmed.

$search_xh_pid is hoisted out to TestCommon for use with the new
slow-xh-search test and renamed $find_xh_pid to avoid confusion
with Xapian search functionality.  We'll also drop a redundant
call to find the xap_helper PID in psgi_v2.t while transitioning
to $find_xh_pid.

www: mbox: break out of loop on exceptions

In case async_mset fails due to resource limitations, ensure we
stop trying to make expensive search queries ASAP.

search: async_mset: always run callback on exceptions

To produce consistent error behavior, ensure we always run
the user-supplied callback on exceptions when using in-process
Xapian (as opposed to the external xap_helper process).

git_http_backend: input_prepare: die on unrecoverable errors

We shouldn't be guarding against errors at this level to return
500 errors, but rather we can rely on existing eval wrappers in
the stack (e.g. Plack::Util::run_app and Qspawn->parse_hdr_done)
to capture errors and return the HTTP 500 status.

lei_mirror: use write_file to append configs

It saves us a few lines of code and reduces unnecessary
error checking since the close done by write_file aleady
does autodie for error checking.

msgmap: use v5.12

No unicode_string dependencies, here, so we can use v5.12 and
perhaps to speed up loading one day if everything drops `strict'
in favor of v5.12 (or higher).

init: reduce git-config execve for idempotent cases

This probably saves us a few cycles in some cases since spawning
new processes is expensive.

multi_git: remove redundant ops

read_all already returns an array in array context so the
`split' op is unnecessary, and we don't need to use
`join("", ...)' on arrays that are destined for `print'
or `say'.

devel/sysdefs-list: explain why we don't autodie, here

Some distros split out core modules like autodie, and
sysdefs-list has higher portability requirements than the rest
of our code since it's used for uncommon platforms.

config: handle limiter `max' knob in ->setup_limiter

Handling all config knobs in the same sub is more logical and
reduces the size of the frequently-loaded PublicInbox::Config
package.

qspawn: drop redundant check against limiter->{max}

We only need to guard against excessive parallelism on entry
in one place during Qspawn->start.  Redundant guards are
confusing and make bugs harder-to-spot.

viewvcs: -codeblob limiter w/ depth for solver

By adding the `publicinboxlimiter.<name>.depth' parameter for
all limiters, we can have queue overflow detection and reject
requests with HTTP 503 error codes for all limiter uses, not
just the custom queue in ViewVCS as before.  Then we can just
use a normal limiter in ViewVCS and get rid of the old custom
queue.

qspawn: use limiter->new default

No need to hardcode `32' here since PublicInbox::Limiter already
uses that value already (and includes a helpful comment about
using the same value as git-daemon).

daemon: check connections before solving codeblobs

The /$MSGID/s/ codeblob reconstruction endpoint is extremely
expensive and one of the few which do a large amount of upfront
processing before being able to write to an HTTP client and
detect if they're still alive (unlike other expensive
endpoints).

For TCP connections, use the TCP_INFO via getsockopt(2) if
supported or attempt to use poll(2) + the FIONREAD ioctl(2) to
check the connection before possibly invoking
git-(apply|ls-files|update-index) dozens or even hundreds of
times to reconstruct a blob.

git_http_backend: fix 32 default connection limit

Using any configurable limiter actually defaults to `1', which
isn't intended for `-httpbackend'.  So add a $max_default
parameter to ensure we can set a per-limiter default value for
default limiters such as `-httpbackend'.

Fixes: 0a083241 (git_http_backend: use default limiter from Qspawn, 2025-01-28)

syscall: `use bytes' throughout

All *nix syscalls operate on the byte-level with no knowledge of
encodings, so ensure all `substr' and `length' calculations use
the bytes(3perl) pragma.

Revert "daemon: check connections WIP"

Accidentally pushed out a WIP change since I couldn't access my
normal VM for pushing :x
This reverts commit 10394e508575fd7cc78d0255d39b04c833efcdbb.

git_http_backend: use default limiter from Qspawn

There's no reason for us to have another default limiter object
when the one in Qspawn already exists.

www: configurable "-httpbackend" named limiter

The default limiter being hard-coded to 32 is excessive for
smaller systems.  With dozens or hundreds of inboxes,
configuring all inboxes to point to a user-defined limiter
is tedious, as well.  So give WWW admins the opportunity
to configure the limiter for all git-http-backend(1) processes
with one `publicinbox.-httpbackend.max' knob.

limiter: ignore unparseable rlimit

Instead of blindly accepting whatever bogus values the config
gave us, ignore it and use the `W:' prefix to be consistent
with the rest of our codebase.

daemon: check connections WIP

viewvcs: handle exceptions in on_destroy cb

We need to account for File::Temp->newdir or autodie::open
croaking on us in case the system is out of space or memory.
These resource errors are already handled in our normal code
path.  However, this on_destroy codepath can be triggered
when the solver request needs to be queued due to business.
Thus we explicitly call the {-wcb} to ensure the socket
isn't forgotten.

emergency: remove needless $! clobber

We don't check $! unless `sysopen' fails, and `sysopen' will set
$! on failure so there's no need to undef $! ourselves.

mda: use read_all for error handling

We already imported PublicInbox::IO for this script and read_all
provides more safety in case default PerlIO semantics change for
read-in-full behavior.

v2writable: remove outdated FIXME comment and assertions

The lei/store bug was resolved and thus the comments and
assertions are no longer necessary.

Followup-to: 99fc3d76 (v2writable: done: force synchronous awaitpid, 2024-11-19)

config: config_fh_parse: hardcode FS/RS

We no longer need the flexibility to handle non-NUL-delimited
output from `git config -l', so simplify callers and allow
a theoretically sufficiently-advanced Perl implementation
optimize more easily.

Followup-to: 21146412 (config: drop scalar ref support from internal API, 2023-09-24)

git: rely on autodie for sysseek/sysread/truncate

Error messages are more consistent with autodie.  We'll also
drop autodie::read since it's no longer in use for this package.

treewide: use autodie for seek+sysseek

The underlying lseek(2) syscall won't fail due to HW errors,
only due to usage errors (ESPIPE, EINVAL); so don't waste
code on error checking ourselves and just let autodie check
things during development.

lei_xsearch: use autodie for `pipe' ops

We already use autodie in this module and we can have more
consistent error messages this way.

treewide: replace redundant `;;' with `;'

Wonky USB keyboard adapter or too much coffee sometimes makes me
type too many semi-colons (and other characters) :x

lei_saved_search: drop needless comparisons and `next'

The grep(!/\A\.\.?\z/, ...) op already filters out the `.' and
`..' entries from `readdir'.

init: move --skip-epoch handling to {-creat_opt}

Epoch skipping only makes sense at inbox creation, thus we'll
bundle inbox creation options together to reduce potentionally
confusing positional parameters.

init: move --skip-artnum handling to {-creat_opt}

It makes more sense to have inbox creation options bundled
together and reduces the amount of potentially confusing
positional parameters we must pass around.

inbox_writable: match v1 and v2 init semantics

More consistent code between v1 and v2 will make maintenance
easier going forward.

v2writable: simplify ->new by reducing arg flexibility

We can update callers easily enough for internal-only APIs,
so there's no need to deal with unwarranted flexibility for
V2Writable->new.

inbox_writable: use autodie::open

autodie should give us more consistent error reporting going
forward.

doc: add an example of acceptable marketing

Presenting specific solutions to random comments is probably
acceptable since it's potentially helpful to some people;
but disclaimers must be present to lower expectations.

search_query: fix warnings on bogus `o=' query param

Users may specify non-numeric values for the `o' parameter
which won't be captured.  Avoid uninitialized variable warnings
by assuming `0' when no numeric value is specified.

config: force absolute path when `-C /' (chdir) is used

For rare cases where we rely on `-c' to override temporary
options, we also chdir(2) to `/' to avoid hitting a users'
$worktree/.git/config.  Thus, the config file must be given as
as an absolute path.  While the majority of or code assumes
absolute paths are used for config files, it's possible we end
up on some strange setups where $ENV{HOME} is a relative path.

(ext)index: eliminate $sync entirely

Finally, the elimination of this variable simplifies subroutine
calls hopefully makes object lifetimes easier to reason about.

(ext)index: eliminate $sync->{ibx}

Perhaps the trickiest field to eliminate from $sync {ibx}
due to the way -extindex handles cross-posted messages.  We
now eliminate the per-request $req->{ibx} for non-crossposted
messages and use local-ized $self->{ibx} directly.

(ext)index: move {ranges} to $self

Another field we can trivially `local'-ize in our quest to
eliminate the clumsy $sync structure.

(ext)index: move {unindexed} to $self

As with most things that were formerly in $sync, we can just
rely on `local' to flatten the data structure graph and work
towards eliminating $sync.

v2writable: hoist out process_todo sub for extindex

We can have consistent $self->{quit} detection this way and
eliminate an early return from index_todo.

v2writable: {in_unindex} moved to self

{in_unindex} is already local-ized for $sync, so moving it to
$self is trivial since we use ->async_wait_all to ensure
cat-file requests are done.

(ext)index: move {todo} into $self

Another trivial field to `local'-ize and another step towards
eliminating the $sync structure.

extindex: simplify data structures used for dedupe

We can stuff more into $self via `local' and eliminate the $per_mid
structure and extra lookups.

extindex: move {dedupe_cull} to self

This allows us to eliminate the $per_mid->{sync} field used for
dedupe, as well.

(ext)index: eliminate redundant $sync->{epoch_max}

We already had $self->{epoch_max}, and it's easy enough to
`local'-ize it to ensure it doesn't outlive its usefulness when
-extindex handles multiple inboxes.

(ext)index: $sync->{unit} => $self->{unit}

Since we were using `local' anyways on the $sync hashref, it's a
trivial swap to move it into $self.

v2writable: eliminate $sync->{art_end}

Instead of creating a long-lived {art_end} entry or even
local-izing it in $self, pass the `$art_end' value on stack to
achieve symmetry with the existing `$arg_beg' arg in calls to
index_xap_step().

extindex: eliminate repeated ->eidx_key method call

No need to make two relatively expensive `->' method calls when
one will do.

(ext)index: eliminate most uses of `$sync->{ibx}'

Yet another step towards eliminating the $sync structure.
There's still a few remaining dependencies due to cross-inbox
linkage but the goal is to reduce refcount traffic for the
majority of Inbox object references.  This field in $sync will
be completely eliminated in the next few commits.

v2writable: move {mm_tmp} to $self

Another variable we can easily local-ize to limit scope and
reduce refcount traffic from copying into the per-cat_async $arg
structure.

searchidx: eliminate $sync from subroutines

Eliminating this variable will hopefully reduce cognitive
overhead as well as reducing overhead from argument passing.

index: move {reindex} to $self

Again, we can easily contain the scope of {reindex} to $self via
`local', so there's no need to rely on another temporary structure.

index: move {D} (delete state) to $self

The {D} delete state is short-lived and may have its scope
limited via `local', so take another step towards reducing
internal data structures.

(ext)index: move {max_size} and related bits to $self

`--max-size' is persistent for a process, so having it in $self
is more appropriate anyways than the shorter-lived $sync.  The
{index_oid} function pointer is tied to max-size handling, so
we'll move that over to $self as well.

searchidx: rename {sidx} to {self}

While this is v1-only code, {self} is more consistent with the
rest of the code and the eventual goal is to eliminate $sync
entirely in favor of $self for temporary state.

searchidx: move {ntodo} to $self

Another step towards eliminating the temporary $sync structure
to flatten the internal data structures.

extindex: move {id2pos} to $self

{id2pos} doesn't need a different hash table entry for every
request, instead it is tied to the inboxes associated with the
ExtSearchIdx ($self) object so we can just store it and give it
the same lifetime as the associated inbox references.

extindex: {boost_in_use} field to $self

There's no need to repeatedly propagate this field to every
cat-file blob request since this field is tied to the attached
config and inboxes associated with an inbox.

(ext)index: move {quit} from $sync to $self

No need to localize it, either, since we don't expect to
use the $self instance after {quit} is set.

(ext)index: avoid needless {git} ref with --max-size

We can access the PublicInbox::Git object via {ibx} directly to
avoid redundant refs and cut down the $sync struct further.

searchidx: prefix v1 code with `v1_'

Since there's no or v1-specific modules such as `V1Writable',
prefixing v1-specific subs seems like a prudent way to demarcate
subs used for dealing with the old v1 storage format.

We'll also take this opportunity to rearrange the order of subs
to take advantage of prototypes and compile-time checking with
`perl -c'.

smsg->populate: rename $sync to $cmt_info

We only use this hashref to propagate author and commit time
from the commit, so give it a more descriptive name rather than
overloading the to-be-eliminated `$sync' struct.  There's no
need to explicitly vivify into a hashref, either.

(ext)index: move {latest_cmt} to $self (from $sync)

No more sigil and brace overload from ${$sync->{latest_cmt}}
and another step towards $sync elimination.

(ext)index: move {-regen_fmt} from $sync to $self

We rely on `local' anyways in some cases.  This is yet another
step towards eliminating the $sync structure.

(ext)index: move {-opt} from $sync to $self

Another step towards eradicating the $sync structure.

This intermediate step does introduce the $self arg into
log2stack() and prepare_stack() but $self will eventually
eliminate $sync entirely.

(ext)index: ${$sync->{nr}} to $self->{nrec}

{nrec} is probably less confusing as a name in a long-lived
context and we can get rid of the awkward scalar dereferencing
by using $self.

ExtMsg, NewsWWW: account for publicinbox.nameIsUrl

As with WwwListing, these generate full URLs which go across
multiple inboxes, so support the new publicinbox.nameIsUrl
feature which allows users with many inboxes on the same domain
to avoid setting `publicinbox.*.url' for each one.

t/lei-sigpipe.t: use correct pipe size

According to fcntl(2), Linux will round up pipe sizes lower than a
page to a whole page.  Additionally, the kernel may use a larger size
in general, "if that is convenient for the implementation".  The
actual size of the pipe is returned from fcntl, so the test should use
that return value, rather than assuming the size requested was
accepted exactly.  This fixes the test on my system with 16K pages.

extindex: use nproc_shards directly from IPC

There's no reason to use it from the V2Writable namespace
since it was moved to PublicInbox::IPC in commit
9225145d (ipc: move nproc_shards from v2writable, 2023-03-21)
Import it early via `use' so we can take advantage of prototype
checking while we're at it.

watch: don't propagate header changes to other inboxes

Message-IDs may be appended by v2 inboxes for messages with with
conflicting Message-IDs or SpamAssassin (or another spam filter)
can change headers of both v1 and v2 messages.  So we rely on
`local' to reach into Eml internals to localize ->header_set
modifications and rely on modern Perl having copy-on-write
scalars to minimize memory traffic in the common case.

watch: import_eml: avoid Eml dup for non-scrub case

Most inboxes don't use filters, so the destructive ->scrub won't
be called and we can avoid duplicating the Eml object in the
common case.  We'll also drop the last inbox optimization for
net_cb since it's likely unnecessary given that filters are not
very common.

This may be more noticeable for users who map multiple inboxes
to a single Maildir|IMAP|NNTP source.

watch|mda|purge: Filter::*->scrub is destructive

-watch was failing to properly account for inboxes having
different filters and ->scrub behavior during message removal
(but not adds).  Explicitly duplicate and simplify the -watch
code for handling message removal and update the rest of the
callers to reflect the standardized destructive behavior of
->scrub.  While most filters were destructive anyways, the Vger
filter was a notable exception and updated to be destructive.

We'll also update some variables from `$mime' uses to `$eml' to
reflect the switch from (Email|PublicInbox)::MIME to
PublicInbox::Eml years ago.

Finally, the Vger filter includes updated comments and uses
v5.10.1+ features, now.

test_common: support `require_mods "v2"' for v2 inboxes

For our purposes, `v2' should be interpreted as a public-inbox
format and not as a Perl version (e.g. `use v5.12').  This ensures
v2index-late-dupe.t correctly depends on DBD::SQLite and git
v2.6+ via `require_mods "v2"' instead of requiring Perl v2.x.

On a side note, it's unlikely public-inbox-v3 format will ever
be necessary as the v2 format appears scalable enough; thus we
won't hit v5 and risk conflicting with in-use Perl versions.
However, I'm not ruling out a v2.112 format for (nearly)
transparent v1->v2 migrations.

watch: don't count invalid paths against batch limit

Invalid paths such as `.', `..', `.mh_sequence', and perhaps
other implementation-specific files may throw off the count and
cause premature commits.  While the premature commit isn't too
harmful in the common case, it's possible a pathological case of
having too many non-mail entries in a directory can cause
noticeable slowdowns and storage wear.

So have _try_path() and _remove_spam() return a true value if
a file was actually read.  We'll also simplify the $inboxes
check by relying simply on `eq', since the `ref' check isn't
necessary as the `eq' against a ref will never match the
"watchspam" literal.

import: fix space calculation when reusing epochs

Dividing the result of $git->packed_bytes by $PACKING_FACTOR
_twice_ was completely wrong for v2.  Just calculate
$unpacked_bytes once and use it for the Import->{bytes_added}
field.  The calculation for lei/store was actually correct,
just redundant since repeated division is unnecessary.

v2writable: simplify epoch directory generation

As noted in a now-removed comment, InboxWritable->git_dir_latest
seems redundant and an unnecessary function.  Instead, we can
use MultiGit->epoch_dir for these v2-only (non-extindex)
codepaths.

t/filter_base: relax Regexp class match with ->isa

It would be nice to support alternative Regexp engines such
as re::engine::PCRE2 in the future.  The exact ref() name
can't match, however ->isa() works with re::engine::PCRE2.
So future-proof our code for potential changes in case PCRE2
becomes usable.

lei: use PublicInbox::Eml::warn_ignore_cb

The open-coded callback was identical to the existing callback
generated by our Eml package, so just use the existing code
instead unless a user uses `lei import --noisy'

admin: common warn_cb

I noticed verbose output from t/extsearch.t was not correctly
commenting out (`# ') informational messages when the
{current_info} prefix is in use.  This also appears to affect
other indexers with the exception of the new -cindex.

So consolidate all the common warning code into
PublicInbox::Admin module so we can handle {current_info}
properly in all contexts.

-cindex gets some unnecessary Eml warning filtering, but that's
probably not a real problem and worth the overall code savings
since PublicInbox::Admin is loaded by script/public-inbox-cindex
anyways.

t/extindex: add --max-size test

I noticed this missing coverage while working on another
series of changes which aren't quite ready, yet.

searchidx: consolidate checkpoint accounting

We can eliminate check_batch_limit() and checkpoint_due() from
extsearchidx in favor of update_checkpoint() in searchidx.  We
can also get rid of the awkward scalar deref for setting the
{need_checkpoint} field.

The only behavioral difference is the checkpoint interval is
standardized to 5s and -extindex no longer uses 10s for its
checkpoints.  In retrospect, 5s should work more nicely for
public-facing indices since they spend less time waiting on
writers, but it has the downside of potentially hurting writer
performance.

This is another step in the gradual shift away from the $sync
arg in favor of `local $self->{...}'.

extindex: move {checkpoint_unlocks} to $self

One small step towards eliminating the $sync structure.

searchidx: update_checkpoint: take bytes arg directly

Passing $smsg limits flexibility in case we reuse it for deletes
and/or commit search.

over_idx: simplify each_by_mid

Eliminate a useless use of `map {}' and avoid a needless `push'
op since the `join' op can just take extra arg.

cindex: adjust estimated memory cost for deletes

Based on my conversations with the Xapian lead, the cost of
deletes were overestimated by 7x in cindex.  Adjust the estimate
cost of a deleted document to a more reasonable number based on
calculations discussed on the xapian-discuss list.

In any case, all of our batch size memory cost estimates are
rough since since Xapian provides no way of letting us know the
memory cost of the current transaction.