HTTP2Session (Jetty :: HTTP2 :: Common 9.4.10.v20180503 API)

java.lang.Object
- org.eclipse.jetty.util.component.AbstractLifeCycle
- - org.eclipse.jetty.util.component.ContainerLifeCycle
  - - org.eclipse.jetty.http2.HTTP2Session

All Implemented Interfaces:: Session, ISession, Parser.Listener, Container, Destroyable, Dumpable, LifeCycle

@ManagedObject
public abstract class HTTP2Session
extends ContainerLifeCycle
implements ISession, Parser.Listener

Nested Class Summary
- Nested classes/interfaces inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle
  AbstractLifeCycle.AbstractLifeCycleListener
- Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Container
  Container.InheritedListener, Container.Listener
- Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.LifeCycle
  LifeCycle.Listener
- Nested classes/interfaces inherited from interface org.eclipse.jetty.http2.parser.Parser.Listener
  Parser.Listener.Adapter
- Nested classes/interfaces inherited from interface org.eclipse.jetty.http2.api.Session
  Session.Listener

Field Summary
- Fields inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle
  FAILED, RUNNING, STARTED, STARTING, STOP_ON_FAILURE, STOPPED, STOPPING

Constructor Summary

Constructors
Constructor	Description
`HTTP2Session(Scheduler scheduler, EndPoint endPoint, Generator generator, Session.Listener listener, FlowControlStrategy flowControl, int initialStreamId)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`abort(java.lang.Throwable failure)`
`boolean`	`close(int error, java.lang.String reason, Callback callback)`	Invoked internally and by applications to send a GO_AWAY frame to the other peer.
`protected IStream`	`createLocalStream(int streamId, Promise<Stream> promise)`
`protected IStream`	`createRemoteStream(int streamId)`
`void`	`data(IStream stream, Callback callback, DataFrame frame)`	Enqueues the given DATA frame to be written to the connection.
`void`	`disconnect()`
`protected void`	`doStop()`
`void`	`dump(java.lang.Appendable out, java.lang.String indent)`
`void`	`frames(IStream stream, Callback callback, Frame frame, Frame... frames)`	Enqueues the given frames to be written to the connection.
`long`	`getBytesWritten()`
`EndPoint`	`getEndPoint()`
`FlowControlStrategy`	`getFlowControlStrategy()`
`Generator`	`getGenerator()`
`int`	`getInitialSessionRecvWindow()`
`int`	`getMaxLocalStreams()`
`int`	`getMaxRemoteStreams()`
`int`	`getRecvWindow()`
`int`	`getSendWindow()`
`IStream`	`getStream(int streamId)`	Retrieves the stream with the given `streamId`.
`int`	`getStreamCount()`
`long`	`getStreamIdleTimeout()`
`java.util.Collection<Stream>`	`getStreams()`
`int`	`getWriteThreshold()`
`boolean`	`isClosed()`
`boolean`	`isDisconnected()`
`boolean`	`isPushEnabled()`
`protected IStream`	`newStream(int streamId, boolean local)`
`void`	`newStream(HeadersFrame frame, Promise<Stream> promise, Stream.Listener listener)`	Sends the given HEADERS `frame` to create a new `Stream`.
`protected void`	`notifyClose(Session session, GoAwayFrame frame, Callback callback)`
`protected void`	`notifyFailure(Session session, java.lang.Throwable failure, Callback callback)`
`protected void`	`notifyHeaders(IStream stream, HeadersFrame 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)`
`void`	`onConnectionFailure(int error, java.lang.String reason)`
`void`	`onData(DataFrame frame)`
`void`	`onFlushed(long bytes)`	Callback method invoked when bytes are flushed to the network.
`void`	`onFrame(Frame frame)`	Callback method invoked during an HTTP/1.1 to HTTP/2 upgrade requests to process the given synthetic frame.
`void`	`onGoAway(GoAwayFrame frame)`	This method is called when receiving a GO_AWAY from the other peer.
`abstract void`	`onHeaders(HeadersFrame frame)`
`boolean`	`onIdleTimeout()`	This method is invoked when the idle timeout triggers.
`void`	`onPing(PingFrame frame)`
`void`	`onPriority(PriorityFrame frame)`
`void`	`onReset(ResetFrame frame)`
`void`	`onSettings(SettingsFrame frame)`
`void`	`onSettings(SettingsFrame frame, boolean reply)`
`void`	`onShutdown()`	A typical close by a remote peer involves a GO_AWAY frame followed by TCP FIN.
`protected void`	`onStreamClosed(IStream stream)`
`protected void`	`onStreamOpened(IStream stream)`
`void`	`onWindowUpdate(WindowUpdateFrame frame)`
`void`	`onWindowUpdate(IStream stream, WindowUpdateFrame frame)`	Callback method invoked when a WINDOW_UPDATE frame has been received.
`void`	`ping(PingFrame frame, Callback callback)`	Sends the given PING `frame`.
`int`	`priority(PriorityFrame frame, Callback callback)`	Sends the given PRIORITY `frame`.
`void`	`push(IStream stream, Promise<Stream> promise, PushPromiseFrame frame, Stream.Listener listener)`	Enqueues the given PUSH_PROMISE frame to be written to the connection.
`void`	`removeStream(IStream stream)`	Removes the given `stream`.
`protected void`	`reset(ResetFrame frame, Callback callback)`
`void`	`setInitialSessionRecvWindow(int initialSessionRecvWindow)`
`void`	`setMaxLocalStreams(int maxLocalStreams)`
`void`	`setMaxRemoteStreams(int maxRemoteStreams)`
`void`	`setStreamIdleTimeout(long streamIdleTimeout)`
`void`	`settings(SettingsFrame frame, Callback callback)`	Sends the given SETTINGS `frame` to configure the session.
`void`	`setWriteThreshold(int writeThreshold)`
`java.lang.String`	`toString()`
`int`	`updateRecvWindow(int delta)`	Updates the session receive window by the given `delta`.
`int`	`updateSendWindow(int delta)`	Updates the session send window by the given `delta`.

Methods inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle
addLifeCycleListener, getState, getState, getStopTimeout, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeLifeCycleListener, start, stop

Methods inherited from class org.eclipse.jetty.util.component.ContainerLifeCycle
addBean, addBean, addBean, addEventListener, addManaged, contains, destroy, doStart, dump, dump, dump, dump, dumpBeans, dumpObject, dumpStdErr, dumpThis, getBean, getBeans, getBeans, getContainedBeans, getContainedBeans, isManaged, manage, removeBean, removeBeans, removeEventListener, setBeans, setStopTimeout, start, stop, unmanage, updateBean, updateBean, updateBeans

Methods inherited from interface org.eclipse.jetty.util.component.LifeCycle
start, stop

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.jetty.http2.parser.Parser.Listener
onPushPromise

- Constructor Detail
  - HTTP2Session
```
public HTTP2Session(Scheduler scheduler,
                    EndPoint endPoint,
                    Generator generator,
                    Session.Listener listener,
                    FlowControlStrategy flowControl,
                    int initialStreamId)
