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

lei_mirror: allow --epoch on mixed v1/v2 clones

It's entirely possible an instance will have both v1 and v2
inboxes (or v2 inboxes and coderepos).  Don't punish --epoch
users by forcing them to run multiple commands.

lei_mirror: reduce scope of v2 lock

Guarding against parallel clones isn't realistic, really, only
setting up all.git, and even then, I'm not 100% sure the lock
is useful.

lei_mirror: retrieve v2 description properly

clone: support --inbox-config option

This allows avoiding 404s when trying _/text/config/raw on code
repositories.

lei_mirror: reduce noise on interrupted clones

We don't need git-config or other commands failing loudly.
`git clone' and subcommands it spawns may still spew, but it's no
worse than interrupting `git clone' itself, now.

We accomplish this by localizing $LIVE (formerly %LIVE) and
detecting when its auto-vivification into a hashref goes
out-of-scope during the `DESTRUCT' ${^GLOBAL_PHASE}.

We can't use ${^GLOBAL_PHASE}, yet, either, since it appeared in
Perl 5.14 and we're still migrating slowly to Perl 5.12 before
going to 5.14.

lei_mirror: support {reference} for v1 manifest clones

This will be generalized to v2, as well.

lei_mirror: initialize placeholders with "head" from manifest

This only affects v2 epochs, but ensures our bases are covered,
at least.  We'll have to update PublicInbox::Fetch later to
deal with "head" entries in manifest.js.gz, too.

clone: support --dry-run / -n flag

It still makes HTTP(S) requests to retrieve the manifest or
scrape HTML, but doesn't make permanent changes to the FS
(aside from modifying {acm}time of ${TMPDIR-/tmp}).

lei_mirror: set gitweb.owner from manifest

This is mainly for coderepos, but sometimes public-inboxes
get shared via cgit/gitweb, too.

lei_mirror: load most modules up-front

lei lazy loads LeiMirror itself lazily, anyways, and it only
supports HTTP(S) mirrors, so there's no point in delaying most
of the modules it loads.  Some of the inbox-specific and
v2-specific stuff can be lazy-loaded, however, since this
will support mirroring non-inbox repositories, too.

lei_mirror: load File::Path unconditionally

File::Temp already uses it, so there's no sense in conditionally
require-ing it to save startup time.

lei_mirror: consolidate clone process management

This simplifies our code by having fewer places check process
limits and perform reaping.  We'll also print command names
immediately before executing, instead of right before waiting
for running processes.

lei_mirror: add a hint for skipped epoch permissions

Some users may think it's git-specific thing to enable
writability, rather than a *nix permissions thing.  Clarify that
it's a standard *nix thing.

lei_mirror: elide description retrieval for v1|coderepo

manifest.js.gz can provide the description without an extra
HTTP(S) requests, so attempt to use it whenever we're using
the manifest.

lei_mirror: simplify _get_txt_start callers

We can avoid needless select()-based sleeps by always
using TMPDIR for temporary files, and just slurping the
small config or description file.

This will make it easier to reuse the description from
the manifest in the next commit.

manifest: update module blurb + v5.12

Helps steer new contributors (or forgetful old ones) in the
right direction.

switch inotify/kevent stuff to v5.12

Another tiny step towards an eventual startup time improvements
by avoiding strict.pm

lei_mirror: retrieve description text asynchronously, too

We can easily parallelize this, so do it.

lei_mirror: move directory creation to v2-only path

We rely on `git clone' to create the destination directory
for v1 and coderepos, so having it in _try_config_start was
senseless.

lei_mirror: default to single job by default

Parallel git clones are expensive on the server-side, and
smaller machines (which we encourage) can't handle them, well.

We'll also set `-q' since parallel clones will have output step
all over each other.

clone: support parallel v1 clones

This opens the door to parallel cloning of coderepos, too.  We
can also get rid of needless AutoReap usage, here, too since
it's usage has been 100% synchronous and not DESTROY-based as
they are in tests.

lei_mirror: rely on global process reaper

We no longer rely on SIGCHLD for predictability, and instead
call waitpid at safe points.  This will make it easier for us to
do parallel mirroring of multiple inboxes while preserving
proper dependencies via ->DESTROY callbacks.

lei_mirror: rely on DESTROY to index v2 inbox

This will give us more freedom in upcoming commits
to ensure indexing only happens after all all epochs
are cloned.

lei_mirror: async config retrieval for v2 w/ manifest

Another step towards being able to minimize mirror time by
supporting parallelization.

clone: parallelize v2 epoch clones

This is a first step in supporting completely parallelized
clones.  Eventually, everything will be parallelized and
dependencies will be managed via callbacks.

clone: support --include and --exclude with multi-clone

These will be handy when someone is interested in a subset of
inboxes on a large hosting site.