Class HttpChannel

  • All Implemented Interfaces:
    java.lang.Runnable, HttpOutput.Interceptor
    Direct Known Subclasses:
    HttpChannelOverFCGI, HttpChannelOverHttp, HttpChannelOverHTTP2

    public abstract class HttpChannel
    extends java.lang.Object
    implements java.lang.Runnable, HttpOutput.Interceptor
    HttpChannel represents a single endpoint for HTTP semantic processing. The HttpChannel is both an HttpParser.RequestHandler, where it passively receives events from an incoming HTTP request, and a Runnable, where it actively takes control of the request/response life cycle and calls the application (perhaps suspending and resuming with multiple calls to run). The HttpChannel signals the switch from passive mode to active mode by returning true to one of the HttpParser.RequestHandler callbacks. The completion of the active phase is signalled by a call to HttpTransport.completed().
    • Method Detail

      • isSendError

        public boolean isSendError()
      • formatAddrOrHost

        protected java.lang.String formatAddrOrHost​(java.lang.String addr)
        Format the address or host returned from Request methods
        Parameters:
        addr - The address or host
        Returns:
        Default implementation returns HostPort.normalizeHost(String)
      • needContent

        public abstract boolean needContent()
        Notify the channel that content is needed. If some content is immediately available, true is returned and produceContent() has to be called and will return a non-null object. If no content is immediately available, HttpInput.onContentProducible() is called once some content arrives and produceContent() can be called without returning null. If a failure happens, then HttpInput.onContentProducible() will be called and an error content will return the error on the next call to produceContent().
        Returns:
        true if content is immediately available.
      • produceContent

        public abstract HttpInput.Content produceContent()
        Produce a HttpInput.Content object with data currently stored within the channel. The produced content can be special (meaning calling HttpInput.Content.isSpecial() returns true) if the channel reached a special state, like EOF or an error. Once a special content has been returned, all subsequent calls to this method will always return a special content of the same kind and needContent() will always return true. The returned content is "raw", i.e.: not decoded.
        Returns:
        a HttpInput.Content object if one is immediately available without blocking, null otherwise.
      • failAllContent

        public abstract boolean failAllContent​(java.lang.Throwable failure)
        Fail all content that is currently stored within the channel.
        Parameters:
        failure - the failure to fail the content with.
        Returns:
        true if EOF was reached while failing all content, false otherwise.
      • failed

        public abstract boolean failed​(java.lang.Throwable failure)
        Fail the channel's input.
        Parameters:
        failure - the failure.
        Returns:
        true if the channel needs to be rescheduled.
      • eof

        protected abstract boolean eof()
        Mark the channel's input as EOF.
        Returns:
        true if the channel needs to be rescheduled.
      • newHttpOutput

        protected HttpOutput newHttpOutput()
      • addListener

        @Deprecated
        public boolean addListener​(HttpChannel.Listener listener)
        Deprecated.
        Add a transient Listener to the HttpChannel.

        Listeners added by this method will only be notified if the HttpChannel has been constructed with an instance of HttpChannel.TransientListeners as an AbstractConnector provided listener

        Transient listeners are removed after every request cycle

        Parameters:
        listener - the listener to add
        Returns:
        true if the listener was added.
      • removeListener

        @Deprecated
        public boolean removeListener​(HttpChannel.Listener listener)
        Deprecated.
      • getTransientListeners

        @Deprecated
        public java.util.List<HttpChannel.Listener> getTransientListeners()
        Deprecated.
      • getBytesWritten

        public long getBytesWritten()
      • getRequests

        public long getRequests()
        Returns:
        the number of requests handled by this connection
      • getConnector

        public Connector getConnector()
      • getRequestLog

        public RequestLog getRequestLog()
      • setRequestLog

        public void setRequestLog​(RequestLog requestLog)
      • addRequestLog

        public void addRequestLog​(RequestLog requestLog)
      • getIdleTimeout

        public long getIdleTimeout()
        Get the idle timeout.

        This is implemented as a call to EndPoint.getIdleTimeout(), but may be overridden by channels that have timeouts different from their connections.

        Returns:
        the idle timeout (in milliseconds)
      • setIdleTimeout

        public void setIdleTimeout​(long timeoutMs)
        Set the idle timeout.

        This is implemented as a call to EndPoint.setIdleTimeout(long), but may be overridden by channels that have timeouts different from their connections.

        Parameters:
        timeoutMs - the idle timeout in milliseconds
      • getServer

        public Server getServer()
      • getRequest

        public Request getRequest()
      • getResponse

        public Response getResponse()
      • getConnection

        public Connection getConnection()
      • getEndPoint

        public EndPoint getEndPoint()
      • getLocalAddress

        public java.net.InetSocketAddress getLocalAddress()
      • getRemoteAddress

        public java.net.InetSocketAddress getRemoteAddress()
      • continue100

        public void continue100​(int available)
                         throws java.io.IOException
        If the associated response has the Expect header set to 100 Continue, then accessing the input stream indicates that the handler/servlet is ready for the request body and thus a 100 Continue response is sent.
        Parameters:
        available - estimate of the number of bytes that are available
        Throws:
        java.io.IOException - if the InputStream cannot be created
      • recycle

        public void recycle()
      • run

        public void run()
        Specified by:
        run in interface java.lang.Runnable
      • handle

        public boolean handle()
        Returns:
        True if the channel is ready to continue handling (ie it is not suspended)
      • ensureConsumeAllOrNotPersistent

        public void ensureConsumeAllOrNotPersistent()
      • sendErrorOrAbort

        public boolean sendErrorOrAbort​(java.lang.String message)
        Parameters:
        message - the error message.
        Returns:
        true if we have sent an error, false if we have aborted.
      • handleException

        protected void handleException​(java.lang.Throwable failure)

        Sends an error 500, performing a special logic to detect whether the request is suspended, to avoid concurrent writes from the application.

        It may happen that the application suspends, and then throws an exception, while an application spawned thread writes the response content; in such case, we attempt to commit the error directly bypassing the ErrorHandler mechanisms and the response OutputStream.

        Parameters:
        failure - the Throwable that caused the problem
      • unwrap

        protected java.lang.Throwable unwrap​(java.lang.Throwable failure,
                                             java.lang.Class<?>... targets)
        Unwrap failure causes to find target class
        Parameters:
        failure - The throwable to have its causes unwrapped
        targets - Exception classes that we should not unwrap
        Returns:
        A target throwable or null
      • sendResponseAndComplete

        public void sendResponseAndComplete()
      • isExpecting100Continue

        public boolean isExpecting100Continue()
      • isExpecting102Processing

        public boolean isExpecting102Processing()
      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object
      • onContentComplete

        public boolean onContentComplete()
      • onTrailers

        public void onTrailers​(HttpFields trailers)
      • onRequestComplete

        public boolean onRequestComplete()
      • checkAndPrepareUpgrade

        protected boolean checkAndPrepareUpgrade()

        Checks whether the processing of the request resulted in an upgrade, and if so performs upgrade preparation steps before the upgrade response is sent back to the client.

        This avoids a race where the server is unprepared if the client sends data immediately after having received the upgrade response.

        Returns:
        true if the channel is not complete and more processing is required, typically because sendError has been called.
      • onCompleted

        public void onCompleted()
      • sendResponse

        protected boolean sendResponse​(MetaData.Response response,
                                       java.nio.ByteBuffer content,
                                       boolean complete,
                                       Callback callback)
      • sendResponse

        public boolean sendResponse​(MetaData.Response info,
                                    java.nio.ByteBuffer content,
                                    boolean complete)
                             throws java.io.IOException
        Throws:
        java.io.IOException
      • isCommitted

        public boolean isCommitted()
      • isRequestCompleted

        public boolean isRequestCompleted()
        Returns:
        True if the request lifecycle is completed
      • isResponseCompleted

        public boolean isResponseCompleted()
        Returns:
        True if the response is completely written.
      • isPersistent

        public boolean isPersistent()
      • write

        public void write​(java.nio.ByteBuffer content,
                          boolean complete,
                          Callback callback)

        Non-Blocking write, committing the response if needed.

        Called as last link in HttpOutput.Filter chain
        Specified by:
        write in interface HttpOutput.Interceptor
        Parameters:
        content - the content buffer to write
        complete - whether the content is complete for the response
        callback - Callback when complete or failed
      • execute

        protected void execute​(java.lang.Runnable task)
      • getScheduler

        public Scheduler getScheduler()
      • isUseOutputDirectByteBuffers

        public boolean isUseOutputDirectByteBuffers()
      • abort

        public void abort​(java.lang.Throwable failure)
        If a write or similar operation to this channel fails, then this method should be called.

        The standard implementation calls HttpTransport.abort(Throwable).

        Parameters:
        failure - the failure that caused the abort.
      • isTunnellingSupported

        public boolean isTunnellingSupported()
      • getTunnellingEndPoint

        public EndPoint getTunnellingEndPoint()