HttpChannel (Jetty :: Server Core 9.2.28.v20190418 API)

java.lang.Object
- org.eclipse.jetty.server.HttpChannel<T>

All Implemented Interfaces:

Runnable, HttpParser.HttpHandler<T>, HttpParser.ProxyHandler, HttpParser.RequestHandler<T>

Direct Known Subclasses:

HttpConnection.HttpChannelOverHttp
```
public class HttpChannel<T>
extends Object
implements HttpParser.RequestHandler<T>, Runnable, HttpParser.ProxyHandler
```
HttpChannel. Represents a single endpoint for HTTP semantic processing. The HttpChannel is both a 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().

Constructor Summary

Constructors
Constructor and Description
`HttpChannel(Connector connector, HttpConfiguration configuration, EndPoint endPoint, HttpTransport transport, HttpInput<T> input)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abort()` If a write or similar to this channel fails this method should be called.
`void`	`badMessage(int status, String reason)`
`boolean`	`content(T item)`
`void`	`continue100(int available)` 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.
`void`	`earlyEOF()`
`protected void`	`execute(Runnable task)`
`ByteBufferPool`	`getByteBufferPool()`
`Connector`	`getConnector()`
`static HttpChannel<?>`	`getCurrentHttpChannel()` Get the current channel that this thread is dispatched to.
`EndPoint`	`getEndPoint()`
`int`	`getHeaderCacheSize()`
`HttpConfiguration`	`getHttpConfiguration()`
`HttpTransport`	`getHttpTransport()`
`HttpVersion`	`getHttpVersion()`
`long`	`getIdleTimeout()` Get the idle timeout.
`InetSocketAddress`	`getLocalAddress()`
`InetSocketAddress`	`getRemoteAddress()`
`Request`	`getRequest()`
`int`	`getRequests()`
`Response`	`getResponse()`
`org.eclipse.jetty.util.thread.Scheduler`	`getScheduler()`
`Server`	`getServer()`
`HttpChannelState`	`getState()`
`boolean`	`handle()`
`protected void`	`handleException(Throwable x)` Sends an error 500, performing a special logic to detect whether the request is suspended, to avoid concurrent writes from the application.
`boolean`	`headerComplete()`
`boolean`	`isCommitted()`
`boolean`	`isExpecting100Continue()`
`boolean`	`isExpecting102Processing()`
`boolean`	`messageComplete()`
`boolean`	`parsedHeader(HttpField field)`
`boolean`	`parsedHostHeader(String host, int port)`
`void`	`proxied(String protocol, String sAddr, String dAddr, int sPort, int dPort)`
`void`	`reset()`
`void`	`run()`
`protected boolean`	`sendResponse(HttpGenerator.ResponseInfo info, ByteBuffer content, boolean complete)`
`protected boolean`	`sendResponse(HttpGenerator.ResponseInfo info, ByteBuffer content, boolean complete, org.eclipse.jetty.util.Callback callback)`
`protected static HttpChannel<?>`	`setCurrentHttpChannel(HttpChannel<?> channel)`
`void`	`setIdleTimeout(long timeoutMs)` Set the idle timeout.
`boolean`	`startRequest(HttpMethod httpMethod, String method, ByteBuffer uri, HttpVersion version)`
`String`	`toString()`
`boolean`	`useDirectBuffers()`
`protected void`	`write(ByteBuffer content, boolean complete, org.eclipse.jetty.util.Callback callback)` Non-Blocking write, committing the response if needed.

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

- Constructor Detail
  - HttpChannel
```
public HttpChannel(Connector connector,
           HttpConfiguration configuration,
           EndPoint endPoint,
           HttpTransport transport,
           HttpInput<T> input)
```
- Method Detail
  - getCurrentHttpChannel
```
public static HttpChannel<?> getCurrentHttpChannel()
```
    Get the current channel that this thread is dispatched to.
    
    Returns:
    the current HttpChannel or null
    See Also:
    for a more general way to access the HttpChannel
  - setCurrentHttpChannel
```
protected static HttpChannel<?> setCurrentHttpChannel(HttpChannel<?> channel)
```
  - getState
```
public HttpChannelState getState()
```
  - getHttpVersion
```
public HttpVersion getHttpVersion()
```
  - getRequests
```
public int getRequests()
```
    Returns:
    the number of requests handled by this connection
  - getConnector
```
public Connector getConnector()
```
  - getHttpTransport
```
public HttpTransport getHttpTransport()
```
  - 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.
  - 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.
  - getByteBufferPool
```
public ByteBufferPool getByteBufferPool()
```
  - getHttpConfiguration