```
- Method Detail
  - doStop
```
protected void doStop()
               throws java.lang.Exception
```
    Overrides:
    
    doStop in class ContainerLifeCycle
    
    Throws:
    
    java.lang.Exception
  - getFlowControlStrategy
```
@ManagedAttribute(value="The flow control strategy",
                  readonly=true)
public FlowControlStrategy getFlowControlStrategy()
```
  - getMaxLocalStreams
```
public int getMaxLocalStreams()
```
  - setMaxLocalStreams
```
public void setMaxLocalStreams(int maxLocalStreams)
```
  - getMaxRemoteStreams
```
public int getMaxRemoteStreams()
```
  - setMaxRemoteStreams
```
public void setMaxRemoteStreams(int maxRemoteStreams)
```
  - getStreamIdleTimeout
```
@ManagedAttribute("The stream\'s idle timeout")
public long getStreamIdleTimeout()
```
  - setStreamIdleTimeout
```
public void setStreamIdleTimeout(long streamIdleTimeout)
```
  - getInitialSessionRecvWindow
```
@ManagedAttribute("The initial size of session\'s flow control receive window")
public int getInitialSessionRecvWindow()
```
  - setInitialSessionRecvWindow
```
public void setInitialSessionRecvWindow(int initialSessionRecvWindow)
```
  - getWriteThreshold
```
public int getWriteThreshold()
```
  - setWriteThreshold
```
public void setWriteThreshold(int writeThreshold)
```
  - getEndPoint
```
public EndPoint getEndPoint()
```
  - getGenerator
```
public Generator getGenerator()
```
  - getBytesWritten
```
public long getBytesWritten()
```
    Specified by:
    
    getBytesWritten in interface ISession
    
    Returns:
    
    the number of bytes written by this session
  - onData
```
public void onData(DataFrame frame)
```
    Specified by:
    
    onData in interface Parser.Listener
  - onHeaders
```
public abstract void onHeaders(HeadersFrame frame)
```
    Specified by:
    
    onHeaders in interface Parser.Listener
  - onPriority
```
public void onPriority(PriorityFrame frame)
```
    Specified by:
    
    onPriority in interface Parser.Listener
  - onReset
```
public void onReset(ResetFrame frame)
```
    Specified by:
    
    onReset in interface Parser.Listener
  - onSettings
```
public void onSettings(SettingsFrame frame)
```
    Specified by:
    
    onSettings in interface Parser.Listener
  - onSettings
```
public void onSettings(SettingsFrame frame,
                       boolean reply)
