qspawn: fix process finalization for generic PSGI server

This fixes the inability to fallback to WwwCoderepo on cgit 404s
with generic PSGI servers.  Unfortunately, this doesn't seem to
get tested with generic PSGI tests, and doesn't happen on
public-inbox-httpd, obviously.

t/httpd-unix.t: stop tail(1) before stopping server

When using the `TAIL' environment, the tail(1) process
inherits the non-FD_CLOEXEC pipe we introduced in commit
5f9baf725106 (t/httpd-unix: eliminate some busy waits, 2022-12-12).
We must ensure that pipe is gone before waiting on -httpd's
death by destroying the tail(1) process, first.

t/solver_git.t: avoid redundant work for snapshot test

We only have to generate the expected tarball and checksum once
for testing both -httpd and generic PSGI. And drop the redundant
length check since the SHA-256 check is sufficient.

This saves 20-30ms on my system.

t/run.perl: drop branch for a small set of test cases

It's not worth it, since our test count is only going to
increase over time.

www: load cgitrc for coderepos for solver

Loading cgitrc (and associated projects.list) can get users
out of defining as many individual coderepos.

xt/solver.t needs a use of `$_' replaced since that
gets clobbered while parsing cgitrc.

clone: fix --post-update-hook behavior

Only run hooks if we've done a fetch (which may be a no-op), and
add some tests to ensure it works as advertised with and without
--objstore=

clone: --dry-run unconditionally runs show-ref

It's useful to show what's being updated, of course.

clone: support --post-update-hook= from grokmirror

This should be compatible with both grokmirror 1 and 2 behavior
and serialized on a per-repo basis.

qspawn: more generic command chaining

Move the chaining logic into qspawn so we can gracefully
try other commands when cgit or git-http-backend refuses
to service a request for us.

syscall: fix i386/i686 detection

Both __ILP32__ and __x86_64__ need to be defined for a system to
be considered x32.  Without this, my 32-bit Debian VM on a
64-bit kernel would fail after upgrading to Perl 5.32.1 on
Debian 11 (bullseye).

test_common: avoid needless fcntl in start_script

POSIX::dup2 does not do anything in addition to dup2(2) and is
thus immune to Perl automatically setting FD_CLOEXEC on FDs it
makes into IO objects/globs.  We only need to account for the
case when both args for dup2 are identical, in which case the
kernel treats it as a no-op and then thus we need to clear
FD_CLOEXEC ourselves.

spawn_pp: cleanup, error checks and descriptive errors

The pipe(2) call needs to be checked for failure.  While we're
at it, none of this is affected by unicode_strings, so Perl v5.12
is safe to use and gets rid of the strict.pm overhead.

We can also `die' directly since it's pure Perl and not contort
our Perl code to the assumptions of the Inline::C version.

`die' already implies a failure, so follow existing conventions
of just having the failing function or op name.

We can also rely on the grep op for filtering out non-system
signals to avoid writing a loop ourselves.

Finally, drop a needless `undef' on the read side of the pipe
since it's already closed immediately in the child.

cleanup pure Perl use

This quiets down tests when the optional Inline::C is missing.

We do not currently have a hard dependency on Inline::C; and we
should not leave PERL_INLINE_DIRECTORY set in PublicInbox::Spawn
if Inline fails to build.

Leaving PERL_INLINE_DIRECTORY set by Spawn after it fails (due
to missing Inline::C) would cause downstream failures in Gcf2
builds for the same reason.  So we should bail out of the Gcf2
build early if Spawn already failed due to missing Inline::C.

The only time we want to be noisy is if a user explicitly sets
PERL_INLINE_DIRECTORY and Inline::C is missing.

This reverts commit ad8acf7d6484d0a489499742cadadbd4f890ab53.
ad8acf7d6484d0a4 (Gcf2: Create cache folder if missing, 2022-09-08)

syscall: drop syscall.ph support

h2ph-generated *.ph files are often wrong or incomplete and IME
they cause more problems than they solve.  Furthermore, we need
knowledge of struct layouts which h2ph-generated files can't get
us.  So trim down some bloat and leave a note for porters.

syscall: get rid of epoll_defined() sub

We can just check defined() on the `our' var itself and
save the process several kilobytes of memory.

