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.

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).