```
  - onPing
```
public void onPing(PingFrame frame)
```
    Specified by:
    
    onPing in interface Parser.Listener
  - onGoAway
```
public void onGoAway(GoAwayFrame frame)
```
    This method is called when receiving a GO_AWAY from the other peer. We check the close state to act appropriately:
    - NOT_CLOSED: we move to REMOTELY_CLOSED and queue a disconnect, so that the content of the queue is written, and then the connection closed. We notify the application after being terminated. See HTTP2Session.ControlEntry#succeeded()
    - In all other cases, we do nothing since other methods are already performing their actions.
    Specified by:
    
    onGoAway in interface Parser.Listener
    
    Parameters:
    
    frame - the GO_AWAY frame that has been received.
    
    See Also:
    
    close(int, String, Callback), onShutdown(), onIdleTimeout()
  - onWindowUpdate
```
public void onWindowUpdate(WindowUpdateFrame frame)
```
    Specified by:
    
    onWindowUpdate in interface Parser.Listener
  - onConnectionFailure
```
public void onConnectionFailure(int error,
                                java.lang.String reason)
```
    Specified by:
    
    onConnectionFailure in interface Parser.Listener
  - newStream
```
public void newStream(HeadersFrame frame,
                      Promise<Stream> promise,
                      Stream.Listener listener)
```
    Description copied from interface: Session
    
    Sends the given HEADERS frame to create a new Stream.
    
    Specified by:
    
    newStream in interface Session
    
    Parameters:
    
    frame - the HEADERS frame containing the HTTP headers
    
    promise - the promise that gets notified of the stream creation
    
    listener - the listener that gets notified of stream events
  - priority
```
public int priority(PriorityFrame frame,
                    Callback callback)
```
    Description copied from interface: Session
    
    Sends the given PRIORITY frame.
    
    If the frame references a streamId that does not exist (for example 0), then a new streamId will be allocated, to support unused anchor streams that act as parent for other streams.
    
    Specified by:
    
    priority in interface Session
    
    Parameters:
    
    frame - the PRIORITY frame to send
    
    callback - the callback that gets notified when the frame has been sent
    
    Returns:
    
    the new stream id generated by the PRIORITY frame, or the stream id that it is already referencing
  - push
```
public void push(IStream stream,
                 Promise<Stream> promise,
                 PushPromiseFrame frame,
                 Stream.Listener listener)