httpd/async + qspawn: rename {fh} fields

Use more unique names within the project to minimize confusion
since these packages interact quite a bit and using identical
names leads to needless confusion.

qspawn: shorten life of {hdr_buf} in generic code path

No point in keeping the old buffer around if we don't need to.

httpd/async: remove useless undef

Assigning `undef' to a scalar doesn't free it's memory,
we need to call `undef($var)' in the caller.  It's also
been pointless since we simplified ->async_pass in commit
b7fbffd1f8c12556 (httpd/async: get rid of ephemeral main_cb, 2019-12-25)

httpd: avoid crash on cgit -> coderepo 404 fallback

A trickled cgit response can cause HTTPD::Async->event_step to
fire an extra time after header parsing.  We need to account for
the lack of async_pass call populating ->{fh} and ->{http} in
that case and avoid calling $self->{fh}->write when there's
no {fh}.

lei_mirror: allow `git show-ref' failures

`git show-ref' may fail on initialized-but-empty repositories.
So just unconditionally fetch those repos if we're in that
situation.

tests: add tests for cloning coderepos w/ manifest

It's not much, yet, but it's something for the corner cases
which I'm maybe not hitting under normal use.

git: cap MAX_INFLIGHT value to POSIX minimum

This ensures we get consistent pipelining behavior across
platforms.  Furthermore, a smaller value is probably more
reasonable since "git cat-file" can usually outpace indexing and
lower values allow us to react to user interaction (e.g. Ctrl-C)
more quickly.

The previous value based on Linux PIPE_BUF (4096) allowed a
value of 189 which worked fine on non-musl Linux systems, but
failed on musl-based Void and Alpine Linux.  Mysteriously, this
works on musl up to a value of 114 and starts locking up at 115.
The reason for this failure is currently unexplained and will
hopefully be discovered soon.

Regardless, capping the value to 23 based on the universal
PIPE_BUF minimum (512) seems reasonable, anyways.

Reported-by: Chris Brannon <chris@the-brannons.com>
Tested-by: Chris Brannon <chris@the-brannons.com>
Link: https://public-inbox.org/meta/87edssl7u0.fsf@the-brannons.com/T/

relnotes: 2.0.0 work-in-progress

I'm thinking the -nntpd regression fix will push this release
out sooner rather than later...

www_listing: drop "sort options + mbox downloads" bit

The sort options and mbox downloads only apply to individual
inbox search endpoints, and they make no sense for the listing
of inboxes themselves.

search_query: fix warnings on empty "o=" query

This fixes the following warnings from bad URLs:

  Odd number of elements in anonymous hash at <>/PublicInbox/SearchQuery.pm line 22.
  Argument "l" isn't numeric in numeric lt (<) at <>/PublicInbox/SearchView.pm line 39.

solver_git: more descriptive error for "git apply" failures

This happens quite often on my systems due to scrapers,
unfortunately.

lei_mirror: break circular references

It seems more graceful than dying and breaking a mirror, since
the {reference} in util-linux was irrelevant anyways with the
move to forkgroups.

lei_mirror: trim current symlinks from warning

This quiets needless warnings from current symlinks, while still
complaining about out-of-date ones.

t/httpd-unix: eliminate some busy waits

A small step towards making our test suite as sleep-less as
possible.  We can use FIFOs to coordinate processes in a few
places, while other spots can take advantage of disabling
FD_CLOEXEC to further eliminate back-and-forth traffic between
processes.

This speeds up t/httpd-unix.t by ~20 ms on my system.

tests: replace select/usleep calls with tick()

This makes it easier to identify places in tests which cause
unnecessary slowdowns doing busy waits.

lei_saved_search: expand only/include/exclude to absolute paths

While users may specify relative paths for convenience on the
command-line, absolute paths are required for `lei up' since
that (especially `lei up --all') could run from anywhere.

Note that we need to do this when parsing the command-line
options, since shortcuts for URL matching on URL path components
are allowed for `lei q', and those same shortcuts may remain
in effect across to `lei up' as the underlying external may
be moved to a different URI host.

