Class AbstractH2StreamMultiplexer

java.lang.Object

org.apache.hc.core5.http2.impl.nio.AbstractH2StreamMultiplexer

All Implemented Interfaces:

Closeable, AutoCloseable, HttpConnection, SocketModalCloseable, ModalCloseable, Identifiable

Direct Known Subclasses:

ClientH2StreamMultiplexer, ServerH2StreamMultiplexer

abstract class AbstractH2StreamMultiplexer
extends Object
implements Identifiable, HttpConnection

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) static enum	AbstractH2StreamMultiplexer.ConnectionHandshake
private static class	AbstractH2StreamMultiplexer.Continuation
(package private) class	AbstractH2StreamMultiplexer.H2StreamChannelImpl
(package private) static enum	AbstractH2StreamMultiplexer.SettingsHandshake

Field Summary

Fields

Modifier and Type	Field	Description
private static final long	CONNECTION_WINDOW_LOW_MARK
private final AtomicInteger	connInputWindow
private final BasicHttpConnectionMetrics	connMetrics
private final AtomicInteger	connOutputWindow
private AbstractH2StreamMultiplexer.ConnectionHandshake	connState
private AbstractH2StreamMultiplexer.Continuation	continuation
private EndpointDetails	endpointDetails
private final FrameFactory	frameFactory
private boolean	goAwayReceived
private final HPackDecoder	hPackDecoder
private final HPackEncoder	hPackEncoder
private final HttpProcessor	httpProcessor
private int	initInputWinSize
private int	initOutputWinSize
private final FrameInputBuffer	inputBuffer
private final BasicH2TransportMetrics	inputMetrics
private final ProtocolIOSession	ioSession
private final H2Config	localConfig
private AbstractH2StreamMultiplexer.SettingsHandshake	localSettingState
private int	lowMark
private final FrameOutputBuffer	outputBuffer
private final BasicH2TransportMetrics	outputMetrics
private final Deque<RawFrame>	outputQueue
private final AtomicInteger	outputRequests
private boolean	peerNoRfc7540Priorities
private final Queue<AsyncPingHandler>	pingHandlers
private H2Config	remoteConfig
private AbstractH2StreamMultiplexer.SettingsHandshake	remoteSettingState
private final H2StreamListener	streamListener
private final H2Streams	streams

Constructor Summary

Constructors

Constructor	Description
AbstractH2StreamMultiplexer(ProtocolIOSession ioSession, FrameFactory frameFactory, StreamIdGenerator idGenerator, HttpProcessor httpProcessor, CharCodingConfig charCodingConfig, H2Config h2Config, H2StreamListener streamListener)

Method Summary

