All this will do as of this commit are simple metagets, ie:
mg /foo/a t v

...and only for small responses.

This turns memcached into what will be a full featured proxy. Full
writeup of what that entails will live in the PR on github.

Does not include vendored files. requires:
vendor/lua (lua 5.4.0 from public tarball)
vendor/mcmc (from https://github.com/dormando/mcmc (or
https://github.com/memcached/mcmc in the future)

also requires a startfile.lua. An empty configuration looks like:

function mcp_config_selectors(oldss)

end

function mcp_config_routes(main_zones)

end

keeping this separate so I can review/re-apply in case I need to do
this rebase again.

no more batched completion :(

Adds a primitive asynchronous wait call, where request "r" is dispatched
against N pools in parallel. An optional number specifies how many
responses to wait for before returning.

Has bugs around edge cases and limited testing as of writing, but does
pass basic tests.

classic C bugs :P doesn't seem to leak now in some limited testing with
mctester.

Taking a simplified first attempt at having fast-failures for backends
that throw errors or time out; IO's will immediately be returned for
these backends until they become alive. A background retry is scheduled
until the backend works again.

There are a lot of ways to improve this, some noted in comments, and I
will likely need to move the connect() code anyway, so doing that as a
later change.

if replacing existing user stats, would crash. think broke during a
refactor; need more integration tests :)

timing is a little tough; not a lot of places to stick the time start vs
time end for the log. gives a raw timing of microseconds.

also need to follow up with having a response inherit some details about
the request (type?) and translate the response type/code to something
useful... but starting with this.

This commit changes:
 - add --enable-proxy-uring option, which looks for a compiled liburing
   in vendor/liburing
 - change backend drive_machine() to remove syscalls so it can be a
   common code path between libevent and uring
 - add basic liburing support for the backend read path. writes to
   backends still use normal syscalls and will be optimized later

The structure will need to change to meter out *sqe's more carefully,
but it should be impossible to trip the exhaustion condition so this is
fine for now.

The mcmc code did not make this easy, drive_machine() has turned into a
bit of a mess. I need to flatten that out to allow avoiding memmove's
and make the code clearer. Will come back to it after taking a break
from it...

Uring path is missing some critical code still:
 - backend disconnects
 - bad backend handling/retry
 - timeouts don't exist at all

So it should work for testing in good conditions and I'll add the error
handling during the stabilization phase.

Some uring changes before I forget I wanted to do them, and
update/remove some TODO notes.

some cleanups/changes to the test startfile as well.

plus gets/cas/touch tests.

mostly in the parser + adding tests. no userlib parts yet.

avoid second malloc for lua request objects by requesting some extra
space.

generate a bitfield of flags generically to allow later flags without
breaking code.

when looking for arguments to flags from the API, we will have to
re-scan the string, which usually very short anyway.

hasn't made sense for a long time now. distribution and hash functions
are abstract from the pool.

in preparation of adding a few more common options.

hash_selectors are now pools. I've now separated the concepts:

ketama/jump/etc are considered "key distributors", and can now be
separate from key hashing.

collapse arguments into a single options table. this table gets
passed-through to the distribution function for extra options.

t/startfile.lua has been updated.

rewriting the parser yet again... fixes a bug where parser wasn't
handling spaces around arguments. Simplifies and removes redundancy for
a bunch of the parser code.

Finally, sets up for a simplified API wrapper that simply handles tokens
directly.

*trimkey is a fast routine for clipping part of the key before shipping
the command.
r:token(n) can fetch a token in the nth position.
r:token(n, str) replaces the token at the nth position.

modifications to the tokens are ignored. the next commit should
re-stringify in case of modification.

replace specific tokens in a request with r:token(n, str) command. the
request will be re-serialized when it's being sent to a backend.

also removes errant fprintf.

need to actually parse the flags so we can handle binary-encoded keys.

not used anymore.

https://github.com/memcached/memcached-proxylibs

mcp.backend_connect_timeout()
mcp.backend_retry_timeout()
mcp.backend_read_timeout()

only takes integers. could take a fractional with more work.

these were done / no longer matter.

I'd forget how to breathe if it weren't automatic.

clears up an automake error. need a for-real makefile or to turn mcmc
into a header. Think I like the idea of it being a header actually?

will print the original request command name. we can't toss the
key/anything useful as requests are not pinned to responses. I can think
of better approaches but they require more clever code so I'm not doing
it now.

can handle flat routing (pools and such) and multi-zones

flat routing is probably fine, zones needs more work for production.

thinking I'll end up moving this script to the proxylibs repo... but
vendor it on releases.

instead of just erroring.

when not configured, again. also cleans up a bit from a TODO note.

--proxy_config=./datafile.lua is now the calling convention. the
datafile loads the library which defines globals for the proxy to run.

https://github.com/memcached/memcached-proxylibs

lua is external.. mcmc is inlined, at least for now.

extra step for proxy builders.

I need to spend some time learning this properly, but I need it to work
in the meantime... So using a proxy makefile to build things.

"make dist" does actually work now, but not unless you "make clean"
first. it'll add junk because the make dist recursion happens after the
EXTRA_DIST copies files in.

I'll fix this another time. since it's mostly me building tarballs I'll
just try to not screw it up until fixed.