Update some deprecated usages
Refactored some names for clarity

The connection-level http2 pipelines are almost identical between client
and server, because they're just setting up the frame codec and the
multiplex handler.

Created top-level server pipeline building fns
Refactored out executor setup fns

Netty has an optimized formatter
Keeps 1s scheduled executor updates

Bumped up Netty to 4.1.96

If `continue-executor` is same as main executor .shutdown gets called
twice. Probably harmless, but also pointless.

Switch to `common/date-header-value` for HTTP/1

pipeline and handler now part of opts map

`ring-map->netty-http2-headers` now handles both requests and responses
correctly.

Use AsciiString/String consistently when comparing
Remove unneeded null check for header values (Netty will do it)
Updated add-header docstring

Add add-exception-handler to common to log exception that make it to the
end of the pipeline.
Rename attach-idle-handlers to add-idle-handlers to match the rest of
the system.
Move error-response and invalid-value-exception to common ns

Hint ssl-handler with SslHandler, not ChannelHandler
Hint coerce-ssl-context with SslContext

Fix SSL test when using BoringSSL

`keyword` doesn't work with CharSequences

Basic GET/HEAD requests work

Bump byte-streams to 0.3.4

Raise io.netty.util log level. It generates a lot of distracting logs.

Instead of automatically closing, make final error handler in charge,
if it exists.

If not, continue to fire exception along pipeline. (Preferable to closing?)

Now uses succinct AS"some string" format

Since both Channels and ChannelHandlerContext inherit from
ChannelOutboundInvoker, use that for the type hint, instead of manually
checking class ourselves.

Next: inline

Meant to be final exception handler in a pipeline. No point in
propagating further, just results in Netty logging.

…o true

If the channel closed unexpectedly, set complete to true to tell client
to dispose of the connection.

Parse response status
Check for mandatory pseudo-headers

As of Netty 4.1.96, the presence of mandatory pseudo-headers doesn't
seem to be checked, just their values, when present.

Replace with writable? and h2-exception. complete is needed for client,
not server.

writable? is checked before calling send-response

Support user-supplied go-away-handler and reset-stream-handler
Set writable? false when called.
Do not propagate event further.
Extract out handle-shutdown-frame

Add goaway and reset handlers for client
Set status to 200 if missing, for backwards-compatibility with http1 code

Refactor out common goaway/reset code

Re-enable request header validation

Move http2-client-handler to http2 ns

Too many params, switched to map

When aleph-error-handler (and .exceptionCaught) are called, now tries to
send a 400 response before sending RST_STREAM.

By calling close on th conn channel, GOAWAYs are sent, but without
regard to any associated H2 error codes.

Add reset-stream fn

Add netty/write-fut that returns a promise. By default, netty/write uses
a void promise for speed.

Rename send-http-error-response -> write-http-error-response, and have
it return promise

Theoretically better for flow control

Replaced with write-simple-http-mesg
Made body-text/error message optional

Fixed status parsing bug when :aleph/response-status was set to nil

Caused by using http/request directly and not using *pool*

Add max-size-handler

Moves the sleep from the body to before the return of the Ring map.

Unlike the HTTP1 code, the H2 code can respond as soon as it gets a
header, which prevents the request timeout from triggering.

Also adds a 1.5s delay to server shutdown, so repeating tasks like
(date-header-value) can finish and not throw exceptions.

Fix circular ns issue
Not just applicable to HTTP, anyway

Update the client :channel-inactive method in H2 to set the response-d
to closed, in order to mimic HTTP1 behavior

In HTTP1 code, when the client channel is closed, it closes the responses
stream, which leads the take! to get ::closed.

Also replace ::closed with :aleph/closed, so it can be used in other nses

Trying to close an already-closed channel on the client-side caused an
exception, when it should be idempotent.

The HTTP2 code didn't use the :on-closed callback like the HTTP1 code
did. As a result, closed connections weren't automatically being
disposed of in the connection pool, but reused, which leads to immediate
failures.

The HTTP1 code attached the on-closed cb to the responses stream, but H2
doesn't need a stream. The code now attaches the close cb to the Netty
Channel's close Future. This should be safe, tho there may be some churn
in Dirigiste.

(Also realiased confusing aleph.ssl in tests to test-ssl)

Remove nonexistent :socket-timeout option in tests
Add Channel id to print output
Add TODOs
Increase io.netty.channel logging level to warn
Add more tracing

Some tests are very specific to either HTTP1 semantics or Aleph's HTTP1
implementation.

Also add common/ssl-ctx-supports-http2? fn

Targets public 0.4.6 vars

Does not support netty/headers

HTTP1's HeaderMap enabled the use of keywords and case-insensitivity for
header retrieval (but not assoc/dissoc).

This copies HeaderMap to the HTTP2 code base. Unfortunately, Netty's
HTTP1 header class is outside the later Header hierarchy, and can't be
shared.

Ensures HeaderMap always returns a String value

Fix bug where get-all and extract-cookies-from-response-headers were
HTTP1-only

Fix bug where AsciiString's broke retrieval when passed to `name`

Remove unneeded netty-http2-headers->map

Also HeadersMap is 5x faster than prev H2 solution

Required to compile support for them

Add AsciiString-aware str= equality fn

H2 compression is not well-supported by Netty for its multiplex setup,
only its older single-pipeline H2 classes.

It happens in two parts: (1) decorators are attached to the
Http2FrameCodec that handle the actual de/compression, and (2) a handler
that parses and updates the *-encoding headers is added to each stream
pipeline.

Adds new `compression-options` for both H1/H2, and deprecates
`compression-level` to H1-only, like Netty.

Add a Lein profile for performance testing. Just clj-async-profiler for
now, but should support more libs in the future

Rebase failed, too divergent

Broke validate-http1-pipeline-xform

Ensure tests can always override default options

The Clojure compiler cannot distinguish between static methods and fields
without reflection. This causes ClassNotFoundExceptions when loading
Netty's StandardCompressionOptions class, even if optional code paths
are guarded.

Add AlephCompressionOptions, a class that exists solely to relay calls
to StandardCompressionOptions without triggering CNFEs.