Support for the PROXY protocol is now enabled via 2 new modules:
proxy-protocol and proxy-protocol-ssl, respectively for the HTTP
connector and the SSL connector.
Changed HTTPServerConnection to return a Runnable to be run by the
execution strategy also in case of content.
This allows onDataAvailable() to be called at the proper times.
Ported the "maxAssociations" functionality from SPDY's ReferrerPushStrategy.
Added JMX support.
Removed __renew__ special path in favour of a JMX method.
Added clearPushCache() JMX method.
Made push reentrant by eliminating the check for "org.eclipse.jetty.pushed".
Before, the sender was updating the window size after the SETTINGS
frame was written.
This was leading to a race where the receiver saw the updated window
size and sent DATA frames; these were received by the original sender
before it had the chance to update its local window size, causing an
error.
Now, the update of the window size happen just before writing the
SETTINGS frame to avoid this race.
Testing for stream.isClosed() is done in StreamCloseTest.
The tests were failing because receiving the headers does not mean
the sending the headers has notified the callback yet, and hence
closed the stream.
Fixed by tracking both send and recv initial stream windows.
This is needed because both client and server may send an
INITIAL_WINDOW_SIZE setting, and they must be treated
separately.
Naked writes could throw WritePendingException.
Now we wait until the client has finished sending the reply to the
server SETTINGS frame, then we do the naked write.
Now the stream close state is updated when the frame has been
successfully written, and when it is received.
The stream is closed in case of failures.
Just after the stream close state update, if the stream is closed
then it is removed from the session.
It is not possible to perform asynchronous processing of the content
of DATA frames, because otherwise the parser has to stop, stalling
all other streams.
Parser.Listener methods were returning boolean in a vestigial attempt
to handle asynchronous data processing, and have now been converted to
return void.
Introduced parameter "dispatchIO" in the relevant factories so that
they can be configured by users and connections will be created
taking into account this parameter.
For less configurable connection factories, this parameter is
currently hardcoded to either true or false depending on the case.
For example, ALPN and NPN connections have it to false, since they
don't do any blocking operation in onFillable().
Fixed by ensuring that when a failure happens, either by catching an
exception or by failing a callback, we always call completed() and
abort the channel (via new method terminate()).
Introduced ResetException, and using it when failing frames of streams
that have been reset already.
HttpTransportOverHTTP2.abort(Throwable) checks for this exception and
does not close the connection.
A PushCacheFilter contains the logic to associate secondary resources
to primary resources.
PushCacheFilter calls a Jetty-specific API on the request dispatcher:
Dispatcher.push(ServletRequest). This is a technology preview of the
push functionality slated for Servlet 4.0.
The push() invocation arrives to the transport and it is converted to
HTTP/2 specific PUSH_PROMISE, along with the mechanism to simulate
the request for the secondary resource.
It's now sent after a call to onPreface(), which has been moved to
the common interface Session.Listener (from ServerSession.Listener),
so that client applications can customize the SETTINGS to send to the
server.
Flow control window updates are now processed by the flusher, so that
it is the only component that handles window updates.
In the process of this refactoring, HTTP2Flusher was refactored out
of HTTP2Session.
There is a difference between the value set via configuration, that
always refer to remote streams (streams initiated by remote peers),
and the value received via SETTINGS frame, that always refer to local
streams (streams initiated locally).
This refactor strives to remove duplication between the Metadata class and the HttpURI class.
Both classes have been made mutable (as they partially were anyway so best not to pretend).
HttpURI now holds the decomposed strings rather than a single string with indexes. This allows it to be rebuilt after changing just parts of the URI. It is now a lot more similar to the
JVM URI class and we could consider replacing it (after checking peformance).
Next step is to refactor the Request class to prevent it duplicating these fields.
Jesse McConnell
Simone Bordet
Joakim Erdfelt
Greg Wilkins
Greg Wilkins