The fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=484446
reimplemented InputStreamResponseListener using callbacks rather than
blocking waits.
However, HTTP/2 behaves a little differently than HTTP/1.
Where in HTTP/1 until the callback was completed no further calls to
onContent() were made, with HTTP/2 additional calls are made until
the flow control window is exhausted.
For this reason InputStreamResponseListener must queue content chunks
rather than dealing only with one chunk at a time.
Introduced ClientConnectionFactory.customize() to look for
Connection.Listener beans.
ClientConnectionFactory implementation calls customize() when they
create a Connection instance, so the Connection.Listener beans are
registered onto the Connection.
Made sure that the idle timeout mechanism notifies the destination
that the connection will close.
Also reviewed the close protocol to be: notify destination, then abort,
then close. In this way, HTTP/2 can send RST_STREAM before the
connection is closed.
Improved fix, notifying the response.success event using a
CompletableCallback to avoid that HttpReceiver.responseContent()
fails the update from ResponseState.TRANSIENT.
Added guard to avoid that the idle timeout expires just before
sending the request.
Reworked the way idle timeouts are handled, to support the case where
the idle timeout just expired and the request can be tried on a
different connection/channel.
Fixed by reworking how ClientConnectionFactories are handled by both
HTTP2Client and by HttpClientTransportOverHTTP2, to avoid that the
latter wraps the nested factories with SslConnection twice.
HttpInput was using a bounded ArrayQueue with max capacity 64.
The queue was overflowing if there were more than 64 reads within the
flow control window capacity.
Fixed by replacing the ArrayQueue with ArrayDeque, which is unbounded.
The client connection's promise was succeeded in the context of a
call to SelectorManager.newConnection().
This was wrong, since succeeding the promise may trigger the send
of a request *before* the connection is actually linked to the
endPoint and opened.
This change moves the succeeding of the client connection's promise
to the connection onOpen() method.
Simone Bordet
Greg Wilkins
Joakim Erdfelt
Greg Wilkins