Class HTTP2Session.StreamsState

java.lang.Object
org.eclipse.jetty.http2.HTTP2Session.StreamsState
Enclosing class:
HTTP2Session

private class HTTP2Session.StreamsState extends Object

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

This implementation uses a queue to atomically reserve a stream id and claim a slot in the queue; the slot is then assigned the entries to write.

Concurrent threads push slots in the queue but only one thread flushes the slots, up to the slot that has a non-null entries to write, therefore guaranteeing that frames are sent strictly in their stream id order.

This class also coordinates the creation of streams with the close of the session, see RFC 7540, 6.8.

  • Field Details

  • Constructor Details

    • StreamsState

      private StreamsState()
  • Method Details

    • getCloseState

      private CloseState getCloseState()
    • goAway

      private boolean goAway(GoAwayFrame frame, org.eclipse.jetty.util.Callback callback)
    • halt

      private void halt(String reason)
    • onGoAway

      private void onGoAway(GoAwayFrame frame)
    • onShutdown

      private void onShutdown()
    • onIdleTimeout

      private boolean onIdleTimeout()
    • onSessionFailure

      private void onSessionFailure(int error, String reason, org.eclipse.jetty.util.Callback callback)
    • onWriteFailure

      private void onWriteFailure(Throwable x)
    • sendGoAwayAndTerminate

      private void sendGoAwayAndTerminate(GoAwayFrame frame, GoAwayFrame eventFrame)
    • sendGoAway

      private void sendGoAway(GoAwayFrame frame, org.eclipse.jetty.util.Callback callback)
    • onStreamCreated

      private void onStreamCreated()
    • onStreamDestroyed

      private void onStreamDestroyed()
    • tryRunZeroStreamsAction

      private void tryRunZeroStreamsAction()
    • terminate

      private void terminate(GoAwayFrame frame)
    • priority

      private int priority(PriorityFrame frame, org.eclipse.jetty.util.Callback callback)
    • newLocalStream

      private void newLocalStream(IStream.FrameList frameList, org.eclipse.jetty.util.Promise<Stream> promise, Stream.Listener listener)
    • newRemoteStream

      private boolean newRemoteStream(int streamId)
    • push

      private void push(PushPromiseFrame frame, org.eclipse.jetty.util.Promise<Stream> promise, Stream.Listener listener)
    • createLocalStream

      private boolean createLocalStream(HTTP2Session.StreamsState.Slot slot, List<StreamFrame> frames, org.eclipse.jetty.util.Promise<Stream> promise, Stream.Listener listener, int streamId)
    • reserveSlot

      private int reserveSlot(HTTP2Session.StreamsState.Slot slot, int streamId, Consumer<Throwable> fail)
    • freeSlot

      private void freeSlot(HTTP2Session.StreamsState.Slot slot, int streamId)
    • flush

      private void flush()

      Iterates over the entries of the slot queue to flush them.

      The flush proceeds until either one of the following two conditions is true:

      • the queue is empty
      • a slot with a no entries is encountered

      When a slot with a no entries is encountered, then it means that a concurrent thread reserved a slot but hasn't set its entries yet. Since slots must be flushed in order, the thread encountering the slot with no entries must bail out and it is up to the concurrent thread to finish up flushing.

      Note that only one thread can flush at any time; if two threads happen to call this method concurrently, one will do the work while the other will bail out, so it is safe that all threads call this method after they are done reserving a slot and setting the entries.

    • toString

      public String toString()
      Overrides:
      toString in class Object