lei: stricter external checks for valid $GIT_DIR/objects

I ended up with my $HOME in
~/.cache/lei/all_locals_ever.git/objects/info/alterntes
and am trying to avoid that in the future.

lei_mirror: handle forkgroup changes

Forkgroups for projects are not static and may change at
the whim of the remote sysadmin.  Ensure we can migrate
to the new forkgroup.

Old forkgroups do not get pruned, yet, and their entries
stay in alternates.

clone: support --project-list= for cgit

grokmirror supports it, and we also support cgit, so this should
make running mirrors easier.  This will be useful for scripting
purposes, too.

lei_mirror: break out of fgrp fetch iteration early

Don't queue up more work if we already have a failure somewhere.

lei_mirror: don't clobber inbox.config.example if it exists

Users may save notes or edits in there, and it's only an
example, so there's no need to mindlessly clobber it.

lei_mirror: set info/web/last-modified from manifest

The grokmirror manifest sets {modified}, so we might as well use
it to make life easier for users of cgit (and compatible)
front-ends.

lei_mirror: omit trailing slash for git remote.*.url

While PublicInbox::WWW URLs have a trailing slash in them
for compatibility with static web server mirrors, URLs
intended for `git clone' don't benefit from this and the
trailing `/' just looks awkward.

lei_mirror: avoid redundant curl `-f' use

All of our curl invocations use the `-f' (--fail) switch
anyways, and I can't imagine a time when we'd want silent
failures.

lei_mirror: use curl -z/--timecond if manifest exists

This lets us save cycles and avoid scanning + comparing manifest
contents by relying on the Last-Modified HTTP response header.

lei_mirror: eliminate circular references

...by using local-ized globals.  While non-globals could work,
eliminating the {todo} and {fgrp_todo} refs in all sub-refs
is more error-prone and the `local' construct is convenient.

This allows us to get rid of the `delete $fgrp->{-fini}' call
in pack_refs and eliminates the indiscriminate reaping of all
processes before calling fgrp_fetch_all.  This means we can
fully depend on DESTROY to provide predictable dependency
handling while supporting parallelization.

Global $TODO and $FGRP_TODO now become SCALAR refs on
consumption so they can act as assertions to detect future bugs.

lei_mirror: support {symlinks} from manifest

It's part of grokmirror, and useful for keeping compatibility.
We can make use of File::Spec->abs2rel here to ensure our
symlinks are relative and the entire mirror can be copied
as a whole.

lei_mirror: set {head} from manifest

We handle symbolic refs properly, at least.  It's also possible
for $GIT_DIR/HEAD to contain a full SHA-1/SHA-256, and we'll
support that by using update-ref --no-deref

lei_mirror: shorten scope mirror objects

We may be able to save some memory this way.

lei_mirror: simplify forkgroup-related subs

We can pass fewer variables around on stack since $fgrp is just
a copy of $self.  We can also rely more on explicit callback
passing rather than relying on OnDestroy and ->cancel for
conditional calls.

lei_mirror: run v1_done earlier on forkgroup done

There's likely a circular reference somewhere which was
preventing v1_done from running early.  In any case, this allows
v1_done to run in parallel with the pack-refs process since
there's no ordering dependency between ref-packing and v1_done.

lei_mirror: simplify most process spawning

For commands where we rely on successful exit codes to continue,
start_cmd() generalizes well enough to be used in a variety
of places.

lei_mirror: remove janky mirror.done stamp file

This makes a fundamental (and overdue) change to the core of
lei in how it handles child errors.  Every process which
generates or receives a child error will remember it before
passing it on.  This ensures _wq_done_wait callbacks will
know of prior errors aside from $? when it runs.

lei_mirror: update fingerprints when writing local manifest.js.gz

We need our local manifest to match the actual data we store,
not what we're mirroring.

lei_mirror: --manifest= affects destination, too

This probably makes the most sense, if a user wants to
use an alternate path to read from, it's likely they
want to write it there, too.

lei_mirror: respect `./' and `../' prefixes for CLI args

