import collections
|
|
import datetime
|
|
import enum
|
|
import json
|
|
import math
|
|
import time
|
|
import warnings
|
|
import zlib
|
|
from email.utils import parsedate
|
|
from http.cookies import SimpleCookie
|
|
|
|
from multidict import CIMultiDict, CIMultiDictProxy
|
|
|
|
from . import hdrs, payload
|
|
from .helpers import HeadersMixin, rfc822_formatted_time, sentinel
|
|
from .http import RESPONSES, SERVER_SOFTWARE, HttpVersion10, HttpVersion11
|
|
|
|
|
|
__all__ = ('ContentCoding', 'StreamResponse', 'Response', 'json_response')
|
|
|
|
|
|
class ContentCoding(enum.Enum):
|
|
# The content codings that we have support for.
|
|
#
|
|
# Additional registered codings are listed at:
|
|
# https://www.iana.org/assignments/http-parameters/http-parameters.xhtml#content-coding
|
|
deflate = 'deflate'
|
|
gzip = 'gzip'
|
|
identity = 'identity'
|
|
|
|
|
|
############################################################
|
|
# HTTP Response classes
|
|
############################################################
|
|
|
|
|
|
class StreamResponse(collections.MutableMapping, HeadersMixin):
|
|
|
|
_length_check = True
|
|
|
|
def __init__(self, *, status=200, reason=None, headers=None):
|
|
self._body = None
|
|
self._keep_alive = None
|
|
self._chunked = False
|
|
self._compression = False
|
|
self._compression_force = None
|
|
self._cookies = SimpleCookie()
|
|
|
|
self._req = None
|
|
self._payload_writer = None
|
|
self._eof_sent = False
|
|
self._body_length = 0
|
|
self._state = {}
|
|
|
|
if headers is not None:
|
|
self._headers = CIMultiDict(headers)
|
|
else:
|
|
self._headers = CIMultiDict()
|
|
|
|
self.set_status(status, reason)
|
|
|
|
@property
|
|
def prepared(self):
|
|
return self._payload_writer is not None
|
|
|
|
@property
|
|
def task(self):
|
|
return getattr(self._req, 'task', None)
|
|
|
|
@property
|
|
def status(self):
|
|
return self._status
|
|
|
|
@property
|
|
def chunked(self):
|
|
return self._chunked
|
|
|
|
@property
|
|
def compression(self):
|
|
return self._compression
|
|
|
|
@property
|
|
def reason(self):
|
|
return self._reason
|
|
|
|
def set_status(self, status, reason=None, _RESPONSES=RESPONSES):
|
|
assert not self.prepared, \
|
|
'Cannot change the response status code after ' \
|
|
'the headers have been sent'
|
|
self._status = int(status)
|
|
if reason is None:
|
|
try:
|
|
reason = _RESPONSES[self._status][0]
|
|
except Exception:
|
|
reason = ''
|
|
self._reason = reason
|
|
|
|
@property
|
|
def keep_alive(self):
|
|
return self._keep_alive
|
|
|
|
def force_close(self):
|
|
self._keep_alive = False
|
|
|
|
@property
|
|
def body_length(self):
|
|
return self._body_length
|
|
|
|
@property
|
|
def output_length(self):
|
|
warnings.warn('output_length is deprecated', DeprecationWarning)
|
|
return self._payload_writer.buffer_size
|
|
|
|
def enable_chunked_encoding(self, chunk_size=None):
|
|
"""Enables automatic chunked transfer encoding."""
|
|
self._chunked = True
|
|
|
|
if hdrs.CONTENT_LENGTH in self._headers:
|
|
raise RuntimeError("You can't enable chunked encoding when "
|
|
"a content length is set")
|
|
if chunk_size is not None:
|
|
warnings.warn('Chunk size is deprecated #1615', DeprecationWarning)
|
|
|
|
def enable_compression(self, force=None):
|
|
"""Enables response compression encoding."""
|
|
# Backwards compatibility for when force was a bool <0.17.
|
|
if type(force) == bool:
|
|
force = ContentCoding.deflate if force else ContentCoding.identity
|
|
elif force is not None:
|
|
assert isinstance(force, ContentCoding), ("force should one of "
|
|
"None, bool or "
|
|
"ContentEncoding")
|
|
|
|
self._compression = True
|
|
self._compression_force = force
|
|
|
|
@property
|
|
def headers(self):
|
|
return self._headers
|
|
|
|
@property
|
|
def cookies(self):
|
|
return self._cookies
|
|
|
|
def set_cookie(self, name, value, *, expires=None,
|
|
domain=None, max_age=None, path='/',
|
|
secure=None, httponly=None, version=None):
|
|
"""Set or update response cookie.
|
|
|
|
Sets new cookie or updates existent with new value.
|
|
Also updates only those params which are not None.
|
|
"""
|
|
|
|
old = self._cookies.get(name)
|
|
if old is not None and old.coded_value == '':
|
|
# deleted cookie
|
|
self._cookies.pop(name, None)
|
|
|
|
self._cookies[name] = value
|
|
c = self._cookies[name]
|
|
|
|
if expires is not None:
|
|
c['expires'] = expires
|
|
elif c.get('expires') == 'Thu, 01 Jan 1970 00:00:00 GMT':
|
|
del c['expires']
|
|
|
|
if domain is not None:
|
|
c['domain'] = domain
|
|
|
|
if max_age is not None:
|
|
c['max-age'] = max_age
|
|
elif 'max-age' in c:
|
|
del c['max-age']
|
|
|
|
c['path'] = path
|
|
|
|
if secure is not None:
|
|
c['secure'] = secure
|
|
if httponly is not None:
|
|
c['httponly'] = httponly
|
|
if version is not None:
|
|
c['version'] = version
|
|
|
|
def del_cookie(self, name, *, domain=None, path='/'):
|
|
"""Delete cookie.
|
|
|
|
Creates new empty expired cookie.
|
|
"""
|
|
# TODO: do we need domain/path here?
|
|
self._cookies.pop(name, None)
|
|
self.set_cookie(name, '', max_age=0,
|
|
expires="Thu, 01 Jan 1970 00:00:00 GMT",
|
|
domain=domain, path=path)
|
|
|
|
@property
|
|
def content_length(self):
|
|
# Just a placeholder for adding setter
|
|
return super().content_length
|
|
|
|
@content_length.setter
|
|
def content_length(self, value):
|
|
if value is not None:
|
|
value = int(value)
|
|
if self._chunked:
|
|
raise RuntimeError("You can't set content length when "
|
|
"chunked encoding is enable")
|
|
self._headers[hdrs.CONTENT_LENGTH] = str(value)
|
|
else:
|
|
self._headers.pop(hdrs.CONTENT_LENGTH, None)
|
|
|
|
@property
|
|
def content_type(self):
|
|
# Just a placeholder for adding setter
|
|
return super().content_type
|
|
|
|
@content_type.setter
|
|
def content_type(self, value):
|
|
self.content_type # read header values if needed
|
|
self._content_type = str(value)
|
|
self._generate_content_type_header()
|
|
|
|
@property
|
|
def charset(self):
|
|
# Just a placeholder for adding setter
|
|
return super().charset
|
|
|
|
@charset.setter
|
|
def charset(self, value):
|
|
ctype = self.content_type # read header values if needed
|
|
if ctype == 'application/octet-stream':
|
|
raise RuntimeError("Setting charset for application/octet-stream "
|
|
"doesn't make sense, setup content_type first")
|
|
if value is None:
|
|
self._content_dict.pop('charset', None)
|
|
else:
|
|
self._content_dict['charset'] = str(value).lower()
|
|
self._generate_content_type_header()
|
|
|
|
@property
|
|
def last_modified(self):
|
|
"""The value of Last-Modified HTTP header, or None.
|
|
|
|
This header is represented as a `datetime` object.
|
|
"""
|
|
httpdate = self.headers.get(hdrs.LAST_MODIFIED)
|
|
if httpdate is not None:
|
|
timetuple = parsedate(httpdate)
|
|
if timetuple is not None:
|
|
return datetime.datetime(*timetuple[:6],
|
|
tzinfo=datetime.timezone.utc)
|
|
return None
|
|
|
|
@last_modified.setter
|
|
def last_modified(self, value):
|
|
if value is None:
|
|
self.headers.pop(hdrs.LAST_MODIFIED, None)
|
|
elif isinstance(value, (int, float)):
|
|
self.headers[hdrs.LAST_MODIFIED] = time.strftime(
|
|
"%a, %d %b %Y %H:%M:%S GMT", time.gmtime(math.ceil(value)))
|
|
elif isinstance(value, datetime.datetime):
|
|
self.headers[hdrs.LAST_MODIFIED] = time.strftime(
|
|
"%a, %d %b %Y %H:%M:%S GMT", value.utctimetuple())
|
|
elif isinstance(value, str):
|
|
self.headers[hdrs.LAST_MODIFIED] = value
|
|
|
|
def _generate_content_type_header(self, CONTENT_TYPE=hdrs.CONTENT_TYPE):
|
|
params = '; '.join("%s=%s" % i for i in self._content_dict.items())
|
|
if params:
|
|
ctype = self._content_type + '; ' + params
|
|
else:
|
|
ctype = self._content_type
|
|
self.headers[CONTENT_TYPE] = ctype
|
|
|
|
def _do_start_compression(self, coding):
|
|
if coding != ContentCoding.identity:
|
|
self.headers[hdrs.CONTENT_ENCODING] = coding.value
|
|
self._payload_writer.enable_compression(coding.value)
|
|
# Compressed payload may have different content length,
|
|
# remove the header
|
|
self._headers.popall(hdrs.CONTENT_LENGTH, None)
|
|
|
|
def _start_compression(self, request):
|
|
if self._compression_force:
|
|
self._do_start_compression(self._compression_force)
|
|
else:
|
|
accept_encoding = request.headers.get(
|
|
hdrs.ACCEPT_ENCODING, '').lower()
|
|
for coding in ContentCoding:
|
|
if coding.value in accept_encoding:
|
|
self._do_start_compression(coding)
|
|
return
|
|
|
|
async def prepare(self, request):
|
|
if self._eof_sent:
|
|
return
|
|
if self._payload_writer is not None:
|
|
return self._payload_writer
|
|
|
|
await request._prepare_hook(self)
|
|
return await self._start(request)
|
|
|
|
async def _start(self, request,
|
|
HttpVersion10=HttpVersion10,
|
|
HttpVersion11=HttpVersion11,
|
|
CONNECTION=hdrs.CONNECTION,
|
|
DATE=hdrs.DATE,
|
|
SERVER=hdrs.SERVER,
|
|
CONTENT_TYPE=hdrs.CONTENT_TYPE,
|
|
CONTENT_LENGTH=hdrs.CONTENT_LENGTH,
|
|
SET_COOKIE=hdrs.SET_COOKIE,
|
|
SERVER_SOFTWARE=SERVER_SOFTWARE,
|
|
TRANSFER_ENCODING=hdrs.TRANSFER_ENCODING):
|
|
self._req = request
|
|
|
|
keep_alive = self._keep_alive
|
|
if keep_alive is None:
|
|
keep_alive = request.keep_alive
|
|
self._keep_alive = keep_alive
|
|
|
|
version = request.version
|
|
writer = self._payload_writer = request._payload_writer
|
|
|
|
headers = self._headers
|
|
for cookie in self._cookies.values():
|
|
value = cookie.output(header='')[1:]
|
|
headers.add(SET_COOKIE, value)
|
|
|
|
if self._compression:
|
|
self._start_compression(request)
|
|
|
|
if self._chunked:
|
|
if version != HttpVersion11:
|
|
raise RuntimeError(
|
|
"Using chunked encoding is forbidden "
|
|
"for HTTP/{0.major}.{0.minor}".format(request.version))
|
|
writer.enable_chunking()
|
|
headers[TRANSFER_ENCODING] = 'chunked'
|
|
if CONTENT_LENGTH in headers:
|
|
del headers[CONTENT_LENGTH]
|
|
elif self._length_check:
|
|
writer.length = self.content_length
|
|
if writer.length is None:
|
|
if version >= HttpVersion11:
|
|
writer.enable_chunking()
|
|
headers[TRANSFER_ENCODING] = 'chunked'
|
|
if CONTENT_LENGTH in headers:
|
|
del headers[CONTENT_LENGTH]
|
|
else:
|
|
keep_alive = False
|
|
|
|
headers.setdefault(CONTENT_TYPE, 'application/octet-stream')
|
|
headers.setdefault(DATE, rfc822_formatted_time())
|
|
headers.setdefault(SERVER, SERVER_SOFTWARE)
|
|
|
|
# connection header
|
|
if CONNECTION not in headers:
|
|
if keep_alive:
|
|
if version == HttpVersion10:
|
|
headers[CONNECTION] = 'keep-alive'
|
|
else:
|
|
if version == HttpVersion11:
|
|
headers[CONNECTION] = 'close'
|
|
|
|
# status line
|
|
status_line = 'HTTP/{}.{} {} {}'.format(
|
|
version[0], version[1], self._status, self._reason)
|
|
await writer.write_headers(status_line, headers)
|
|
|
|
return writer
|
|
|
|
async def write(self, data):
|
|
assert isinstance(data, (bytes, bytearray, memoryview)), \
|
|
"data argument must be byte-ish (%r)" % type(data)
|
|
|
|
if self._eof_sent:
|
|
raise RuntimeError("Cannot call write() after write_eof()")
|
|
if self._payload_writer is None:
|
|
raise RuntimeError("Cannot call write() before prepare()")
|
|
|
|
await self._payload_writer.write(data)
|
|
|
|
async def drain(self):
|
|
assert not self._eof_sent, "EOF has already been sent"
|
|
assert self._payload_writer is not None, \
|
|
"Response has not been started"
|
|
warnings.warn("drain method is deprecated, use await resp.write()",
|
|
DeprecationWarning,
|
|
stacklevel=2)
|
|
await self._payload_writer.drain()
|
|
|
|
async def write_eof(self, data=b''):
|
|
assert isinstance(data, (bytes, bytearray, memoryview)), \
|
|
"data argument must be byte-ish (%r)" % type(data)
|
|
|
|
if self._eof_sent:
|
|
return
|
|
|
|
assert self._payload_writer is not None, \
|
|
"Response has not been started"
|
|
|
|
await self._payload_writer.write_eof(data)
|
|
self._eof_sent = True
|
|
self._req = None
|
|
self._body_length = self._payload_writer.output_size
|
|
self._payload_writer = None
|
|
|
|
def __repr__(self):
|
|
if self._eof_sent:
|
|
info = "eof"
|
|
elif self.prepared:
|
|
info = "{} {} ".format(self._req.method, self._req.path)
|
|
else:
|
|
info = "not prepared"
|
|
return "<{} {} {}>".format(self.__class__.__name__,
|
|
self.reason, info)
|
|
|
|
def __getitem__(self, key):
|
|
return self._state[key]
|
|
|
|
def __setitem__(self, key, value):
|
|
self._state[key] = value
|
|
|
|
def __delitem__(self, key):
|
|
del self._state[key]
|
|
|
|
def __len__(self):
|
|
return len(self._state)
|
|
|
|
def __iter__(self):
|
|
return iter(self._state)
|
|
|
|
def __hash__(self):
|
|
return hash(id(self))
|
|
|
|
def __eq__(self, other):
|
|
return self is other
|
|
|
|
|
|
class Response(StreamResponse):
|
|
|
|
def __init__(self, *, body=None, status=200,
|
|
reason=None, text=None, headers=None, content_type=None,
|
|
charset=None):
|
|
if body is not None and text is not None:
|
|
raise ValueError("body and text are not allowed together")
|
|
|
|
if headers is None:
|
|
headers = CIMultiDict()
|
|
elif not isinstance(headers, (CIMultiDict, CIMultiDictProxy)):
|
|
headers = CIMultiDict(headers)
|
|
|
|
if content_type is not None and "charset" in content_type:
|
|
raise ValueError("charset must not be in content_type "
|
|
"argument")
|
|
|
|
if text is not None:
|
|
if hdrs.CONTENT_TYPE in headers:
|
|
if content_type or charset:
|
|
raise ValueError("passing both Content-Type header and "
|
|
"content_type or charset params "
|
|
"is forbidden")
|
|
else:
|
|
# fast path for filling headers
|
|
if not isinstance(text, str):
|
|
raise TypeError("text argument must be str (%r)" %
|
|
type(text))
|
|
if content_type is None:
|
|
content_type = 'text/plain'
|
|
if charset is None:
|
|
charset = 'utf-8'
|
|
headers[hdrs.CONTENT_TYPE] = (
|
|
content_type + '; charset=' + charset)
|
|
body = text.encode(charset)
|
|
text = None
|
|
else:
|
|
if hdrs.CONTENT_TYPE in headers:
|
|
if content_type is not None or charset is not None:
|
|
raise ValueError("passing both Content-Type header and "
|
|
"content_type or charset params "
|
|
"is forbidden")
|
|
else:
|
|
if content_type is not None:
|
|
if charset is not None:
|
|
content_type += '; charset=' + charset
|
|
headers[hdrs.CONTENT_TYPE] = content_type
|
|
|
|
super().__init__(status=status, reason=reason, headers=headers)
|
|
|
|
if text is not None:
|
|
self.text = text
|
|
else:
|
|
self.body = body
|
|
|
|
self._compressed_body = None
|
|
|
|
@property
|
|
def body(self):
|
|
return self._body
|
|
|
|
@body.setter
|
|
def body(self, body,
|
|
CONTENT_TYPE=hdrs.CONTENT_TYPE,
|
|
CONTENT_LENGTH=hdrs.CONTENT_LENGTH):
|
|
if body is None:
|
|
self._body = None
|
|
self._body_payload = False
|
|
elif isinstance(body, (bytes, bytearray)):
|
|
self._body = body
|
|
self._body_payload = False
|
|
else:
|
|
try:
|
|
self._body = body = payload.PAYLOAD_REGISTRY.get(body)
|
|
except payload.LookupError:
|
|
raise ValueError('Unsupported body type %r' % type(body))
|
|
|
|
self._body_payload = True
|
|
|
|
headers = self._headers
|
|
|
|
# set content-length header if needed
|
|
if not self._chunked and CONTENT_LENGTH not in headers:
|
|
size = body.size
|
|
if size is not None:
|
|
headers[CONTENT_LENGTH] = str(size)
|
|
|
|
# set content-type
|
|
if CONTENT_TYPE not in headers:
|
|
headers[CONTENT_TYPE] = body.content_type
|
|
|
|
# copy payload headers
|
|
if body.headers:
|
|
for (key, value) in body.headers.items():
|
|
if key not in headers:
|
|
headers[key] = value
|
|
|
|
self._compressed_body = None
|
|
|
|
@property
|
|
def text(self):
|
|
if self._body is None:
|
|
return None
|
|
return self._body.decode(self.charset or 'utf-8')
|
|
|
|
@text.setter
|
|
def text(self, text):
|
|
assert text is None or isinstance(text, str), \
|
|
"text argument must be str (%r)" % type(text)
|
|
|
|
if self.content_type == 'application/octet-stream':
|
|
self.content_type = 'text/plain'
|
|
if self.charset is None:
|
|
self.charset = 'utf-8'
|
|
|
|
self._body = text.encode(self.charset)
|
|
self._body_payload = False
|
|
self._compressed_body = None
|
|
|
|
@property
|
|
def content_length(self):
|
|
if self._chunked:
|
|
return None
|
|
|
|
if hdrs.CONTENT_LENGTH in self.headers:
|
|
return super().content_length
|
|
|
|
if self._compressed_body is not None:
|
|
# Return length of the compressed body
|
|
return len(self._compressed_body)
|
|
elif self._body_payload:
|
|
# A payload without content length, or a compressed payload
|
|
return None
|
|
elif self._body is not None:
|
|
return len(self._body)
|
|
else:
|
|
return 0
|
|
|
|
@content_length.setter
|
|
def content_length(self, value):
|
|
raise RuntimeError("Content length is set automatically")
|
|
|
|
async def write_eof(self):
|
|
if self._eof_sent:
|
|
return
|
|
if self._compressed_body is not None:
|
|
body = self._compressed_body
|
|
else:
|
|
body = self._body
|
|
if body is not None:
|
|
if (self._req._method == hdrs.METH_HEAD or
|
|
self._status in [204, 304]):
|
|
await super().write_eof()
|
|
elif self._body_payload:
|
|
await body.write(self._payload_writer)
|
|
await super().write_eof()
|
|
else:
|
|
await super().write_eof(body)
|
|
else:
|
|
await super().write_eof()
|
|
|
|
async def _start(self, request):
|
|
if not self._chunked and hdrs.CONTENT_LENGTH not in self._headers:
|
|
if not self._body_payload:
|
|
if self._body is not None:
|
|
self._headers[hdrs.CONTENT_LENGTH] = str(len(self._body))
|
|
else:
|
|
self._headers[hdrs.CONTENT_LENGTH] = '0'
|
|
|
|
return await super()._start(request)
|
|
|
|
def _do_start_compression(self, coding):
|
|
if self._body_payload or self._chunked:
|
|
return super()._do_start_compression(coding)
|
|
if coding != ContentCoding.identity:
|
|
# Instead of using _payload_writer.enable_compression,
|
|
# compress the whole body
|
|
zlib_mode = (16 + zlib.MAX_WBITS
|
|
if coding.value == 'gzip' else -zlib.MAX_WBITS)
|
|
compressobj = zlib.compressobj(wbits=zlib_mode)
|
|
self._compressed_body = compressobj.compress(self._body) +\
|
|
compressobj.flush()
|
|
self._headers[hdrs.CONTENT_ENCODING] = coding.value
|
|
self._headers[hdrs.CONTENT_LENGTH] = \
|
|
str(len(self._compressed_body))
|
|
|
|
|
|
def json_response(data=sentinel, *, text=None, body=None, status=200,
|
|
reason=None, headers=None, content_type='application/json',
|
|
dumps=json.dumps):
|
|
if data is not sentinel:
|
|
if text or body:
|
|
raise ValueError(
|
|
"only one of data, text, or body should be specified"
|
|
)
|
|
else:
|
|
text = dumps(data)
|
|
return Response(text=text, body=body, status=status, reason=reason,
|
|
headers=headers, content_type=content_type)
|