Modifier and Type	Method	Description
(package private) abstract void	acceptHeaderFrame()
(package private) abstract void	acceptPushFrame()
(package private) abstract void	acceptPushRequest()
(package private) abstract boolean	allowGracefulAbort(H2Stream stream)
(package private) void	appendState(StringBuilder buf)
private void	applyLocalSettings()
private void	applyRemoteSettings(H2Config config)
void	close()	Closes this connection gracefully.
void	close(CloseMode closeMode)	Closes this process or endpoint and releases any system resources associated with it.
private void	commitFrame(RawFrame frame)
private void	commitFrameInternal(RawFrame frame)
private void	commitHeaders(int streamId, List<? extends Header> headers, boolean endStream)
private void	commitPushPromise(int streamId, int promisedStreamId, List<Header> headers)
private void	consumeContinuationFrame(RawFrame frame, H2Stream stream)
private void	consumeDataFrame(RawFrame frame, H2Stream stream)
private void	consumeFrame(RawFrame frame)
private void	consumeHeaderFrame(RawFrame frame, H2Stream stream)
private void	consumePushPromiseFrame(RawFrame frame, ByteBuffer payload, H2Stream promisedStream)
private void	consumeSettingsFrame(ByteBuffer payload)
(package private) H2StreamChannel	createChannel(int streamId)
(package private) H2Stream	createStream(H2StreamChannel channel, H2StreamHandler streamHandler)
(package private) List<Header>	decodeHeaders(ByteBuffer payload)
private void	executePing(PingCommand pingCommand)
private void	executePush(PushResponseCommand pushResponseCommand)
private void	executeRequest(RequestExecutionCommand requestExecutionCommand)
private void	executeShutdown(ShutdownCommand shutdownCommand)
private void	executeStaleCheck(StaleCheckCommand staleCheckCommand)
(package private) abstract H2Setting[]	generateSettings(H2Config localConfig)
(package private) BasicHttpConnectionMetrics	getConnMetrics()
EndpointDetails	getEndpointDetails()	Returns this connection's endpoint details.
(package private) HttpProcessor	getHttpProcessor()
String	getId()
SocketAddress	getLocalAddress()	Returns this connection's local address or null if it is not bound yet.
ProtocolVersion	getProtocolVersion()	Returns this connection's protocol version or null if unknown.
SocketAddress	getRemoteAddress()	Returns this connection's remote address or null if it is not connected yet or unconnected.
Timeout	getSocketTimeout()	Returns the socket timeout value.
SSLSession	getSSLSession()	Returns this connection's SSL session or null if TLS has not been activated.
(package private) abstract H2StreamHandler	incomingPushPromise(H2StreamChannel channel, HandlerFactory<AsyncPushConsumer> pushHandlerFactory)
(package private) abstract H2StreamHandler	incomingRequest(H2StreamChannel channel)
private void	incrementInputCapacity(int streamId, AtomicInteger inputWindow, int inputCapacity)
boolean	isOpen()	Checks if this connection is open.
private void	maximizeWindow(int streamId, AtomicInteger window)
final void	onConnect()
final void	onDisconnect()
final void	onException(Exception cause)
final void	onInput(ByteBuffer src)
final void	onOutput()
final void	onTimeout(Timeout timeout)
(package private) abstract H2StreamHandler	outgoingPushPromise(H2StreamChannel channel, AsyncPushProducer pushProducer)
(package private) abstract H2StreamHandler	outgoingRequest(H2StreamChannel channel, AsyncClientExchangeHandler exchangeHandler, HandlerFactory<AsyncPushConsumer> pushHandlerFactory, HttpContext context)
private PriorityValue	parsePriorityValue(String field)
private PriorityValue	parsePriorityValue(Header header)
private void	produceOutput()
private void	recordPriorityFromHeaders(H2Stream stream, List<? extends Header> headers)
(package private) void	requestSessionOutput()
void	setSocketTimeout(Timeout timeout)	Sets the socket timeout value.
private int	streamData(int streamId, AtomicInteger streamOutputWindow, ByteBuffer payload)
private void	streamDataFrame(int streamId, AtomicInteger streamOutputWindow, ByteBuffer payload, int chunk)
(package private) void	submitCommand(Command command)
private int	updateInputWindow(int streamId, AtomicInteger window, int delta)
private int	updateOutputWindow(int streamId, AtomicInteger window, int delta)
private int	updateWindow(AtomicInteger window, int delta)
private int	updateWindowMax(AtomicInteger window)
(package private) abstract void	validateSetting(H2Param param, int value)

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

CONNECTION_WINDOW_LOW_MARK

private static final long CONNECTION_WINDOW_LOW_MARK

See Also:

• Constant Field Values

ioSession

private final ProtocolIOSession ioSession

frameFactory

private final FrameFactory frameFactory

httpProcessor

private final HttpProcessor httpProcessor

localConfig

private final H2Config localConfig

inputMetrics

private final BasicH2TransportMetrics inputMetrics

outputMetrics

private final BasicH2TransportMetrics outputMetrics

connMetrics

private final BasicHttpConnectionMetrics connMetrics

inputBuffer

private final FrameInputBuffer inputBuffer

outputBuffer

private final FrameOutputBuffer outputBuffer

outputQueue

private final Deque<RawFrame> outputQueue

hPackEncoder

private final HPackEncoder hPackEncoder

hPackDecoder

private final HPackDecoder hPackDecoder

streams

private final H2Streams streams

pingHandlers

private final Queue<AsyncPingHandler> pingHandlers

connInputWindow

private final AtomicInteger connInputWindow

connOutputWindow

private final AtomicInteger connOutputWindow

outputRequests

private final AtomicInteger outputRequests

streamListener

private final H2StreamListener streamListener

connState

private AbstractH2StreamMultiplexer.ConnectionHandshake connState

localSettingState

private AbstractH2StreamMultiplexer.SettingsHandshake localSettingState

remoteSettingState

private AbstractH2StreamMultiplexer.SettingsHandshake remoteSettingState

initInputWinSize

private int initInputWinSize

initOutputWinSize

private int initOutputWinSize

lowMark

private int lowMark

remoteConfig

private volatile H2Config remoteConfig

continuation

private AbstractH2StreamMultiplexer.Continuation continuation

endpointDetails

private EndpointDetails endpointDetails

goAwayReceived

private boolean goAwayReceived

peerNoRfc7540Priorities

private volatile boolean peerNoRfc7540Priorities

Constructor Details

AbstractH2StreamMultiplexer

AbstractH2StreamMultiplexer(ProtocolIOSession ioSession,
 FrameFactory frameFactory,
 StreamIdGenerator idGenerator,
 HttpProcessor httpProcessor,
 CharCodingConfig charCodingConfig,
 H2Config h2Config,
 H2StreamListener streamListener)

Method Details

getId

public String getId()

Specified by:

