Known subclasses: twisted.web.proxy.Proxy, twisted.web.proxy.ReverseProxy

Implements interfaces: twisted.internet.interfaces.IConsumer, twisted.internet.interfaces.IPushProducer, twisted.internet.interfaces.ITransport

A receiver for HTTP requests.

The HTTPChannel provides interfaces.ITransport and interfaces.IConsumer to the Request objects it creates. It also implements interfaces.IPushProducer to self.transport, allowing the transport to pause it.

Instance Variable MAX_LENGTH Maximum length for initial request line and each line from the header.
Instance Variable maxHeaders Maximum number of headers allowed per request. (type: int)
Instance Variable totalHeadersSize Maximum bytes for request line plus all headers from the request. (type: int)
Method __init__ Undocumented
Method connectionMade Called when a connection is made.
Method lineReceived Called for each line from request until the end of headers when it enters binary mode.
Method headerReceived Do pre-processing (for content-length) and store this header away. Enforce the per-request header limit.
Method allContentReceived Undocumented
Method rawDataReceived Override this for when raw data is received.
Method allHeadersReceived Undocumented
Method checkPersistence Check if the channel should close or not.
Method requestDone Called by first request in queue when it is done.
Method timeoutConnection Called when the connection times out.
Method connectionLost Called when the connection is shut down.
Method isSecure Return True if this channel is using a secure transport.
Method writeHeaders Called by Request objects to write a complete set of HTTP headers to a transport.
Method write Called by Request objects to write response data.
Method writeSequence Write a list of strings to the HTTP response.
Method getPeer Get the remote address of this connection.
Method getHost Get the local address of this connection.
Method loseConnection Closes the connection. Will write any data that is pending to be sent on the network, but if this response has not yet been written to the network will not write anything.
Method registerProducer Register to receive data from a producer.
Method unregisterProducer Stop consuming data from a producer, without disconnecting.
Method stopProducing Stop producing data.
Method pauseProducing Pause producing data.
Method resumeProducing Resume producing data.
Instance Variable _transferDecoder None or a decoder instance if the request body uses the chunked Transfer-Encoding. (type: _ChunkedTransferDecoder)
Instance Variable _receivedHeaderSize Bytes received so far for the header. (type: int)
Instance Variable _handlingRequest Whether a request is currently being processed. (type: bool)
Instance Variable _dataBuffer Any data that has been received from the connection while processing an outstanding request. (type: list of bytes)
Instance Variable _networkProducer Either the transport, if it provides interfaces.IPushProducer, or a null implementation of interfaces.IPushProducer. Used to attempt to prevent the transport from producing excess data when we're responding to a request. (type: interfaces.IPushProducer)
Instance Variable _requestProducer If the Request object or anything it calls registers itself as an interfaces.IProducer, it will be stored here. This is used to create a producing pipeline: pause/resume producing methods will be propagated from the transport, through the HTTPChannel instance, to the c{_requestProducer}.

The reason we proxy through the producing methods rather than the old behaviour (where we literally just set the Request object as the producer on the transport) is because we want to be able to exert backpressure on the client to prevent it from sending in arbitrarily many requests without ever reading responses. Essentially, if the client never reads our responses we will eventually stop reading its requests.

(type: interfaces.IPushProducer)
Instance Variable _requestProducerStreaming A boolean that tracks whether the producer on the Request side of this channel has registered itself as a interfaces.IPushProducer or an interfaces.IPullProducer. (type: bool or None)
Instance Variable _waitingForTransport A boolean that tracks whether the transport has asked us to stop producing. This is used to keep track of what we're waiting for: if the transport has asked us to stop producing then we don't want to unpause the transport until it asks us to produce again. (type: bool)
Method _finishRequestBody Undocumented
Method _send100Continue Sends a 100 Continue response, used to signal to clients that further processing will be performed.
Method _respondToBadRequestAndDisconnect This is a quick and dirty way of responding to bad requests.

Inherited from TimeoutMixin:

Class Variable timeOut The number of seconds after which to timeout the connection.
Method callLater Wrapper around reactor.callLater for test purpose.
Method resetTimeout Reset the timeout count down.
Method setTimeout Change the timeout period
Method __timedOut Undocumented

