Top Inners Fields Constructors Methods
org.eclipse.jetty.http2

public abstract Class HTTP2Session

extends ContainerLifeCycle
implements Session, Listener
Class Inheritance
All Implemented Interfaces
org.eclipse.jetty.http2.parser.Parser.Listener, org.eclipse.jetty.http2.api.Session
Annotations
@ManagedObject
Imports
java.io.IOException, java.net.InetSocketAddress, .SocketAddress, java.nio.channels.ClosedChannelException, java.nio.charset.StandardCharsets, java.util.ArrayDeque, .ArrayList, .Collection, .Collections, .Iterator, .List, .Map, .Queue, java.util.concurrent.CompletableFuture, .ConcurrentHashMap, .TimeoutException, java.util.concurrent.atomic.AtomicInteger, .AtomicLong, java.util.function.Consumer, .Predicate, java.util.stream.Collectors, org.eclipse.jetty.http.MetaData, org.eclipse.jetty.http2.api.Session, .Stream, org.eclipse.jetty.http2.frames.DataFrame, .FailureFrame, .Frame, .FrameType, .GoAwayFrame, .HeadersFrame, .PingFrame, .PrefaceFrame, .PriorityFrame, .PushPromiseFrame, .ResetFrame, .SettingsFrame, .StreamFrame, .WindowUpdateFrame, org.eclipse.jetty.http2.generator.Generator, org.eclipse.jetty.http2.hpack.HpackEncoder, .HpackException, org.eclipse.jetty.http2.internal.HTTP2Flusher, org.eclipse.jetty.http2.parser.Parser, org.eclipse.jetty.io.ByteBufferPool, .CyclicTimeouts, .EndPoint, .WriteFlusher, org.eclipse.jetty.util.AtomicBiInteger, .Atomics, .Callback, .CountingCallback, .MathUtils, .NanoTime, .Promise, org.eclipse.jetty.util.annotation.ManagedAttribute, .ManagedObject, org.eclipse.jetty.util.component.ContainerLifeCycle, .DumpableCollection, org.eclipse.jetty.util.thread.AutoLock, .Invocable, .Scheduler, org.slf4j.Logger, .LoggerFactory

Nested and Inner Type Summary

Modifier and TypeClass and Description
private class
HTTP2Session.ControlEntry

private class
HTTP2Session.DataEntry

public abstract static class
HTTP2Session.Entry

private class
HTTP2Session.OnResetCallback

private class
HTTP2Session.StreamsState

The HTTP/2 specification requires that stream ids are monotonically increasing, see RFC 7540, 5.1.1.

private class
HTTP2Session.StreamTimeouts

Field Summary

Modifier and TypeField and Description
private final AtomicLong
bytesWritten

private boolean
connectProtocolEnabled

private final EndPoint
endPoint

private final FlowControlStrategy
flowControl

private final HTTP2Flusher
flusher

private final Generator
generator

private int
initialSessionRecvWindow

private final AtomicInteger
lastRemoteStreamId

private final Session.Listener
listener

private final AtomicInteger
localStreamCount

private final AtomicInteger
localStreamIds

private static final Logger
LOG

Hides org.eclipse.jetty.util.component.ContainerLifeCycle.LOG.

private int
maxEncoderTableCapacity

private int
maxLocalStreams

private int
maxRemoteStreams

private final Parser
parser

private boolean
pushEnabled

private final AtomicInteger
recvWindow

private final AtomicBiInteger
remoteStreamCount

private final AtomicInteger
sendWindow

private long
streamIdleTimeout

private final Map<Integer, HTTP2Stream>
streams

private final AtomicLong
streamsClosed

private final AtomicLong
streamsOpened

private final HTTP2Session.StreamsState
streamsState

private final HTTP2Session.StreamTimeouts
streamTimeouts

private int
writeThreshold

Constructor Summary

AccessConstructor and Description
public
HTTP2Session(Scheduler scheduler, EndPoint endPoint, Parser parser, Generator generator, Session.Listener listener, FlowControlStrategy flowControl, int initialStreamId)

Method Summary

Modifier and TypeMethod and Description
protected void
abort(String reason, Throwable failure, Callback callback)

public boolean
close(int
the error code
error, String
the reason
reason, Callback
the callback to invoke when the operation is complete
callback)

Implements org.eclipse.jetty.http2.api.Session.close.

Invoked internally and by applications to send a GO_AWAY frame to the other peer.

private void
configure(Map<Integer, Integer> settings, boolean local)

private void
control(HTTP2Stream stream, Callback callback, Frame frame)

protected HTTP2Stream
createLocalStream(int streamId, MetaData.Request request, Consumer<Throwable> failFn)