```
    Description copied from interface: ISession
    
    Enqueues the given PUSH_PROMISE frame to be written to the connection.
    
    Differently from ISession.frames(IStream, Callback, Frame, Frame...), this method generates atomically the stream id for the pushed stream.
    
    Specified by:
    
    push in interface ISession
    
    Parameters:
    
    stream - the stream associated to the pushed stream
    
    promise - the promise that gets notified of the pushed stream creation
    
    frame - the PUSH_PROMISE frame to enqueue
    
    listener - the listener that gets notified of pushed stream events
  - settings
```
public void settings(SettingsFrame frame,
                     Callback callback)
```
    Description copied from interface: Session
    
    Sends the given SETTINGS frame to configure the session.
    
    Specified by:
    
    settings in interface Session
    
    Parameters:
    
    frame - the SETTINGS frame to send
    
    callback - the callback that gets notified when the frame has been sent
  - ping
```
public void ping(PingFrame frame,
                 Callback callback)
```
    Description copied from interface: Session
    
    Sends the given PING frame.
    
    PING frames may be used to test the connection integrity and to measure round-trip time.
    
    Specified by:
    
    ping in interface Session
    
    Parameters:
    
    frame - the PING frame to send
    
    callback - the callback that gets notified when the frame has been sent
  - reset
```
protected void reset(ResetFrame frame,
                     Callback callback)
```
  - close
```
public boolean close(int error,
                     java.lang.String reason,
                     Callback callback)
```
    Invoked internally and by applications to send a GO_AWAY frame to the other peer. We check the close state to act appropriately:
    - NOT_CLOSED: we move to LOCALLY_CLOSED and queue a GO_AWAY. When the GO_AWAY has been written, it will only cause the output to be shut down (not the connection closed), so that the application can still read frames arriving from the other peer. Ideally the other peer will notice the GO_AWAY and close the connection. When that happen, we close the connection from onShutdown(). Otherwise, the idle timeout mechanism will close the connection, see onIdleTimeout().
    - In all other cases, we do nothing since other methods are already performing their actions.
    Specified by:
    
    close in interface Session
    
    Parameters:
    
    error - the error code
    
    reason - the reason
    
    callback - the callback to invoke when the operation is complete
    
    Returns:
    
    true if the frame is being sent, false if the session was already closed
    
    See Also:
    
    onGoAway(GoAwayFrame), onShutdown(), onIdleTimeout()
  - isClosed
```
public boolean isClosed()
```
    Specified by:
    
    isClosed in interface Session
    
    Returns:
    
    whether the session is not open
  - frames
```
public void frames(IStream stream,
                   Callback callback,
                   Frame frame,
                   Frame... frames)
```
    Description copied from interface: ISession
    
    Enqueues the given frames to be written to the connection.
    
    Specified by:
    
    frames in interface ISession
    
    Parameters:
    
    stream - the stream the frames belong to
    
    callback - the callback that gets notified when the frames have been sent
    
    frame - the first frame to enqueue
    
    frames - additional frames to enqueue
  - data
```
public void data(IStream stream,
                 Callback callback,
                 DataFrame frame)
```
    Description copied from interface: ISession
    
    Enqueues the given DATA frame to be written to the connection.
    
    Specified by:
    
    data in interface ISession
    
    Parameters:
    
    stream - the stream the data frame belongs to
    
    callback - the callback that gets notified when the frame has been sent
    
    frame - the DATA frame to send
  - createLocalStream
```
protected IStream createLocalStream(int streamId,
                                    Promise<Stream> promise)
```
  - createRemoteStream
```
protected IStream createRemoteStream(int streamId)
```
  - newStream
```
protected IStream newStream(int streamId,
                            boolean local)