Users may wish to keep objstore and manifest files at
a higher level to prevent direct access via HTTP(S),
so those relative paths probably make sense.

lei_mirror: don't warn on missing manifest on initial clone

Users may choose to specify a manifest on the initial clone,
so don't complain if it's missing in that case.

clone: support --keep-going/-k like make(1)

This can be useful for intermittent network errors,
and the required code changes makes it less dependent
on global state.

lei_mirror: avoid needless FD passing

Most git processes we invoke don't care about stdin nor stdout,
so don't waste cycles and memory dealing with it.

stderr passing is added `git config --unset-all remotes.fgrptmp'
invocation, though, since that can fail due to I/O errors or OOM.

clone|fetch: support passing --prune(-tags) to `git fetch'

We need to be able to get rid of removed branches and tags on
the remote.  --prune-tags is implied for non-objstore repos,
and incompatible with objstore repos.

clone: canonicalize destination path from CLI

We'll probably save the destination path somewhere, so
ensure the path doesn't have redundant slashes and such

lei_mirror: delay configuring forkgroups

When relying on `public-inbox-clone --manifest=', idempotent
`git config' invocations can take a considerable amount of
time.  We still configure inboxes idempotently since it
allows quickly changing URLs to mirrors, but we just defer
it until an update is actually needed.

clone: support loading manifest.js.gz from destination

This will allow us to quickly check fingerprints against
remotes with a single HTTP(S) request, saving us numerous
`git show-refs' invocations.

lei_mirror: check fingerprints before fetching

While we currently don't check an existing on-disk manifest,
using `git show-ref' can still save us precious network traffic.

lei_mirror: support resuming multi-repo clones

This is actually a combination of clone and fetch, and I don't
think `public-inbox-fetch' will be used to update multiple git
repos (inbox or not).

Our use of `git update-ref --stdin -z' was broken for
incremental updates, but now fixed to properly NUL-terminate
commands.

on_destroy: support ->cancel callback

We probably use this idiom elsewhere, but having this method
around to make future use cases more readable is probably prudent.

lei_mirror: show child error error code

Just passing the exit value of the child process isn't to
our parent process isn't very useful when multiple commands
are failing at once.

lei_mirror: properly pack-refs in non-forkgroup repos

We need to ensure `git update-ref --stdin' is complete
before running `git pack-refs', otherwise loose refs can
remain while update-ref is still running.

fetch: eliminate File::Temp->filename var

File::Temp objects are overloaded to automatically
call ->filename when stringified, so there's no need
to store the ->filename result on the Perl stack.

fetch: use v5.12

Another tiny step towards improved startup performance by
avoiding one .pm file.

lei_mirror: shorten remote names

The lengthy-but-human-meaningful remote names are more expensive
at runtime and increase packed-refs space.

clone: require `--objstore=' for default location

Allowing just `--objstore' without `=' was confusing,
since it could eat one of the required parameters (URL or
DESTINATION).

clone: use v5.12

Another small step in what will probably a be a decades-long
quest to reduce startup time by a few milliseconds.

clone: drop unnecessary requires

These packages are all require-ed elsewhere.

clone: move --dry-run handling to lei_mirror

lei will probably support dry-run in more places, too.

