replace ProcessIO with untied PublicInbox::IO

This fixes two major problems with the use of tie for filehandles:

* no way to do fcntl, stat, etc. calls directly on the tied handle,
  forcing callers to use the `tied' perlop to access the underlying
  IO::Handle

* needing separate classes to handle blocking and non-blocking I/O

As a result, Git->cleanup_if_unlinked, InputPipe->consume,
and Qspawn->_yield_start have fewer bizzare bits and we
can call `$io->blocking(0)' directly instead of
`(tied *$io)->{fh}->blocking(0)'

Having a PublicInbox::IO class will also allow us to support
custom read buffering which allows inspecting the current state.

git_credential: use autodie where appropriate

We can also rely on `say' in Perl 5.10+ to save us the trouble
of printing a newline.

multi_git: use autodie

Trying to move away from half my code being "or die" statements...

treewide: use ->close to call ProcessIO->CLOSE

This will open the door for us to drop `tie' usage from
ProcessIO completely in favor of OO method dispatch.  While
OO method dispatches (e.g. `$fh->close') are slower than normal
subroutine calls, it hardly matters in this case since process
teardown is a fairly rare operation and we continue to use
`close($fh)' for Maildir writes.

cindex: drop redundant close on regular FH

There's no need to waste optree space on close() statements for
file handles which are (effectively) read-only on their last use
and incapable of error checking in our Perl code (since they're
only read by git).

Let Perl refcounting take care of it so we have less code to
wade through when focusing on `close' statements which actually
matter.

ds: don't try ->close after ->accept_SSL failure

