class HTTPClientChannelRequest(HTTPParser):
parseCloseAsEnd = True
outgoing_version = "HTTP/1.1"
chunkedOut = False
finished = False
closeAfter = False
def __init__(self, channel, request, closeAfter):
HTTPParser.__init__(self, channel)
self.request = request
self.closeAfter = closeAfter
self.transport = self.channel.transport
self.responseDefer = Deferred()
def submit(self):
l = []
request = self.request
if request.method == "HEAD":
# No incoming data will arrive.
self.length = 0
l.append('%s %s %s\r\n' % (request.method, request.uri,
self.outgoing_version))
if request.headers is not None:
for name, valuelist in request.headers.getAllRawHeaders():
for value in valuelist:
l.append("%s: %s\r\n" % (name, value))
if request.stream is not None:
if request.stream.length is not None:
l.append("%s: %s\r\n" % ('Content-Length', request.stream.length))
else:
# Got a stream with no length. Send as chunked and hope, against
# the odds, that the server actually supports chunked uploads.
l.append("%s: %s\r\n" % ('Transfer-Encoding', 'chunked'))
self.chunkedOut = True
if self.closeAfter:
l.append("%s: %s\r\n" % ('Connection', 'close'))
else:
l.append("%s: %s\r\n" % ('Connection', 'Keep-Alive'))
l.append("\r\n")
self.transport.writeSequence(l)
d = StreamProducer(request.stream).beginProducing(self)
d.addCallback(self._finish).addErrback(self._error)
def registerProducer(self, producer, streaming):
"""
Register a producer.
"""
self.transport.registerProducer(producer, streaming)
def unregisterProducer(self):
self.transport.unregisterProducer()
def write(self, data):
if not data:
return
elif self.chunkedOut:
self.transport.writeSequence(("%X\r\n" % len(data), data, "\r\n"))
else:
self.transport.write(data)
def _finish(self, x):
"""
We are finished writing data.
"""
if self.chunkedOut:
# write last chunk and closing CRLF
self.transport.write("0\r\n\r\n")
self.finished = True
self.channel.requestWriteFinished(self)
del self.transport
def _error(self, err):
"""
Abort parsing, and depending of the status of the request, either fire
the C{responseDefer} if no response has been sent yet, or close the
stream.
"""
self.abortParse()
if hasattr(self, 'stream') and self.stream is not None:
self.stream.finish(err)
else:
self.responseDefer.errback(err)
def _abortWithError(self, errcode, text):
"""
Abort parsing by forwarding a C{ProtocolError} to C{_error}.
"""
self._error(ProtocolError(text))
def connectionLost(self, reason):
self._error(reason)
def gotInitialLine(self, initialLine):
parts = initialLine.split(' ', 2)
# Parse the initial request line
if len(parts) != 3:
self._abortWithError(BAD_REQUEST,
"Bad response line: %s" % (initialLine,))
return
strversion, self.code, message = parts
try:
protovers = parseVersion(strversion)
if protovers[0] != 'http':
raise ValueError()
except ValueError:
self._abortWithError(BAD_REQUEST,
"Unknown protocol: %s" % (strversion,))
return
self.version = protovers[1:3]
# Ensure HTTP 0 or HTTP 1.
if self.version[0] != 1:
self._abortWithError(HTTP_VERSION_NOT_SUPPORTED,
'Only HTTP 1.x is supported.')
return
## FIXME: Actually creates Response, function is badly named!
def createRequest(self):
self.stream = ProducerStream(self.length)
self.response = Response(self.code, self.inHeaders, self.stream)
self.stream.registerProducer(self, True)
del self.inHeaders
## FIXME: Actually processes Response, function is badly named!
def processRequest(self):
self.responseDefer.callback(self.response)
def handleContentChunk(self, data):
self.stream.write(data)
def handleContentComplete(self):
self.stream.finish()
def createRequest(self):
self.stream = ProducerStream(self.length)
self.response = Response(self.code, self.inHeaders, self.stream)
self.stream.registerProducer(self, True)
del self.inHeaders