```
  - removeStream
```
public void removeStream(IStream stream)
```
    Description copied from interface: ISession
    
    Removes the given stream.
    
    Specified by:
    
    removeStream in interface ISession
    
    Parameters:
    
    stream - the stream to remove
  - getStreams
```
public java.util.Collection<Stream> getStreams()
```
    Specified by:
    
    getStreams in interface Session
    
    Returns:
    
    a snapshot of all the streams currently belonging to this session
  - getStreamCount
```
@ManagedAttribute("The number of active streams")
public int getStreamCount()
```
  - getStream
```
public IStream getStream(int streamId)
```
    Description copied from interface: Session
    
    Retrieves the stream with the given streamId.
    
    Specified by:
    
    getStream in interface ISession
    
    Specified by:
    
    getStream in interface Session
    
    Parameters:
    
    streamId - the stream id of the stream looked for
    
    Returns:
    
    the stream with the given id, or null if no such stream exist
  - getSendWindow
```
@ManagedAttribute(value="The flow control send window",
                  readonly=true)
public int getSendWindow()
```
  - getRecvWindow
```
@ManagedAttribute(value="The flow control receive window",
                  readonly=true)
public int getRecvWindow()
```
  - updateSendWindow
```
public int updateSendWindow(int delta)
```
    Description copied from interface: ISession
    
    Updates the session send window by the given delta.
    
    Specified by:
    
    updateSendWindow in interface ISession
    
    Parameters:
    
    delta - the delta value (positive or negative) to add to the session send window
    
    Returns:
    
    the previous value of the session send window
  - updateRecvWindow
```
public int updateRecvWindow(int delta)
```
    Description copied from interface: ISession
    
    Updates the session receive window by the given delta.
    
    Specified by:
    
    updateRecvWindow in interface ISession
    
    Parameters:
    
    delta - the delta value (positive or negative) to add to the session receive window
    
    Returns:
    
    the previous value of the session receive window
  - onWindowUpdate
```
public void onWindowUpdate(IStream stream,
                           WindowUpdateFrame frame)
```
    Description copied from interface: ISession
    
    Callback method invoked when a WINDOW_UPDATE frame has been received.
    
    Specified by:
    
    onWindowUpdate in interface ISession
    
    Parameters:
    
    stream - the stream the window update belongs to, or null if the window update belongs to the session
    
    frame - the WINDOW_UPDATE frame received
  - isPushEnabled
```
@ManagedAttribute(value="Whether HTTP/2 push is enabled",
                  readonly=true)
public boolean isPushEnabled()
```
    Specified by:
    
    isPushEnabled in interface ISession
    
    Returns:
    
    whether the push functionality is enabled
  - onShutdown
```
public void onShutdown()
```
    A typical close by a remote peer involves a GO_AWAY frame followed by TCP FIN. This method is invoked when the TCP FIN is received, or when an exception is thrown while reading, and we check the close state to act appropriately:
    - NOT_CLOSED: means that the remote peer did not send a GO_AWAY (abrupt close) or there was an exception while reading, and therefore we terminate.
    - LOCALLY_CLOSED: we have sent the GO_AWAY to the remote peer, which received it and closed the connection; we queue a disconnect to close the connection on the local side. The GO_AWAY just shutdown the output, so we need this step to make sure the connection is closed. See close(int, String, Callback).
    - REMOTELY_CLOSED: we received the GO_AWAY, and the TCP FIN afterwards, so we do nothing since the handling of the GO_AWAY will take care of closing the connection. See onGoAway(GoAwayFrame).
    Specified by:
    
    onShutdown in interface ISession
    
    See Also:
    
    onGoAway(GoAwayFrame), close(int, String, Callback), onIdleTimeout()
  - onIdleTimeout
```
public boolean onIdleTimeout()
```
    This method is invoked when the idle timeout triggers. We check the close state to act appropriately:
    - NOT_CLOSED: it's a real idle timeout, we just initiate a close, see close(int, String, Callback).
    - LOCALLY_CLOSED: we have sent a GO_AWAY and only shutdown the output, but the other peer did not close the connection so we never received the TCP FIN, and therefore we terminate.
    - REMOTELY_CLOSED: the other peer sent us a GO_AWAY, we should have queued a disconnect, but for some reason it was not processed (for example, queue was stuck because of TCP congestion), therefore we terminate. See onGoAway(GoAwayFrame).
    Specified by:
    
    onIdleTimeout in interface ISession
    
    Returns:
    
    true if the session should be closed, false otherwise
    
    See Also:
    
    onGoAway(GoAwayFrame), close(int, String, Callback), onShutdown()
  - onFrame
```
public void onFrame(Frame frame)
```
    Description copied from interface: ISession
    
    Callback method invoked during an HTTP/1.1 to HTTP/2 upgrade requests to process the given synthetic frame.
    
    Specified by:
    
    onFrame in interface ISession
    
    Parameters:
    
    frame - the synthetic frame to process
  - onStreamOpened
```
protected void onStreamOpened(IStream stream)
```
  - onStreamClosed
```
protected void onStreamClosed(IStream stream)
```
  - onFlushed
```
public void onFlushed(long bytes)
               throws java.io.IOException