Eric Wong <e@80x24.org> wrote:
> --- a/lib/PublicInbox/DS.pm
> +++ b/lib/PublicInbox/DS.pm
> @@ -341,8 +341,8 @@ sub greet {
>   my $ev = EPOLLIN;
>   my $wbuf;
>   if ($sock->can('accept_SSL') && !$sock->accept_SSL) {
> - return CORE::close($sock) if $! != EAGAIN;
> - $ev = PublicInbox::TLS::epollbit() or return CORE::close($sock);
> + return $sock->close if $! != EAGAIN;
> + $ev = PublicInbox::TLS::epollbit() or return $sock->close;
>   $wbuf = [ \&accept_tls_step, $self->can('do_greet')];
>   }
>   new($self, $sock, $ev | EPOLLONESHOT);

Noticed this on deploy:

-----8<-----
Subject: [PATCH] ds: don't try ->close after ->accept_SSL failure

->accept_SSL failures leaves the socket ref as a GLOB (not
IO::Handle) and unable to respond to the ->close method.
Calling close in any form isn't actually necessary at all,
so just let refcounting destroy the socket.

treewide: use ->close method rather than CORE::close

It's easier-to-read and should open the door for us to get rid
of `tie' for ProcessIO without performance penalties for
more frequently-used perlop calls and ability to do `stat' directly
on the object instead of the awkward `tied' thing.

ds: replace FD map hash table with array

FDs are array indices into the kernel, anyways, so we can
take advantage of space savings and speedups because the
majority of FDs a big process has is going to end up in
the array, anyways.

xap_helper.pm: use do_fork to Reset and reseed

We may start using rand() in the worker someday if we need
to seed a hash function for caching.  It saves us some LoC
in the meantime.

git: reschedule cleanup if active

This is necessary to reliably cleanup cat-file processes for
coderepos in long-lived -netd and -httpd processes if they
haven't been accessed in a while.

Followup-to: 33e99002c552 (git: cleanup un-associated coderepo processes)

ds: make ->close behave like CORE::close

Matching existing Perl IO semantics seems like a good idea to
reduce confusion in the future.

We'll also fix some outdated comments and update indentation
to match the rest of our code base since we're far detached from
Danga::Socket at this point.

pop3: use SSL_shutdown(3ssl) if appropriate

This allows us support SSL session caching + reuse in the future.

watch: simplify DirIdle object cleanup

There's no need to waste time nor reach into DS internals to
map FDs to Perl objects, here.  LEI.pm has never had to deal
with integer FDs for DirIdle, either.

ds: move maxevents further down the stack

The epoll implementation is the only one which respects the
limit (kevent would, but IO::KQueue does not).  In any case,
I'm not a fan of the maxevents=1000 historical default since
it leads to fairness problems with shared non-blocking listeners
across multiple daemon workers.

ds: do not defer close

We can map all integer FDs to Perl objects once ->ep_wait returns,
so there's no need to play tricks elsewhere to ensure FDs can
be mapped to objects within the same event loop iteration.

ds: next_tick: shorten object lifetimes

Drop reference counts ASAP in case it saves us some memory
sooner rather than later.  This ought to give us more predictable
resource use and ensure OnDestroy callbacks fire sooner.
There's no need to use `local' to clobber the arrayref anymore,
either.

AFAIK, this doesn't fix any known bug, but more predictability
will make it easier to debug things going forward.

xap_helper.pm: quiet undefined die at shutdown

Another attempt at doing what commit 35de8fdcbf290e25
(xap_helper.pm: quiet undefined warnings at shutdown, 2023-10-23)
tried to do.  It turns out perl croaks (not warn/carp) when it sees
an undefined file handle, here.

poll+select: check EBADF + POLLNVAL errors

I hit this in via select running -cindex with some other
experimental patches.  I can't reproduce the problem, though,
but this ensure we have a chance to diagnose it if it happens
again instead of looping on select(2) => EBADF.

lei_config: import read_all properly

*sigh* fixing interactive editing stuff is a pain...
Found while making other changes...

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

lei_mirror: fix seek/sysseek argument ordering

It doesn't matter in practice for platforms we support, since
SEEK_SET is `0' everywhere I've seen.

examples/logrotate: only SIGUSR1 main process

There's no need to send SIGUSR1 to auxiliary processes since
they don't know what to do with them.

examples/*.service: avoid `nobody' user on systemd

systemd complains about `User=nobody' since `nobody' has access
to all files which can't be mapped to a valid UID.  We'll also
switch to `Group=ssl-cert' since that ought to be able to read
TLS certificates.

spawn: use readline instead of read for scalar redirects

Using `-s $fh' as the length arg for `read' is incorrect for
:utf8 and other non-:raw file handles because `read' operates
in *characters*, not bytes.

lei_ale: use v5.12, autodie, and try_cat

Just things I spotted while looking for other problems
throughout our codebase.

xt/eml_check_limits: remove useless import

Found while hunting for popen_rd calls.

www_altid: reduce FD pressure in qspawn queues

We can use the built-in stdin redirection functionality of
spawn() instead of creating a pipe that sits idle in the queue
on busy servers.

treewide: use run_qx where appropriate

This saves us some code, and is a small step towards getting
ProcessIO working with stat, fcntl and other perlops that don't
work with tied handles.

gcf2: simplify pkg-config and Inline::C setup

We can use run_qx and try_cat to make the build setup simpler.

git: avoid extra stat(2) for git version

No sane installer will update executable files in place due to
ETXTBSY on execve.  So save ourselves a stat(2) call by relying
on the special `CORE::stat(_)' case to reuse the cached result
from the `-x FILE' filetest in which().

git: use run_qx to read `git --version'

It exists, now, so save us a few lines of code.

spawn: avoid alloca in C pi_fork_exec

We don't have thread-safety to worry about, so just leave a few
allocations at process exit at worst.  We'll also update some
comments about usage while we're at it.

spawnpp: use autodie for syscall failures

We lose a little info for fork failures, but I don't think it
matters.

spawn: croak directly in C pi_fork_exec

This saves us some Perl code in the wrapper, since the SpawnPP
implementation also dies directly.

lei: don't exit lei-daemon on ovv_begin failure

When ->ovv_begin is called in LeiXSearch->do_query in the top-level
lei-daemon process, $lei->{pkt_op_p} still exists.  We must make
sure we're exiting the correct process since lei->out can call
lei->fail and lei->fail calls lei->x_it.

As to avoiding how I caused ->ovv_begin failures to begin with,
that's for a much bigger change...

cindex: clarify fatal vs non-fatal messages

cindex must be able to handle coderepos being deleted mid-run
since `public-inbox-clone --purge' may be running at the same
time.  This is a step towards handling parallel invocations
of -cindex and public-inbox-clone as gracefully as possible
by improving error messages.

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.