getId in interface Identifiable

getConnMetrics

BasicHttpConnectionMetrics getConnMetrics()

getHttpProcessor

HttpProcessor getHttpProcessor()

submitCommand

void submitCommand(Command command)

validateSetting

abstract void validateSetting(H2Param param,
 int value)
                       throws H2ConnectionException

Throws:

H2ConnectionException

generateSettings

abstract H2Setting[] generateSettings(H2Config localConfig)

acceptHeaderFrame

abstract void acceptHeaderFrame()
                         throws H2ConnectionException

Throws:

H2ConnectionException

acceptPushRequest

abstract void acceptPushRequest()
                         throws H2ConnectionException

Throws:

H2ConnectionException

acceptPushFrame

abstract void acceptPushFrame()
                       throws H2ConnectionException

Throws:

H2ConnectionException

incomingRequest

abstract H2StreamHandler incomingRequest(H2StreamChannel channel)
                                  throws IOException

Throws:

IOException

incomingPushPromise

abstract H2StreamHandler incomingPushPromise(H2StreamChannel channel,
 HandlerFactory<AsyncPushConsumer> pushHandlerFactory)
                                      throws IOException

Throws:

IOException

outgoingRequest

abstract H2StreamHandler outgoingRequest(H2StreamChannel channel,
 AsyncClientExchangeHandler exchangeHandler,
 HandlerFactory<AsyncPushConsumer> pushHandlerFactory,
 HttpContext context)
                                  throws IOException

Throws:

IOException

outgoingPushPromise

abstract H2StreamHandler outgoingPushPromise(H2StreamChannel channel,
 AsyncPushProducer pushProducer)
                                      throws IOException

Throws:

IOException

allowGracefulAbort

abstract boolean allowGracefulAbort(H2Stream stream)

updateWindow

private int updateWindow(AtomicInteger window,
 int delta)
                  throws ArithmeticException

Throws:

ArithmeticException

updateWindowMax

private int updateWindowMax(AtomicInteger window)
                     throws ArithmeticException

Throws:

ArithmeticException

updateInputWindow

private int updateInputWindow(int streamId,
 AtomicInteger window,
 int delta)
                       throws ArithmeticException

Throws:

ArithmeticException

updateOutputWindow

private int updateOutputWindow(int streamId,
 AtomicInteger window,
 int delta)
                        throws ArithmeticException

Throws:

ArithmeticException

commitFrameInternal

private void commitFrameInternal(RawFrame frame)
                          throws IOException

Throws:

IOException

commitFrame

private void commitFrame(RawFrame frame)
                  throws IOException

Throws:

IOException

commitHeaders

private void commitHeaders(int streamId,
 List<? extends Header> headers,
 boolean endStream)
                    throws IOException

Throws:

IOException

commitPushPromise

private void commitPushPromise(int streamId,
 int promisedStreamId,
 List<Header> headers)
                        throws IOException

Throws:

IOException

streamDataFrame

private void streamDataFrame(int streamId,
 AtomicInteger streamOutputWindow,
 ByteBuffer payload,
 int chunk)
                      throws IOException

Throws:

IOException

streamData

private int streamData(int streamId,
 AtomicInteger streamOutputWindow,
 ByteBuffer payload)
                throws IOException

Throws:

IOException

incrementInputCapacity

private void incrementInputCapacity(int streamId,
 AtomicInteger inputWindow,
 int inputCapacity)
                             throws IOException

Throws:

IOException

requestSessionOutput

void requestSessionOutput()

onConnect

public final void onConnect()
                     throws HttpException,
IOException

Throws:

HttpException

IOException

onInput

public final void onInput(ByteBuffer src)
                   throws HttpException,
IOException

Throws:

HttpException

IOException

onOutput

public final void onOutput()
                    throws HttpException,
IOException

Throws:

HttpException

IOException

onTimeout

public final void onTimeout(Timeout timeout)
                     throws HttpException,
IOException

Throws:

HttpException

IOException

onDisconnect

public final void onDisconnect()

executeShutdown

private void executeShutdown(ShutdownCommand shutdownCommand)
                      throws IOException

Throws:

IOException

executePing

private void executePing(PingCommand pingCommand)
                  throws IOException

Throws:

IOException

executeStaleCheck

private void executeStaleCheck(StaleCheckCommand staleCheckCommand)

executeRequest

private void executeRequest(RequestExecutionCommand requestExecutionCommand)
                     throws IOException,
HttpException

Throws:

IOException

HttpException

executePush

private void executePush(PushResponseCommand pushResponseCommand)
                  throws IOException,
HttpException

Throws:

IOException

HttpException

onException

public final void onException(Exception cause)

consumeFrame

private void consumeFrame(RawFrame frame)
                   throws HttpException,
IOException

Throws:

HttpException

