git: cleanup un-associated coderepo processes

It's possible to have many coderepos with no inbox association
that never see git->cleanup.  So instead of tying git->cleanup
to inboxes, ensure it gets armed when ->watch_async is called
(since it's only called in our -netd or -httpd servers).

cindex: fix large prunes

When comm(1) has a lot of data to output, we must ensure we
explicitly close FDs of processes in previous stages of the
pipeline to ensure comm(1) to terminates properly.

This is difficult to test automatically with small test repos...

Fixes: 17b06aa32aac (cindex: start using run_await to simplify code)

cindex: quiet --prune when checking objectFormat

Most coderepos don't have extensions.objectFormat set,
so it's senseless to emit warnings on failures.

Fixes: 709fcf00c4d5 (cindex: use run_await to read extensions.objectFormat)

cindex: store coderepo data asynchronously

While it's typically fast to store coderepo data, pathological
latency on HDDs can let us use that delay to get other work
done.

lei_mirror+fetch: don't slurp `git show-ref' output

While uncommon, some git repos have hundreds of thousands of
refs and slurping that output into memory can bloat the heap.
Introduce a sha_all sub in PublicInbox::SHA to loop until EOF
and rely on autodie for checking sysread errors.

cindex: use sysread for generating fingerprint

We use sysseek for this file handle elsewhere (since it's passed
to `git rev-list --stdin' multiple times), and sysread ensures
we can use a larger read buffer than the tiny 8K BUFSIZ Perl +
glibc is contrained to.

This also ensures we autodie on sysread failures, since the
autodie import for `read' was missing and we don't call `read'
anywhere else in this file.

cindex: use run_await wrapper for git commands

Instead of keeping track of live processes ourselves in a hash
table, we'll rely on OnDestroy here to notify us of git command
completions.

cindex: drop XH_PID global

We only the PID locally to call awaitpid.

cindex: use run_await to read extensions.objectFormat

This saves us the trouble of seeking ourselves by using existing
run_await functionality.  We'll also be more robust to ensure we
only handle the result if the `git config' process exited without
a signal.

cindex: start using run_await to simplify code

This saves us some awaitpid calls.  We can also start passing
hashref redirect elements directly to pipe and open perlops,
saving us the trouble of naming some variables.

cindex: use timer for inits

We'll need to be in the event loop to use run_await in parallel,
so we can't start processes outside of it.  This change isn't
ideal, but it likely keeps the rest of our (hotter) code simpler.

cindex: avoid awaitpid for popen

We can use popen_rd to pass command and callbacks to a
callback sub.  This is another step which may allow us
to get rid of the wantarray forms of popen_rd/popen_wr
in the future.

cidx_log_p: don't bother with F_SETPIPE_SZ

It doesn't help here since the bottleneck is Xapian indexing
(and not `git log -p').  This fcntl call was also in the way
of switching to ProcessIO.

qspawn: simplify internal argument passing

Now that psgi_return is gone, we can further simplify our
internals to support only psgi_qx and psgi_yield.  Internal
argument passing is reduced and we keep the command env and
redirects in the Qspawn object for as long as it's alive.

I wanted to get rid of finalize() entirely, but it seems
trickier to do when having to support generic PSGI.

qspawn: use WwwStatic for fallbacks and error code

This ensures we set directives to disable caching since
errors are always transient.

drop psgi_return, httpd/async and GetlineBody

Now that psgi_yield is used everywhere, the more complex
psgi_return and it's helper bits can be removed.  We'll also fix
some outdated comments now that everything on psgi_return has
switched to psgi_yield.  GetlineResponse replaces GetlineBody
and does a better job of isolating generic PSGI-only code.

www_coderepo: use psgi_yield

Yet another drop-in replacement for psgi_return.

cgit: switch to psgi_yield

Another drop-in replacement using an alternate limiter.

www_altid: switch to psgi_yield

Another drop-in replacement for psgi_return, this one notably
utilizing an unconditional qspawn.filter for gzip unlike the
others.

viewvcs: psgi_yield

Another drop-in replacement, though I took the opportunity
to avoid unnecessarily bumping the refcount of $ctx->{env}

repo_snapshot: psgi_yield

Another drop-in replacement for psgi_return.

repo_atom: switch to psgi_yield

To my pleasant surprise, it appears I've managed to make
psgi_yield a drop-in replacement for psgi_return...

qspawn: introduce new psgi_yield API

This is intended to replace psgi_return and HTTPD/Async
entirely, hopefully making our code less convoluted while
maintaining the ability to handle slow clients on
memory-constrained systems

This was made possible by the philosophy shift in commit 21a539a2df0c
(httpd/async: switch to buffering-as-fast-as-possible, 2019-06-28).

We'll still support generic PSGI via the `pull' model with a
GetlineResponse class which is similar to the old GetlineBody.

xt/check-run: call DS->Reset after all tests

This ensures reused processes get a clean start and
avoids surprises as we develop more code around the
DS event loop.

httpd/async: require IO arg

Callers that want to requeue can call PublicInbox::DS::requeue
directly and not go through the convoluted argument handling
via PublicInbox::HTTPD::Async->new.

qspawn: drop unused err arg for ->event_step

It's no longer needed since psgi_qx doesn't use a pipe, anymore.

qspawn: psgi_return allows list for callback args

This slightly simplifies our GitHTTPBackend wrapper.
We can also use shorter variable names to avoid wrapping some
lines.

www_coderepo: capture uses a flattened list

We no longer need a multi-dimensional list to pass multiple
arguments to the psgi_qx callback.  This simplifies usage
and reduces allocations.

psgi_qx: use a temporary file rather than pipe

A pipe requires more context switches, syscalls, and code to
deal with unpredictable pipe EOF vs waitpid ordering.  So just
use the new spawn/aspawn features to automatically handle
slurping output into a string.

spawn: support synchronous run_qx

This is similar to `backtick` but supports all our existing spawn
functionality (chdir, env, rlimit, redirects, etc.).  It also
supports SCALAR ref redirects like run_script in our test suite
for std{in,out,err}.

We can probably use :utf8 by default for these redirects, even.

limiter: split out from qspawn

It's slightly better organized this way, especially since
`publicinboxLimiter' has its own user-facing config section
and knobs.  I may use it in LeiMirror and CodeSearchIdx for
process management.

cindex: basic inboxes are non-fatal for --associate

We need to gracefully continue when a user tries to associate
with --all but has basic (or completely unindexed) inboxes.

t/cindex: use autodie

More tests to come, so cut down on the noise in the test code.

cindex: --associate fails when no inboxes are given

This functionality still needs to be fleshed out, but we
definitely can't associate coderepos to inboxes if we don't have
any inboxes as candidates.

xap_helper.pm: quiet undefined warnings at shutdown

We can't force EBADF with high-level I/O wrappers like we can
in C, so instead we quiet Perl itself.

t/init.t: don't modify $HOME/.public-inbox/config in test

Oops :x

www: fully qualify read_all subroutine call

IMHO, this is not worth importing here since it's only called at
startup.

Fixes: 19b791f4894e (use read_all in more places to improve safety)

lei: simplify startq/au_done wakeup notifications

We only need to write one byte at MUA start instead of a byte
for every LeiXSearch worker.  Also, make sure it succeeds by
enabling autodie for syswrite.

When reading, we can rely on `:perlio' layer `read' semantics
to retry on EINTR to avoid looping and other error checking.

Revert "kqnotify: drop EV_CLEAR (edge triggering)"

This reverts commit 13a2088c74fdb4fa51cd97cefc00862cc2082330.

It's causing errors on an OpenBSD development snapshot while
despite being fine on OpenBSD 7.3 (amd64) and other *BSDs I've
tested.

Reported-by: Štěpán Němec <stepnem@smrk.net>
Link: https://public-inbox.org/meta/20231018170111+0200.599564-stepnem@smrk.net/

idx_stack: use autodie + read_all

We'll also add a note to support multi-hash git repos once git
itself gains that ability.

convert: use read_all to simplify error checks

There wasn't a need to loop anyways with Perl `read' since
the default PerlIO layer will retry.

lei_config: drop redundant open check

autodie already takes care of checking for open failures.

lei_auth: update comments and use v5.12

There's nothing affected by the `unicode_strings' feature, so
it's safe to use v5.12, here.

lei: use autodie where appropriate

This makes us a bit harsher with misbehaving clients, but we
only have one client implementation at the moment.

xt/mem-imapd-tls: reduce FDs for lsof use

We need some pipes in our parent process to capture the output
of lsof(1), so give us some more padding for temporary FDs.

xt/mem-imapd-tls: remove unused/broken epoll imports

The `:epoll' tag has been gone for a few weeks, and EPOLLIN
isn't used in this file anywhere.

Fixes: 3005c1bc5d05 (ds: use object-oriented API for epoll)

init: use autodie to reduce distractions

This hurts startup time a bit, but our tests use run_script
by default and I don't think normal users call -init enough
to care.

init: drop extraneous `+'

It's actually valid Perl syntax, but still confusing to look at.

Fixes: add90b9504f4 ("support -C (chdir) for most non-daemon commands")

test_common: use $cwdfh for every run_script command

It's not lei-specific since we have `-C' to perform chdir
for multiple admin commands.

test_common: only hide TCP port in messages

v2:// lei outputs are on the filesystem, so putting $HOST:$PORT
is nonsensical.  We'll also keep `127.0.0.1' or `[::1]' since
it's harmless and can point out obvious errors in system
configuration when testing with old Perls or libraries.

test_common: use autodie and read_all where possible

Noise reduction to help my aging eyes.

t/lei-up: additional diagnostics for match failures

I'm not sure why, but this test just failed for some odd reason
from `make check-run' on my Debian bullseye workstatation.

syscall: common $F_SETPIPE_SZ definition

We use this in various places to minimize or maximize pipe
size on Linux.  So keep it all in one place.

cindex: drop some unused functions

They're no longer needed with the way PublicInbox::CidxLogP is
currently implemented.

ds: get rid of SetLoopTimeout

It's not worth the code and memory to have a setter method we
never use outside of tests.

ds: introduce and use do_fork helper

This ensures we handle RNG reseeding and resetting the event
loop properly in child processes after forking.

xt/git-http-backend: remove Net::HTTP usage

HTTP::Tiny is part of the Perl standard library since Perl 5.14
while Net::HTTP has never been (unlike Net::NNTP or Net::POP3).
For the test which forces server-side buffering, we'll just use
regular socket handle.

xap_client: autodie for pipe and socketpair

This saves us a few lines of code.

xap_helper: autodie for getsockopt

Only caveat is we can't use bareword filehandles, but that's
a minor inconvenience.

xap_helper: simplify SIGTERM exit checks

We can just close the socket FD to ensure things fail ASAP
when a SIGTERM hits instead of wasting time making getppid(2)
syscalls.

xap_helper: die more easily in both implementations

We don't need to tolerate bad requests since it's only handling
requests from the parent process.  So simplify error management
and just die||exit if we get a bad request.

xap_helper*: use autodie in more places

This ought to lower the cognitive overhead of reading our code.

use read_all in more places to improve safety

`readline' ops may not detect errors on partial reads.
This saves us some code to reduce cognitive overhead for
readers.  We'll also support reusing a destination buffers so it
can work more nicely with existing code.

lei_mirror: use read_all

This gives us better error checking for regular files.

import: use read_all to detect short reads

Our Import package was depending on Git, anyways.

git: introduce read_all function

This makes it easier to improve error checking, since the
`do { local $/; readline(FH) }' construct does not detect
errors (autodie does not cover `readline' or `<FH>').

I'm not sure exactly where this should be, but PublicInbox::Git
is used nearly everywhere in our code base and it's probably
not worth creating a new package for it.

lei_mirror: use autodie for most `open' calls

We'll also drop most `print' checks since we need to rely on
`close' or IO::Handle->flush for error checking, anyways.

lei_mirror: autodie most `close' calls

Another step towards reducing our code burden and having
more consistent error messages.

lei_mirror: start converting to autodie

This code is too noisy and not critical for startup performance;
so autodie provides a nice noise reduction while improving error
reporting in most cases.

For places where failures are expected, the `CORE::' prefix
gives us an easy escape hatch to fall back to normal error
checking.

input_pipe: fix socket check

`-S' is the correct file test op for sockets, `-s' is for st_size.

input_pipe: handle noncanonical TTY

lei could get a TTY in noncanonical mode for stdin, so rely on
VMIN+VTIME to get the desired non-blocking semantics we'd expect
from a pipe or socket.  This ought to prevent read(2) (Perl sysread)
from returning zero when we really want to hit EAGAIN.

input_pipe: improve error handling

Ensure the callback is always guarded by `eval' to catch
exceptions and to force a ->close (EPOLL_CTL_DEL).

We also don't want to blindly set O_NONBLOCK on TTYs since their
O_NONBLOCK semantics aren't well-defined by POSIX.  We can also
drop EPOLLET (edge-triggered) use to reduce the need to make
->requeue calls on our end.

lei: consolidate stdin slurp, fix warnings

We can share more code amongst stdin slurper (not streaming)
commands.  This also fixes uninitialized variable warnings when
feeding an empty stdin to these commands.

install/README: improve wording

Reported-by: Štěpán Němec <stepnem@smrk.net>

search: rectify comment (rt: documented since 738c4a65719e)

Fixes: 738c4a65719e ("www: various help text updates")

doc: lei-q: drop stale TODO comment (fixed in 1f1b1f0e22f7)

Fixes: 1f1b1f0e22f7 ("doc: lei-q: document SEARCH TERMS prefixes")

doc: fix some typos and grammar

[ew: leave install/README unchanged pending wording changes]

learn: respect indexlevel for v1 inboxes

v2 never suffered from this bug, apparently, but -learn didn't
seem able to handle indexlevel=basic (nor respect `medium')
for v1 inboxes.  I only noticed this bug because I converted
some ancient v1 inboxes to `basic' to save space.

xap_helper_cxx: allow sharing XDG_CACHE_HOME across ABIs

For users sharing home directories (or just XDG_CACHE_HOME)
across hosts of different architectures, we must use a compiler
and architecture-specific destination directory for storing the
binary result.  Even on the same OS and architecture, different
C++ compilers may have different ABIs, so we must account for
that.

lei: quiet excessive write/seen messages

We don't want to end up dumping nr_seen/nr_write when progress
is disabled, nor do we want forked off `lei note-event' workers
dump them when DS->Reset is called on fork.

emergency: support hostname of `.'

I think I was too lazy when configuring my Dragonfly VM install.

lei import|tag|rm: support --commit-delay=SECONDS

Delayed commits  allows users to trade off immediate safety for
throughput and reduced storage wear when running multiple
discreet commands.

This feature is currently useful for providing a way to make
t/lei-store-fail.t reliable and for ensuring `lei blob' can
retrieve messages which have not yet been committed.

In the future, it'll also be useful for the FUSE layer to batch
git activity.

lei blob: run cat_blob on lei/store for pending blobs

This can probably be made asynchronous in the future via
PublicInbox::InputPipe, but it's good enough for testing.

import: cat_blob is a no-op w/o live fast-import

cat_blob is a fallback for handling files which haven't made it
onto disk to be readable by `git cat-file'.  Thus spawning a new
fast-import process to retrieve a blob is pointless, as cat_blob
is only used as a last resort when `git cat-file' fails.

import: switch to Unix stream socket for fast-import

We use fewer file descriptors and fewer lines of code this way.
I'm not aware of any place we rely on POSIX pipe semantics with
`git fast-import', and sockets have bigger buffers by default
in most cases (even if Linux allows larger pipe buffers).

treewide: consolidate "From " line removal

Aside from our prior import bugs (fixed in a0c07cba0e5d8b6a
(mda: drop leading "From " lines again, 2016-06-26)), we'll
always have to be dealing with mutt piping messages to us and
`git format-patch' output.  So just share the regexp so we
can use it everywhere.

In may be desirable to allow importing messages with a leading
"From " line for FUSE, even.

Additionally, some instances of this regexp needlessly added
optional `\r?' (CR) checks ahead of the `\n' (LF) element; but
they're pointless anyways since [^\n]* is enough to exclude all
non-LF bytes.

msgtime: simplify msg_timestamp and msg_datestamp

We don't need multiple return points nor multiple time_response
calls in either function.

msgtime: quiet warnings we can do nothing about

In retrospect, warning about bad times and dates is pointless
since there's nothing actionable about it.  We'll also drop an
unnecessary capture in msg_received_at while we're at it and
favor using $eml since as the input variable name to match
current usage.

The note to install Date::Parse as a fallback remains since it
can be helpful in some cases (and is actionable by the user).

lei_xsearch: improve curl progress reporting

Instead of having tail(1) follow a file when we're in verbose
mode, unconditionally pipe stderr to a Perl 2-liner which tees
its output to a regular file with line buffering.

POSIX tee(1) isn't suitable for this task since it's required
to be completely unbuffered while we want line-buffering when
running parallel processes.  Fortunately, Perl makes this easy.

This also means we no longer leave curl-err.XXXX files around
on premature shutdown if we're hit by a SIGKILL or similar and
can't exit normally.

We do need to stop and respawn the Perl process if we hit a curl
error, though, since we need to be certain the output is
flushed.

lei rediff: use ProcessIO for --drq support

This required fixing binmode support a few commits ago, along
with properly enabling autoflush in popen_wr instead of setting
it on the wrapper ProcessIO class.

t/imap_searchqp.t: retry bad query test on failure

I really don't understand why this fails, sometimes; but it does.

ds: use a dummy poller during Reset

commit 1897c3be1ed644a05f96ed06cde4a9cc2ad0e5a4
(ds: Reset: replace Poller object early, 2023-10-04)
was not effective at eliminating the following message
at daemon shutdown:

Can't call method "FILENO" on an undefined value at
.../PublicInbox/Select.pm line 34 during global destruction.

This seems down to some tied objects having unpredictable
destruction order.  So use a dummy class to ensure its ep_*
methods never call the tied `FILENO' method at all since
dropping the Poller object will release any resources it holds.

over*: avoid defined-or hash assignments with side-effects

These may've been causing strange errors[1] in t/imapd.t from
the -watch daemon, such as:

Cannot copy to HASH in scalar assignment ../PublicInbox/Over.pm

in the Over->dbh() sub.  I've only noticed this failure on
FreeBSD 13.2 (Perl 5.32.1, DBD::SQLite 1.72 (bundled SQLite
3.39.4), DBI 1.643) so far, so it could also be something to do
with the versions used and/or memory layout differences
with libc or build toolchain.

t/nntp.t: attempt to track source of undefined vars

Occasionally, t/nntp.t spews undefined variable warnings under
`make check-run'.  While the test doesn't fail, it's annoying
to see them and it could be a source of deeper problems.

spawn: reinstate directory existence check

We must not attempt to use Inline::C unless a user requests
it (by creating the directory) or running lei.

Fixes: ebdccd6666f9 (spawn: drop checks for directory writability)

www_coderepo: fix handling of non-UTF-8 git data

We can't assume git output is UTF-8, and we'll always have
legacy data in git coderepos.  So attempt to display some
some garbled text rather than nothing at all if Perl croaks
on it.

sox commit c38987e8d20505621b8d872863afa7d233ed1096
(Added raw inverse-bit u-law and A-law support.  Updated *.txt files., 2001-12-13)
is an example of a commit which caused problems for me.

introduce ProcessIONBF for multiplexed non-blocking IO

This is required for reliable epoll/kevent/poll/select
wakeup notifications, since we have no visibility into
the buffer states used internally by Perl.

We can safely use sysread here since we never use the :utf8
nor any :encoding Perl IO layers for readable pipes.

I suspect this fixes occasional failures from t/solver_git.t
when retrieving the WwwCoderepo summary.

process_io: fix binmode and use it in lei_xsearch

The `binmode' perlop can only take two scalars, so passing
`@_' blindly won't work since prototypes are checked.  This
means we can get IO::Uncompress::Gunzip working properly
with ProcessIO and use it for curl.

We'll also just autodie (instead of warn) on FS errors when
dealing with curl stderr; since the process will likely be
in bigger trouble soon, anyways.

overidx: use croak/confess instead of die

Unlike `die', `croak' can be expanded to `confess' to give a
full backtrace.  We'll use `confess' on transaction failures
since that occasionally causes sporadic t/imapd.t failures on
FreeBSD (IO::Kqueue is installed, so signals are deferred).

cindex: start using autodie

A small step towards making this code less noisy.