HttpChannel (Jetty :: Project 9.2.6.v20141205 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:

HttpChannelOverFCGI, HttpChannelOverSPDY, 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)` Called to signal that a bad HTTP message has been received.
`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()` Called to signal that an EOF was received unexpectedly during the parsing of a HTTP message
`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()`
`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)` This is the method called by parser when a HTTP Header name and value is found
`boolean`	`parsedHostHeader(String host, int port)` This is the method called by the parser after it has parsed the host header (and checked it's format).
`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, 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)` This is the method called by parser when the HTTP request line is parsed
`String`	`toString()`
`boolean`	`useDirectBuffers()`
`protected void`	`write(ByteBuffer content, boolean complete, 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 {@link 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>
    
    Returns:
    the size in bytes of the per parser header cache
  - 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)
```
    Description copied from interface: HttpParser.RequestHandler
    
    This is the method called by parser when the HTTP request line is parsed
    
    Specified by:
    
    startRequest in interface HttpParser.RequestHandler<T>
    
    Parameters:
    httpMethod - The method as enum if of a known type
    method - The method as a string
    uri - The raw bytes of the URI. These are copied into a ByteBuffer that will not be changed until this parser is reset and reused.
    
    Returns:
    true if handling parsing should return.
  - parsedHeader
```
public boolean parsedHeader(HttpField field)
```
    Description copied from interface: HttpParser.HttpHandler
    
    This is the method called by parser when a HTTP Header name and value is found
    
    Specified by:
    
    parsedHeader in interface HttpParser.HttpHandler<T>
    
    Parameters:
    field - The field parsed
    
    Returns:
    True if the parser should return to its caller
  - parsedHostHeader
```
public boolean parsedHostHeader(String host,
                       int port)
```
    Description copied from interface: HttpParser.RequestHandler
    
    This is the method called by the parser after it has parsed the host header (and checked it's format). This is called after the HttpParser.HttpHandler.parsedHeader(HttpField) methods and before HttpHandler#headerComplete();
    
    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()
```
    Description copied from interface: HttpParser.HttpHandler
    
    Called to signal that an EOF was received unexpectedly during the parsing of a HTTP message
    
    Specified by:
    
    earlyEOF in interface HttpParser.HttpHandler<T>
  - badMessage
```
public void badMessage(int status,
              String reason)
```
    Description copied from interface: HttpParser.HttpHandler
    
    Called to signal that a bad HTTP message has been received.
    
    Specified by:
    
    badMessage in interface HttpParser.HttpHandler<T>
    
    Parameters:
    status - The bad status to send
    reason - The textual reason for badness
  - sendResponse
```
protected boolean sendResponse(HttpGenerator.ResponseInfo info,
                   ByteBuffer content,
                   boolean complete,
                   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,
         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 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