```
public HttpConfiguration getHttpConfiguration()
```
  - getServer
```
public Server getServer()
```
  - getRequest
```
public Request getRequest()
```
  - getResponse
```
public Response getResponse()
```
  - getEndPoint
```
public EndPoint getEndPoint()
```
  - getLocalAddress
```
public InetSocketAddress getLocalAddress()
```
  - getRemoteAddress
```
public InetSocketAddress getRemoteAddress()
```
  - getHeaderCacheSize
```
public int getHeaderCacheSize()
```
    Specified by:
    
    getHeaderCacheSize in interface HttpParser.HttpHandler<T>
  - continue100
```
public void continue100(int available)
                 throws 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.
    
    Throws:
    
    IOException - if the InputStream cannot be created
  - reset
```
public void reset()
```
  - run
```
public void run()
```
    Specified by:
    
    run in interface Runnable
  - handle
```
public boolean handle()
```
    Returns:
    True if the channel is ready to continue handling (ie it is not suspended)
  - handleException
```
protected void handleException(Throwable x)
```
    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:
    x - the Throwable that caused the problem
  - isExpecting100Continue
```
public boolean isExpecting100Continue()
```
  - isExpecting102Processing
```
public boolean isExpecting102Processing()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - proxied
```
public void proxied(String protocol,
           String sAddr,
           String dAddr,
           int sPort,
           int dPort)
```
    Specified by:
    
    proxied in interface HttpParser.ProxyHandler
  - startRequest
```
public boolean startRequest(HttpMethod httpMethod,
                   String method,
                   ByteBuffer uri,
                   HttpVersion version)
```
    Specified by:
    
    startRequest in interface HttpParser.RequestHandler<T>
  - parsedHeader
```
public boolean parsedHeader(HttpField field)
```
    Specified by:
    
    parsedHeader in interface HttpParser.HttpHandler<T>
  - parsedHostHeader
```
public boolean parsedHostHeader(String host,
                       int port)
```
    Specified by:
    
    parsedHostHeader in interface HttpParser.RequestHandler<T>
  - headerComplete
```
public boolean headerComplete()
```
    Specified by:
    
    headerComplete in interface HttpParser.HttpHandler<T>
  - content
```
public boolean content(T item)
```
    Specified by:
    
    content in interface HttpParser.HttpHandler<T>
  - messageComplete
```
public boolean messageComplete()
```
    Specified by:
    
    messageComplete in interface HttpParser.HttpHandler<T>
  - earlyEOF
```
public void earlyEOF()
```
    Specified by:
    
    earlyEOF in interface HttpParser.HttpHandler<T>
  - badMessage
```
public void badMessage(int status,
              String reason)
```
    Specified by:
    
    badMessage in interface HttpParser.HttpHandler<T>
  - sendResponse
```
protected boolean sendResponse(HttpGenerator.ResponseInfo info,
                   ByteBuffer content,
                   boolean complete,
                   org.eclipse.jetty.util.Callback callback)
```
  - sendResponse
```
protected boolean sendResponse(HttpGenerator.ResponseInfo info,
                   ByteBuffer content,
                   boolean complete)
                        throws IOException
```
    Throws:
    
    IOException
  - isCommitted
```
public boolean isCommitted()
```
  - write
```
protected void write(ByteBuffer content,
         boolean complete,
         org.eclipse.jetty.util.Callback callback)
```
    Non-Blocking write, committing the response if needed.
    
    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(Runnable task)
```
  - getScheduler
```
public org.eclipse.jetty.util.thread.Scheduler getScheduler()
```
  - useDirectBuffers
```
public boolean useDirectBuffers()
```
    Returns:
    true if the HttpChannel can efficiently use direct buffer (typically this means it is not over SSL or a multiplexed protocol)
  - abort
```
public void abort()
```
    If a write or similar to this channel fails this method should be called. The standard implementation is to call HttpTransport.abort()

Class HttpChannel<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

HttpChannel

Method Detail

getCurrentHttpChannel

setCurrentHttpChannel

getState

getHttpVersion

getRequests

getConnector

getHttpTransport

getIdleTimeout

setIdleTimeout

getByteBufferPool

getHttpConfiguration

getServer

getRequest

getResponse

getEndPoint

getLocalAddress

getRemoteAddress

getHeaderCacheSize

continue100

reset

run

handle

handleException

isExpecting100Continue

isExpecting102Processing

toString

proxied

startRequest

parsedHeader

parsedHostHeader

headerComplete

content

messageComplete

earlyEOF

badMessage

sendResponse

sendResponse

isCommitted

write

execute

getScheduler

useDirectBuffers

abort