```
    Description copied from interface: ISession
    
    Callback method invoked when bytes are flushed to the network.
    
    Specified by:
    
    onFlushed in interface ISession
    
    Parameters:
    
    bytes - the number of bytes flushed to the network
    
    Throws:
    
    java.io.IOException - if the flush should fail
  - disconnect
```
public void disconnect()
```
  - abort
```
protected void abort(java.lang.Throwable failure)
```
  - isDisconnected
```
public boolean isDisconnected()
```
  - notifyNewStream
```
protected Stream.Listener notifyNewStream(Stream stream,
                                          HeadersFrame frame)
```
  - notifySettings
```
protected void notifySettings(Session session,
                              SettingsFrame frame)
```
  - notifyPing
```
protected void notifyPing(Session session,
                          PingFrame frame)
```
  - notifyReset
```
protected void notifyReset(Session session,
                           ResetFrame frame)
```
  - notifyClose
```
protected void notifyClose(Session session,
                           GoAwayFrame frame,
                           Callback callback)
```
  - notifyIdleTimeout
```
protected boolean notifyIdleTimeout(Session session)
```
  - notifyFailure
```
protected void notifyFailure(Session session,
                             java.lang.Throwable failure,
                             Callback callback)
```
  - notifyHeaders
```
protected void notifyHeaders(IStream stream,
                             HeadersFrame frame)
```
  - dump
```
public void dump(java.lang.Appendable out,
                 java.lang.String indent)
          throws java.io.IOException
```
    Specified by:
    
    dump in interface Dumpable
    
    Overrides:
    
    dump in class ContainerLifeCycle
    
    Throws:
    
    java.io.IOException
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class HTTP2Session

Nested Class Summary

Nested classes/interfaces inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Container

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.LifeCycle

Nested classes/interfaces inherited from interface org.eclipse.jetty.http2.parser.Parser.Listener

Nested classes/interfaces inherited from interface org.eclipse.jetty.http2.api.Session

Field Summary

Fields inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

Methods inherited from class org.eclipse.jetty.util.component.ContainerLifeCycle

Methods inherited from interface org.eclipse.jetty.util.component.LifeCycle

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.jetty.http2.parser.Parser.Listener

Constructor Detail

HTTP2Session

Method Detail

doStop

getFlowControlStrategy

getMaxLocalStreams

setMaxLocalStreams

getMaxRemoteStreams

setMaxRemoteStreams

getStreamIdleTimeout

setStreamIdleTimeout

getInitialSessionRecvWindow

setInitialSessionRecvWindow

getWriteThreshold

setWriteThreshold

getEndPoint

getGenerator

getBytesWritten

onData

onHeaders

onPriority

onReset

onSettings

onSettings

onPing

onGoAway

onWindowUpdate

onConnectionFailure

newStream

priority

push

settings

ping

reset

close

isClosed

frames

data

createLocalStream

createRemoteStream

newStream

removeStream

getStreams

getStreamCount

getStream

getSendWindow

getRecvWindow

updateSendWindow

updateRecvWindow

onWindowUpdate

isPushEnabled

onShutdown

onIdleTimeout

onFrame

onStreamOpened

onStreamClosed

onFlushed

disconnect

abort

isDisconnected

notifyNewStream

notifySettings

notifyPing

notifyReset