Inherited from TimeoutMixin:

Class Variable timeOut The number of seconds after which to timeout the connection.
Method callLater Wrapper around reactor.callLater for test purpose.
Method resetTimeout Reset the timeout count down.
Method setTimeout Change the timeout period
Method __timedOut Undocumented

Inherited from TimeoutMixin:

Class Variable timeOut The number of seconds after which to timeout the connection.
Method callLater Wrapper around reactor.callLater for test purpose.
Method resetTimeout Reset the timeout count down.
Method setTimeout Change the timeout period
Method __timedOut Undocumented

Inherited from TimeoutMixin:

Class Variable timeOut The number of seconds after which to timeout the connection.
Method callLater Wrapper around reactor.callLater for test purpose.
Method resetTimeout Reset the timeout count down.
Method setTimeout Change the timeout period
Method __timedOut Undocumented
MAX_LENGTH =
Maximum length for initial request line and each line from the header.
_transferDecoder =
None or a decoder instance if the request body uses the chunked Transfer-Encoding. (type: _ChunkedTransferDecoder)
maxHeaders =
Maximum number of headers allowed per request. (type: int)
totalHeadersSize =
Maximum bytes for request line plus all headers from the request. (type: int)
_receivedHeaderSize =
Bytes received so far for the header. (type: int)
_handlingRequest =
Whether a request is currently being processed. (type: bool)
_dataBuffer =
Any data that has been received from the connection while processing an outstanding request. (type: list of bytes)
_networkProducer =
Either the transport, if it provides interfaces.IPushProducer, or a null implementation of interfaces.IPushProducer. Used to attempt to prevent the transport from producing excess data when we're responding to a request. (type: interfaces.IPushProducer)
_requestProducer =
If the Request object or anything it calls registers itself as an interfaces.IProducer, it will be stored here. This is used to create a producing pipeline: pause/resume producing methods will be propagated from the transport, through the HTTPChannel instance, to the c{_requestProducer}.

The reason we proxy through the producing methods rather than the old behaviour (where we literally just set the Request object as the producer on the transport) is because we want to be able to exert backpressure on the client to prevent it from sending in arbitrarily many requests without ever reading responses. Essentially, if the client never reads our responses we will eventually stop reading its requests.

(type: interfaces.IPushProducer)
_requestProducerStreaming =
A boolean that tracks whether the producer on the Request side of this channel has registered itself as a interfaces.IPushProducer or an interfaces.IPullProducer. (type: bool or None)
_waitingForTransport =
A boolean that tracks whether the transport has asked us to stop producing. This is used to keep track of what we're waiting for: if the transport has asked us to stop producing then we don't want to unpause the transport until it asks us to produce again. (type: bool)
def __init__(self): (source)
Undocumented
def connectionMade(self): (source)

Called when a connection is made.

This may be considered the initializer of the protocol, because it is called when the connection is completed. For clients, this is called once the connection to the server has been established; for servers, this is called after an accept() call stops blocking and a socket has been received. If you need to send any greeting or initial message, do it here.

def lineReceived(self, line): (source)

Called for each line from request until the end of headers when it enters binary mode.

def _finishRequestBody(self, data): (source)
Undocumented
def headerReceived(self, line): (source)

Do pre-processing (for content-length) and store this header away. Enforce the per-request header limit.

ParameterslineA line from the header section of a request, excluding the line delimiter. (type: bytes)
ReturnsA flag indicating whether the header was valid. (type: bool)
def allContentReceived(self): (source)
Undocumented
def rawDataReceived(self, data): (source)

Override this for when raw data is received.

def allHeadersReceived(self): (source)
Undocumented
def checkPersistence(self, request, version): (source)

Check if the channel should close or not.

ParametersrequestThe request most recently received over this channel against which checks will be made to determine if this connection can remain open after a matching response is returned.
versionThe version of the request. (type: bytes)
ReturnsA flag which, if True, indicates that this connection may remain open to receive another request; if False, the connection must be closed in order to indicate the completion of the response to request. (type: bool)
def requestDone(self, request): (source)

