Package io.undertow.server.protocol.framed

Class AbstractFramedChannel<C extends AbstractFramedChannel<C,​R,​S>,​R extends AbstractFramedStreamSourceChannel<C,​R,​S>,​S extends AbstractFramedStreamSinkChannel<C,​R,​S>>

    • Constructor Detail

      • AbstractFramedChannel

        protected AbstractFramedChannel​(org.xnio.StreamConnection connectedStreamChannel,
                                ByteBufferPool bufferPool,
                                FramePriority<C,​R,​S> framePriority,
                                PooledByteBuffer readData,
                                org.xnio.OptionMap settings)
        Create a new AbstractFramedChannel 8
        Parameters:
        connectedStreamChannel - The ConnectedStreamChannel over which the Frames should get send and received. Be aware that it already must be "upgraded".
        bufferPool - The ByteBufferPool which will be used to acquire ByteBuffer's from.
        framePriority -
        settings - The settings

    • Method Detail

      • createIdleTimeoutChannel

        protected IdleTimeoutConduit createIdleTimeoutChannel​(org.xnio.StreamConnection connectedStreamChannel)

      • getBufferPool

        public ByteBufferPool getBufferPool()
        Get the buffer pool for this connection.
        Returns:
        the buffer pool for this connection

      • getLocalAddress

        public SocketAddress getLocalAddress()
        Specified by:
        getLocalAddress in interface org.xnio.channels.BoundChannel

      • getLocalAddress

        public <A extends SocketAddress> A getLocalAddress​(Class<A> type)
        Specified by:
        getLocalAddress in interface org.xnio.channels.BoundChannel

      • getWorker

        public org.xnio.XnioWorker getWorker()
        Specified by:
        getWorker in interface org.xnio.channels.CloseableChannel

      • getIoThread

        public org.xnio.XnioIoThread getIoThread()
        Specified by:
        getIoThread in interface org.xnio.channels.CloseableChannel

      • supportsOption

        public boolean supportsOption​(org.xnio.Option<?> option)
        Specified by:
        supportsOption in interface org.xnio.channels.Configurable

      • getOption

        public <T> T getOption​(org.xnio.Option<T> option)
                throws IOException
        Specified by:
        getOption in interface org.xnio.channels.Configurable
        Throws:
        IOException

      • setOption

        public <T> T setOption​(org.xnio.Option<T> option,
                       T value)
                throws IOException
        Specified by:
        setOption in interface org.xnio.channels.Configurable
        Throws:
        IOException

      • isOpen

        public boolean isOpen()
        Specified by:
        isOpen in interface Channel

      • getPeerAddress

        public SocketAddress getPeerAddress()
        Specified by:
        getPeerAddress in interface org.xnio.channels.ConnectedChannel

      • getPeerAddress

        public <A extends SocketAddress> A getPeerAddress​(Class<A> type)
        Specified by:
        getPeerAddress in interface org.xnio.channels.ConnectedChannel

      • getSourceAddress

        public InetSocketAddress getSourceAddress()
        Get the source address of the Channel.
        Returns:
        the source address of the Channel

      • getDestinationAddress

        public InetSocketAddress getDestinationAddress()
        Get the destination address of the Channel.
        Returns:
        the destination address of the Channel

      • receive

        public R receive()
          throws IOException
        Receive method, returns null if no frame is ready. Otherwise returns a channel that can be used to read the frame contents.

        Calling this method can also have the side effect of making additional data available to existing source channels. In general if you suspend receives or don't have some other way of calling this method then it can prevent frame channels for being fully consumed.

        Throws:
        IOException

      • lastDataRead

        protected void lastDataRead()
        Method than is invoked when read() returns -1.

      • createChannel

        protected abstract R createChannel​(FrameHeaderData frameHeaderData,
                                   PooledByteBuffer frameData)
                            throws IOException
        Method that creates the actual stream source channel implementation that is in use.
        Parameters:
        frameHeaderData - The header data, as returned by parseFrame(java.nio.ByteBuffer)
        frameData - Any additional data for the frame that has already been read. This may not be the complete frame contents
        Returns:
        A new stream source channel
        Throws:
        IOException

      • parseFrame

        protected abstract FrameHeaderData parseFrame​(ByteBuffer data)
                                       throws IOException
        Attempts to parse an incoming frame header from the data in the buffer.
        Parameters:
        data - The data that has been read from the channel
        Returns:
        The frame header data, or null if the data was incomplete
        Throws:
        IOException - If the data could not be parsed.

      • flushSenders

        protected void flushSenders()
        Flushes all ready stream sink conduits to the channel.

        Frames will be batched up, to allow them all to be written out via a gathering write. The framePriority implementation will be invoked to decide which frames are eligible for sending and in what order.

      • queueFrame

        protected void queueFrame​(S channel)
                   throws IOException
        Queues a new frame to be sent, and attempts a flush if this is the first frame in the new frame queue.

        Depending on the FramePriority implementation in use the channel may or may not be added to the actual pending queue

        Parameters:
        channel - The channel
        Throws:
        IOException

      • flush

        public void flush()

      • isLastFrameReceived

        protected abstract boolean isLastFrameReceived()
        Returns true if the protocol specific final frame has been received.
        Returns:
        true If the last frame has been received

      • isLastFrameSent

        protected abstract boolean isLastFrameSent()
        Returns:
        true If the last frame has been sent

      • handleBrokenSourceChannel

        protected abstract void handleBrokenSourceChannel​(Throwable e)
        Method that is invoked when the read side of the channel is broken. This generally happens on a protocol error.

      • handleBrokenSinkChannel

        protected abstract void handleBrokenSinkChannel​(Throwable e)
        Method that is invoked when then write side of a channel is broken. This generally happens on a protocol error.

      • getReceiveSetter

        public org.xnio.ChannelListener.Setter<C> getReceiveSetter()
        Return the ChannelListener.Setter which will holds the ChannelListener that gets notified once a frame was received.

      • suspendReceives

        public void suspendReceives()
        Suspend the receive of new frames via receive()

      • resumeReceives

        public void resumeReceives()
        Resume the receive of new frames via receive()

      • isReceivesResumed

        public boolean isReceivesResumed()

      • getCloseSetter

        public org.xnio.ChannelListener.Setter<? extends AbstractFramedChannel> getCloseSetter()
        Specified by:
        getCloseSetter in interface org.xnio.channels.BoundChannel
        Specified by:
        getCloseSetter in interface org.xnio.channels.CloseableChannel
        Specified by:
        getCloseSetter in interface org.xnio.channels.ConnectedChannel

      • markReadsBroken

        protected void markReadsBroken​(Throwable cause)
        Called when a source sub channel fails to fulfil its contract, and leaves the channel in an inconsistent state.

        The underlying read side will be forcibly closed.

        Parameters:
        cause - The possibly null cause

      • closeSubChannels

        protected abstract void closeSubChannels()
        Method that is called when the channel is being forcibly closed, and all sub stream sink/source channels should also be forcibly closed.

      • markWritesBroken

        protected void markWritesBroken​(Throwable cause)
        Called when a sub channel fails to fulfil its contract, and leaves the channel in an inconsistent state.

        The underlying channel will be closed, and any sub channels that have writes resumed will have their listeners notified. It is expected that these listeners will then attempt to use the channel, and their standard error handling logic will take over.

        Parameters:
        cause - The possibly null cause

      • isWritesBroken

        protected boolean isWritesBroken()

      • isReadsBroken

        protected boolean isReadsBroken()

      • setIdleTimeout

        public void setIdleTimeout​(long timeout)

      • getIdleTimeout

        public long getIdleTimeout()

      • addCloseTask

        public void addCloseTask​(org.xnio.ChannelListener<C> task)

      • getUnderlyingConnection

        protected org.xnio.StreamConnection getUnderlyingConnection()

      • writeExceptionHandler

        protected org.xnio.ChannelExceptionHandler<org.xnio.channels.SuspendableWriteChannel> writeExceptionHandler()

      • isRequireExplicitFlush

        public boolean isRequireExplicitFlush()

      • setRequireExplicitFlush

        public void setRequireExplicitFlush​(boolean requireExplicitFlush)

      • getSettings

        protected org.xnio.OptionMap getSettings()