protected HTTP2Stream
createRemoteStream(int streamId, MetaData.Request request)

public void
data(HTTP2Stream stream, DataFrame frame, Callback callback)

pack-priv void
dataConsumed(HTTP2Stream stream, int length)

public void
disconnect()

protected void
doStop()

Overrides org.eclipse.jetty.util.component.ContainerLifeCycle.doStop.

Stops the managed lifecycle beans in the reverse order they were added.

public void
dump(Appendable
The appendable to dump to
out, String
The indent to apply after any new lines.
indent)

Overrides org.eclipse.jetty.util.component.ContainerLifeCycle.dump.

Implements org.eclipse.jetty.util.component.Dumpable.dump.

Dump this object (and children) into an Appendable using the provided indent after any new lines.

private void
failStream(Stream stream, int error, String reason, Throwable failure, Callback callback)

private void
failStreams(Predicate<Stream> matcher, String reason, boolean reset)

private void
frame(HTTP2Session.Entry entry, boolean flush)

public void
frames(HTTP2Stream stream, List<? extends Frame> frames, Callback callback)

public long
getBytesWritten()

public CloseState
getCloseState()

public EndPoint
getEndPoint()

public FlowControlStrategy
getFlowControlStrategy()

public Generator
getGenerator()

public int
getInitialSessionRecvWindow()

protected int
getLastRemoteStreamId()

public InetSocketAddress
getLocalAddress()

Implements org.eclipse.jetty.http2.api.Session.getLocalAddress.

public SocketAddress
getLocalSocketAddress()

Overrides default org.eclipse.jetty.http2.api.Session.getLocalSocketAddress.

public int
getMaxEncoderTableCapacity()

public int
getMaxLocalStreams()

public int
getMaxRemoteStreams()

public Parser
getParser()

public int
getRecvWindow()

public InetSocketAddress
getRemoteAddress()

Implements org.eclipse.jetty.http2.api.Session.getRemoteAddress.

public SocketAddress
getRemoteSocketAddress()

Overrides default org.eclipse.jetty.http2.api.Session.getRemoteSocketAddress.

public int
getSendWindow()

public HTTP2Stream
getStream(int
the stream id of the stream looked for
streamId)

Implements org.eclipse.jetty.http2.api.Session.getStream.

Retrieves the stream with the given streamId.

public int
getStreamCount()

public long
getStreamIdleTimeout()

public Collection<Stream>
getStreams()

Implements org.eclipse.jetty.http2.api.Session.getStreams.

public long
getStreamsClosed()

public long
getStreamsOpened()

public int
getWriteThreshold()

public boolean
goAway(GoAwayFrame frame, Callback callback)

protected static boolean
isClientStream(int streamId)

public boolean
isClosed()

Implements org.eclipse.jetty.http2.api.Session.isClosed.

public boolean
isConnectProtocolEnabled()

public boolean
isDisconnected()

private boolean
isLocalStream(int streamId)

protected boolean
isLocalStreamClosed(int streamId)

public boolean
isPushEnabled()

Implements org.eclipse.jetty.http2.api.Session.isPushEnabled.

protected boolean
isRemoteStreamClosed(int streamId)

private boolean
isStreamClosed(int streamId)

private HTTP2Session.Entry
newEntry(Frame frame, HTTP2Stream stream, Callback callback)

private GoAwayFrame
newGoAwayFrame(int error, String reason)

private GoAwayFrame
newGoAwayFrame(int lastRemoteStreamId, int error, String reason)

public void
newStream(HeadersFrame
the HEADERS frame containing the HTTP headers
frame, Promise<Stream>
the promise that gets notified of the stream creation
promise, Stream.Listener
the listener that gets notified of stream events
listener)

Implements org.eclipse.jetty.http2.api.Session.newStream.

Sends the given HEADERS frame to create a new Stream.

public void
newStream(HTTP2Stream.FrameList frames, Promise<Stream> promise, Stream.Listener listener)

protected HTTP2Stream
newStream(int streamId, MetaData.Request request, boolean local)

public Stream
newUpgradeStream(HeadersFrame
the HEADERS frame that triggered the stream creation allocated stream id, or null if not interested in the modified headers frame
frame, Stream.Listener
the listener that gets notified of stream events
listener, Consumer<Throwable> failFn)

Creates a new stream allocating a stream id if the given HEADERS frame does not have one.

private void
notIdle()

protected void
notifyClose(Session session, GoAwayFrame frame, Callback callback)

protected void
notifyFailure(Session session, Throwable failure, Callback callback)

protected void
notifyGoAway(Session session, GoAwayFrame frame)

protected boolean
notifyIdleTimeout(Session session)

protected Stream.Listener
notifyNewStream(Stream stream, HeadersFrame frame)