Called by first request in queue when it is done.

def timeoutConnection(self): (source)

Called when the connection times out.

Override to define behavior other than dropping the connection.

def connectionLost(self, reason): (source)

Called when the connection is shut down.

Clear any circular references here, and any external references to this Protocol. The connection has been closed.

def isSecure(self): (source)

Return True if this channel is using a secure transport.

Normally this method returns True if this instance is using a transport that implements interfaces.ISSLTransport.

ReturnsTrue if this request is secure (type: bool)
def writeHeaders(self, version, code, reason, headers): (source)

Called by Request objects to write a complete set of HTTP headers to a transport.

ParametersversionThe HTTP version in use. (type: bytes)
codeThe HTTP status code to write. (type: bytes)
reasonThe HTTP reason phrase to write. (type: bytes)
headersThe headers to write to the transport. (type: twisted.web.http_headers.Headers)
def write(self, data): (source)

Called by Request objects to write response data.

ParametersdataThe data chunk to write to the stream. (type: bytes)
ReturnsNone
def writeSequence(self, iovec): (source)

Write a list of strings to the HTTP response.

ParametersiovecA list of byte strings to write to the stream.
ReturnsNone
def getPeer(self): (source)

Get the remote address of this connection.

ReturnsAn IAddress provider.
def getHost(self): (source)

Get the local address of this connection.

ReturnsAn IAddress provider.
def loseConnection(self): (source)

Closes the connection. Will write any data that is pending to be sent on the network, but if this response has not yet been written to the network will not write anything.

ReturnsNone
def registerProducer(self, producer, streaming): (source)

Register to receive data from a producer.

This sets self to be a consumer for a producer. When this object runs out of data (as when a send(2) call on a socket succeeds in moving the last data from a userspace buffer into a kernelspace buffer), it will ask the producer to resumeProducing().

For IPullProducer providers, resumeProducing will be called once each time data is required.

For IPushProducer providers, pauseProducing will be called whenever the write buffer fills up and resumeProducing will only be called when it empties.

ParametersproducerThe IProducer that will be producing data. (type: IProducer provider)
streamingTrue if producer provides IPushProducer, False if producer provides IPullProducer. (type: bool)
ReturnsNone
RaisesRuntimeErrorIf a producer is already registered.
def unregisterProducer(self): (source)

Stop consuming data from a producer, without disconnecting.

ReturnsNone
def stopProducing(self): (source)

Stop producing data.

The HTTPChannel doesn't *actually* implement this, beacuse the assumption is that it will only be called just before loseConnection is called. There's nothing sensible we can do other than call loseConnection anyway.

def pauseProducing(self): (source)

Pause producing data.

This will be called by the transport when the send buffers have been filled up. We want to simultaneously pause the producing Request object and also pause our transport.

The logic behind pausing the transport is specifically to avoid issues like https://twistedmatrix.com/trac/ticket/8868. In this case, our inability to send does not prevent us handling more requests, which means we increasingly queue up more responses in our send buffer without end. The easiest way to handle this is to ensure that if we are unable to send our responses, we will not read further data from the connection until the client pulls some data out. This is a bit of a blunt instrument, but it's ok.

Note that this potentially interacts with timeout handling in a positive way. Once the transport is paused the client may run into a timeout which will cause us to tear the connection down. That's a good thing!

def resumeProducing(self): (source)

Resume producing data.

This will be called by the transport when the send buffer has dropped enough to actually send more data. When this happens we can unpause any outstanding Request producers we have, and also unpause our transport.

def _send100Continue(self): (source)

Sends a 100 Continue response, used to signal to clients that further processing will be performed.

def _respondToBadRequestAndDisconnect(self): (source)

This is a quick and dirty way of responding to bad requests.

As described by HTTP standard we should be patient and accept the whole request from the client before sending a polite bad request response, even in the case when clients send tons of data.

ParameterstransportTransport handling connection to the client. (type: interfaces.ITransport)
API Documentation for Twisted, generated by pydoctor at 2017-02-11 20:06:04.