lei_mirror: forkgroups use `git fetch --multiple'

This offloads network parallelization and safety off to git
itself while reducing the amount of unnecessary process spawning
we do.  This also improves readability of pack-refs invocations
and reduces the need for them.

To prevent heavily-forked repos from hitting system command-line
size limits, we group refs to be updated in the "fgrptmp" group.

lei_mirror: fix --dry-run for forkgroups

We must not make permanent changes to the FS if --dry-run is in use.

lei_mirror: make basename more descriptive

This makes it easier for humans to distinguish between
"Alice/project.git" and "Bob/project.git"

lei_mirror: drop git <1.8.5 support

Supporting git <1.8.5 via fetch on non-forkgroup repos would
make auto-GC dangerous, and I want to support auto-GC instead
of relying on the preciousObjects extension.

Since git 1.8.5 is 9 years old at this point, and grokmirror
(used by the only CentOS 7.x user I know of) already relies on
newer git, simplify our code and only fetch into forkgroups.

lei_mirror: do not show ref updates w/o --verbose

It's too noisy IMHO, and UIs are always opinionated.

lei_mirror: preserve permissions of existing alternates file

We don't want to be clobbering permissions when changing to
relative paths.  Furthermore, we can avoid writing to the
alternates file if there are no changes.

lei_mirror: force --no-tags when fetching forkgroups

We can't have multiple remotes writing to refs/tags/*
(instead of refs/remotes/*/tags) due to potential conflicts.

lei_mirror: set description for non-inboxes, too

We can still set $GIT_DIR/description when cloning coderepos with
--inbox-config=never

lei_mirror: always pack refs for coderepos

Unlike object packing, ref packing is cheap and fast.

clone: flesh out --objstore behavior and document

We can support absolute paths to avoid surprising behaviors,
but relative paths are preferred since the goal is to be
accessible over the "dumb" HTTP git transport (the dumb
transport is uses less memory and CPU on the server).

lei_mirror: ensure git <1.8.5 fallback can use torsocks

Since we fall back to `git fetch' on versions of git without
`git update-ref --stdin' support, we must also support
torsocks use on Tor .onion URLs

lei_mirror: cleanup process reaping logic

We can put more of the default --jobs logic and loop handling
inside a sub to simplify callers.

lei_mirror: support --objstore and forkgroups

The {forkgroup} directive of grokmirror 2.x manifest.js.gz
can facilitate more space savings and improved pack performance
with pack.islands.

lei_mirror: simplify clone_v2_prep

Since everything relies on the instance-specific {todo} queue,
there's no need to have sub-specific queues.

lei_mirror: avoid convoluted lazy_cb usage

lazy_cb should only be used for lei command dispatch and
completion callbacks when the method isn't known at startup.
There's zero reason to use it when the method is known
ahead-of-time, especially when there's a comment pointing
reviewers towards the only possible method it can dispatch.

lei_mirror: hoist out dump_manifest sub

We can reuse it in PublicInbox::Fetch, too.

lei_mirror: do not write Makefile for --inbox-config=never

We want to be able to clone non-inbox git repos, too.

lei_mirror: add `index' target to generated Makefile

It can probably be a useful hint to avoid misleading users
into always using `--reindex'.

lei_mirror: cleanup File::Temp OO usage

There's no need to capture or rely on the File::Temp->filename
in most cases since most Perl functions accept file handles all
the same.

lei_mirror: ensure curl exits 22 on HTTP 404 responses

Oops, this is actually a long-standing bug :x

lei_mirror: require Perl v5.12+

Another tiny step towards improve startup performance by
relying on Perl 5.12 strictness and avoiding strict.pm

clone: support --inbox-version

This is part of `lei add-external --mirror', and it makes
sense to have for development and testing.  We'll also add
a fallback in case somebody tries --inbox-version and fails
due to a newer remote instances of public-inbox.

lei_mirror: simplify v2 code paths

We can simply reuse the parallelization of the manifest
code path for non-manifest v2 clones, now.

lei_mirror: support manifest {references} for v2 epochs

This may be useful in case a v1 inbox gets forked into v2
(untested).

lei_mirror: differentiate -entv vs -ent

It makes the code easier-to-follow when we have a single
versus multiple entities (`v' for vector, à la `argv').

lei_mirror: fix glob semantics to match end-of-path

Globs such as `*/foo' should not match `*/foobar',
this allows cloning only `git' and not
`gitolite-transparency-log` off lore

lei_mirror: require PublicInbox::Lock at use

It's easier to understand why we lazy-load Lock for v2-only
code paths when we require it near its first use.

lei_mirror: do not fetch descriptions if using manifest

If a manifest exists, we can expect the description to always be
present, thus there's no need to make a separate HTTP(S) request
since we can use it as-is from the manifest for v1||coderepos
and strip / \[epoch [0-9]+\]\z/ from v1.

lei_mirror: defend against infinite loops

A reference chain of 1000 ought to be enough, I think...

lei_mirror: fix infinite loop in dependency resolution

We need to account for dependencies which are marked `done'.