IOException

consumeDataFrame

private void consumeDataFrame(RawFrame frame,
 H2Stream stream)
                       throws HttpException,
IOException

Throws:

HttpException

IOException

maximizeWindow

private void maximizeWindow(int streamId,
 AtomicInteger window)
                     throws IOException

Throws:

IOException

consumePushPromiseFrame

private void consumePushPromiseFrame(RawFrame frame,
 ByteBuffer payload,
 H2Stream promisedStream)
                              throws HttpException,
IOException

Throws:

HttpException

IOException

decodeHeaders

List<Header> decodeHeaders(ByteBuffer payload)
                    throws HttpException

Throws:

HttpException

consumeHeaderFrame

private void consumeHeaderFrame(RawFrame frame,
 H2Stream stream)
                         throws HttpException,
IOException

Throws:

HttpException

IOException

consumeContinuationFrame

private void consumeContinuationFrame(RawFrame frame,
 H2Stream stream)
                               throws HttpException,
IOException

Throws:

HttpException

IOException

consumeSettingsFrame

private void consumeSettingsFrame(ByteBuffer payload)
                           throws IOException

Throws:

IOException

produceOutput

private void produceOutput()
                    throws HttpException,
IOException

Throws:

HttpException

IOException

applyRemoteSettings

private void applyRemoteSettings(H2Config config)
                          throws H2ConnectionException

Throws:

H2ConnectionException

applyLocalSettings

private void applyLocalSettings()
                         throws H2ConnectionException

Throws:

H2ConnectionException

close

public void close()
           throws IOException

Description copied from interface: HttpConnection

Closes this connection gracefully. This method will attempt to flush the internal output buffer prior to closing the underlying socket. This method MUST NOT be called from a different thread to force shutdown of the connection. Use close(CloseMode.IMMEDIATE) instead.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable

Specified by:

close in interface HttpConnection

Throws:

IOException

close

public void close(CloseMode closeMode)

Description copied from interface: ModalCloseable

Closes this process or endpoint and releases any system resources associated with it. If the endpoint or the process is already closed then invoking this method has no effect.

Specified by:

close in interface ModalCloseable

Parameters:

closeMode - How to close the receiver.

isOpen

public boolean isOpen()

Description copied from interface: HttpConnection

Checks if this connection is open.

Specified by:

isOpen in interface HttpConnection

Returns:

true if it is open, false if it is closed.

setSocketTimeout

public void setSocketTimeout(Timeout timeout)

Description copied from interface: SocketModalCloseable

Sets the socket timeout value.

Specified by:

setSocketTimeout in interface SocketModalCloseable

Parameters:

timeout - timeout value

getSSLSession

public SSLSession getSSLSession()

Description copied from interface: HttpConnection

Returns this connection's SSL session or null if TLS has not been activated.

Specified by:

getSSLSession in interface HttpConnection

Returns:

this connection's SSL session or null if TLS has not been activated.

getEndpointDetails

public EndpointDetails getEndpointDetails()

Description copied from interface: HttpConnection

Returns this connection's endpoint details.

Specified by:

getEndpointDetails in interface HttpConnection

Returns:

this connection's endpoint details.

getSocketTimeout

public Timeout getSocketTimeout()

Description copied from interface: SocketModalCloseable

Returns the socket timeout value.

Specified by:

getSocketTimeout in interface SocketModalCloseable

Returns:

timeout value.

getProtocolVersion

public ProtocolVersion getProtocolVersion()

Description copied from interface: HttpConnection

Returns this connection's protocol version or null if unknown.

Specified by:

getProtocolVersion in interface HttpConnection

Returns:

this connection's protocol version or null if unknown.

getRemoteAddress

public SocketAddress getRemoteAddress()

Description copied from interface: HttpConnection

Returns this connection's remote address or null if it is not connected yet or unconnected.

Specified by:

getRemoteAddress in interface HttpConnection

Returns:

this connection's remote address or null if it is not connected yet or unconnected.

getLocalAddress

public SocketAddress getLocalAddress()

Description copied from interface: HttpConnection

Returns this connection's local address or null if it is not bound yet.

Specified by:

getLocalAddress in interface HttpConnection

Returns:

this connection's local address or null if it is not bound yet.

appendState

void appendState(StringBuilder buf)

createChannel

H2StreamChannel createChannel(int streamId)

createStream

H2Stream createStream(H2StreamChannel channel,
 H2StreamHandler streamHandler)
               throws H2ConnectionException

Throws:

H2ConnectionException

recordPriorityFromHeaders

private void recordPriorityFromHeaders(H2Stream stream,
 List<? extends Header> headers)

parsePriorityValue

private PriorityValue parsePriorityValue(Header header)

parsePriorityValue

private PriorityValue parsePriorityValue(String field)