protected void
notifyPing(Session session, PingFrame frame)

protected void
notifyReset(Session session, ResetFrame frame)

protected void
notifySettings(Session session, SettingsFrame frame)

public void
onConnectionFailure(int error, String reason)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onConnectionFailure.

public void
onData(DataFrame frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onData.

public void
onData(Stream.Data data)

private void
onFailure(int error, String reason, Throwable failure, Callback callback)

public void
onFlushed(long bytes)

public void
onFrame(Frame frame)

public void
onGoAway(GoAwayFrame
the GO_AWAY frame that has been received.
frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onGoAway.

This method is called when receiving a GO_AWAY from the other peer.

public abstract void
onHeaders(HeadersFrame frame)

Redeclares as abstract: org.eclipse.jetty.http2.parser.Parser.Listener.onHeaders.

public boolean

Returns:

true if the session should be closed, false otherwise
onIdleTimeout()

This method is invoked when the idle timeout expires.

public void
onPing(PingFrame frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onPing.

public void
onPriority(PriorityFrame frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onPriority.

public void
onReset(ResetFrame frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onReset.

protected void
onResetForUnknownStream(ResetFrame frame)

private void
onSessionFailure(int error, String reason, Callback callback)

public void
onSettings(SettingsFrame frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onSettings.

public void
onSettings(SettingsFrame frame, boolean reply)

public void
onShutdown()

This method is called when the TCP FIN is received from the remote peer.

private void
onStreamClosed(Stream stream)

private void
onStreamCreated(int streamId)

private void
onStreamDestroyed(int streamId)

public void
onStreamFailure(int streamId, int error, String reason)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onStreamFailure.

protected final void
onStreamOpened(Stream stream)

public void
onWindowUpdate(WindowUpdateFrame frame)

Overrides default org.eclipse.jetty.http2.parser.Parser.Listener.onWindowUpdate.

public void
onWindowUpdate(HTTP2Stream stream, WindowUpdateFrame frame)

public void
onWriteFailure(Throwable failure)

public void
ping(PingFrame
the PING frame to send
frame, Callback
the callback that gets notified when the frame has been sent
callback)

Implements org.eclipse.jetty.http2.api.Session.ping.

Sends the given PING frame.

public int
priority(PriorityFrame
the PRIORITY frame to send
frame, Callback
the callback that gets notified when the frame has been sent
callback)

Implements org.eclipse.jetty.http2.api.Session.priority.

Sends the given PRIORITY frame.

public void
push(Stream stream, Promise<Stream> promise, PushPromiseFrame frame, Stream.Listener listener)

public boolean
removeStream(Stream stream)

pack-priv void
reset(HTTP2Stream stream, ResetFrame frame, Callback callback)

pack-priv void
scheduleTimeout(HTTP2Stream stream)

public void
setConnectProtocolEnabled(boolean connectProtocolEnabled)

public void
setInitialSessionRecvWindow(int initialSessionRecvWindow)

public void
setMaxEncoderTableCapacity(int maxEncoderTableCapacity)

public void
setMaxLocalStreams(int maxLocalStreams)

public void
setMaxRemoteStreams(int maxRemoteStreams)

public void
setStreamIdleTimeout(long streamIdleTimeout)

public void
settings(SettingsFrame
the SETTINGS frame to send
frame, Callback
the callback that gets notified when the frame has been sent
callback)

Implements org.eclipse.jetty.http2.api.Session.settings.

Sends the given SETTINGS frame to configure the session.

public void
setWriteThreshold(int writeThreshold)

public CompletableFuture<Void>
shutdown()

Implements org.eclipse.jetty.http2.api.Session.shutdown.

Gracefully closes the session, returning a CompletableFuture that is completed when all the streams currently being processed are completed.

private void
terminate(Throwable cause)

private Throwable
toFailure(int error, String reason)

public String
toString()

Overrides org.eclipse.jetty.util.component.AbstractLifeCycle.toString.

Returns a string representation of the object.

protected void
updateLastRemoteStreamId(int streamId)

public int
updateRecvWindow(int delta)

public int
updateSendWindow(int delta)

pack-priv void
updateStreamCount(boolean local, int deltaStreams, int deltaClosing)

Inherited from org.eclipse.jetty.util.component.ContainerLifeCycle:
addBeanaddBeanaddEventListeneraddManagedcontainsdestroydoStartdumpdumpdumpObjectsdumpStdErrgetBeangetBeansgetBeansgetContainedBeansgetContainedBeansisAutoisManagedisUnmanagedmanageremoveBeanremoveBeansremoveEventListenersetBeansstartstopunmanageupdateBeanupdateBeanupdateBeansupdateBeans