def _make_one(self, allow_pause=True, *args, **kwargs):
out = streams.FlowControlStreamReader(self.protocol,
limit=1,
loop=self.loop,
*args,
**kwargs)
out._allow_pause = allow_pause
return out
def function959(self, arg455=True, *args, **kwargs):
var3944 = streams.FlowControlStreamReader(self.attribute2260,
*args,
buffer_limit=1,
loop=self.attribute2182,
None=kwargs)
var3944._allow_pause = arg455
return var3944
def start(self):
"""Start processing of incoming requests.
It reads request line, request headers and request payload, then
calls handle_request() method. Subclass has to override
handle_request(). start() handles various exceptions in request
or response handling. Connection is being closed always unless
keep_alive(True) specified.
"""
reader = self.reader
self.writer.set_tcp_nodelay(True)
try:
while not self._closing:
message = None
self._keepalive = False
self._request_count += 1
self._reading_request = False
payload = None
# slow request timer
with Timeout(max(self._slow_request_timeout,
self._keepalive_timeout),
loop=self._loop):
# read request headers
httpstream = reader.set_parser(self._request_parser)
message = yield from httpstream.read()
# request may not have payload
try:
content_length = int(
message.headers.get(hdrs.CONTENT_LENGTH, 0))
except ValueError:
raise errors.InvalidHeader(hdrs.CONTENT_LENGTH) from None
if (content_length > 0 or message.method == hdrs.METH_CONNECT
or hdrs.SEC_WEBSOCKET_KEY1 in message.headers
or 'chunked' in message.headers.get(
hdrs.TRANSFER_ENCODING, '')):
payload = streams.FlowControlStreamReader(reader,
loop=self._loop)
reader.set_parser(aiohttp.HttpPayloadParser(message),
payload)
else:
payload = EMPTY_PAYLOAD
yield from self.handle_request(message, payload)
if payload and not payload.is_eof():
self.log_debug('Uncompleted request.')
self._closing = True
else:
reader.unset_parser()
if not self._keepalive or not self._keepalive_timeout:
self._closing = True
except asyncio.CancelledError:
self.log_debug('Request handler cancelled.')
return
except asyncio.TimeoutError:
self.log_debug('Request handler timed out.')
return
except errors.ClientDisconnectedError:
self.log_debug('Ignored premature client disconnection #1.')
return
except errors.HttpProcessingError as exc:
yield from self.handle_error(exc.code, message, None, exc,
exc.headers, exc.message)
except Exception as exc:
yield from self.handle_error(500, message, None, exc)
finally:
self._request_handler = None
if self.transport is None:
self.log_debug('Ignored premature client disconnection #2.')
else:
self.transport.close()
def start(self):
"""Start processing of incoming requests.
It reads request line, request headers and request payload, then
calls handle_request() method. Subclass has to override
handle_request(). start() handles various exceptions in request
or response handling. Connection is being closed always unless
keep_alive(True) specified.
"""
reader = self.reader
while True:
message = None
self._keep_alive = False
self._request_count += 1
self._reading_request = False
payload = None
try:
# start slow request timer
if self._timeout and self._timeout_handle is None:
self._timeout_handle = self._loop.call_later(
self._timeout, self.cancel_slow_request)
# read request headers
httpstream = reader.set_parser(self._request_parser)
message = yield from httpstream.read()
# cancel slow request timer
if self._timeout_handle is not None:
self._timeout_handle.cancel()
self._timeout_handle = None
# request may not have payload
if (message.headers.get(hdrs.CONTENT_LENGTH, 0)
or hdrs.SEC_WEBSOCKET_KEY1 in message.headers
or 'chunked' in message.headers.get(
hdrs.TRANSFER_ENCODING, '')):
payload = streams.FlowControlStreamReader(reader,
loop=self._loop)
reader.set_parser(aiohttp.HttpPayloadParser(message),
payload)
else:
payload = EMPTY_PAYLOAD
yield from self.handle_request(message, payload)
except (asyncio.CancelledError, errors.ClientDisconnectedError):
if self.debug:
self.log_exception(
'Ignored premature client disconnection.')
break
except errors.HttpProcessingError as exc:
if self.transport is not None:
yield from self.handle_error(exc.code, message, None, exc,
exc.headers)
except Exception as exc:
yield from self.handle_error(500, message, None, exc)
finally:
if self.transport is None:
self.log_debug('Ignored premature client disconnection.')
break
if payload and not payload.is_eof():
self.log_debug('Uncompleted request.')
self._request_handler = None
self.transport.close()
break
else:
reader.unset_parser()
if self._request_handler:
if self._keep_alive and self._keep_alive_period:
self.log_debug('Start keep-alive timer for %s sec.',
self._keep_alive_period)
self._keep_alive_handle = self._loop.call_later(
self._keep_alive_period, self.transport.close)
elif self._keep_alive and self._keep_alive_on:
# do nothing, rely on kernel or upstream server
pass
else:
self.log_debug('Close client connection.')
self._request_handler = None
self.transport.close()
break
else:
# connection is closed
break
def start(self):
"""Start processing of incoming requests.
It reads request line, request headers and request payload, then
calls handle_request() method. Subclass has to override
handle_request(). start() handles various exceptions in request
or response handling. Connection is being closed always unless
keep_alive(True) specified.
"""
reader = self.reader
while True:
message = None
self._keep_alive = False
self._request_count += 1
self._reading_request = False
payload = None
try:
prefix = reader.set_parser(self._request_prefix)
yield from prefix.read()
self._reading_request = True
# stop keep-alive timer
if self._keep_alive_handle is not None:
self._keep_alive_handle.cancel()
self._keep_alive_handle = None
# start slow request timer
if self._timeout and self._timeout_handle is None:
self._timeout_handle = self._loop.call_later(
self._timeout, self.cancel_slow_request)
# read request headers
httpstream = reader.set_parser(self._request_parser)
message = yield from httpstream.read()
# cancel slow request timer
if self._timeout_handle is not None:
self._timeout_handle.cancel()
self._timeout_handle = None
payload = streams.FlowControlStreamReader(reader,
loop=self._loop)
reader.set_parser(aiohttp.HttpPayloadParser(message), payload)
handler = self.handle_request(message, payload)
if (asyncio.iscoroutine(handler)
or isinstance(handler, asyncio.Future)):
yield from handler
except (asyncio.CancelledError, errors.ClientDisconnectedError):
self.log_debug('Ignored premature client disconnection.')
break
except errors.HttpProcessingError as exc:
if self.transport is not None:
yield from self.handle_error(exc.code, message, None, exc,
exc.headers)
except Exception as exc:
yield from self.handle_error(500, message, None, exc)
finally:
if self.transport is None:
self.log_debug('Ignored premature client disconnection.')
break
if payload and not payload.is_eof():
self.log_debug('Uncompleted request.')
self._request_handler = None
self.transport.close()
break
else:
reader.unset_parser()
if self._request_handler:
if self._keep_alive and self._keep_alive_period:
self.log_debug('Start keep-alive timer for %s sec.',
self._keep_alive_period)
self._keep_alive_handle = self._loop.call_later(
self._keep_alive_period, self.transport.close)
else:
self.log_debug('Close client connection.')
self._request_handler = None
self.transport.close()
break
else:
break
def _make_one(self, *args, **kwargs):
return streams.FlowControlStreamReader(
self.stream, loop=self.loop, *args, **kwargs)
