def get_data(self, unreader, buf, stop=False):
data = unreader.read()
if not data:
if stop:
raise StopIteration()
raise NoMoreData(buf.getvalue())
buf.write(data)
def parse_chunked(self, unreader):
(size, rest) = self.parse_chunk_size(unreader)
while size > 0:
while size > len(rest):
size -= len(rest)
yield rest
rest = unreader.read()
if not rest:
raise NoMoreData()
yield rest[:size]
# Remove \r\n after chunk
rest = rest[size:]
while len(rest) < 2:
rest += unreader.read()
if rest[:2] != b'\r\n':
raise ChunkMissingTerminator(rest[:2])
(size, rest) = self.parse_chunk_size(unreader, data=rest[2:])
def parse_chunked(self, unreader):
size, rest = self.parse_chunk_size(unreader)
while size > 0:
# 读取一个chunk中的数据直到差不多要读取完了
while size > len(rest):
size -= len(rest)
yield rest
rest = unreader.read()
if not rest:
raise NoMoreData()
# 读取一个chunk中最后剩余的数据
yield rest[:size]
# Remove \r\n after chunk
rest = rest[size:]
while len(rest) < 2:
rest += unreader.read()
# 上一个chunk的结尾必然是 \r\n
if rest[:2] != b'\r\n':
raise ChunkMissingTerminator(rest[:2])
# 读取下一个chunk的数据
size, rest = self.parse_chunk_size(unreader, data=rest[2:])
def get_data(self, unreader, buf):
data = unreader.read()
if not data:
raise NoMoreData()
buf.write(data)
def __call__(self, environ: Environ,
start_response: StartResponse) -> Iterable[bytes]:
request = Request.from_environ(environ)
resolver = self.injector.get_resolver({
Environ:
environ,
Headers:
request.headers,
Host:
Host(request.host),
Method:
Method(request.method),
Port:
Port(request.port),
QueryParams:
request.params,
QueryString:
QueryString(environ.get("QUERY_STRING", "")),
Request:
request,
RequestInput:
RequestInput(request.body_file),
Scheme:
Scheme(request.scheme),
StartResponse:
start_response,
})
try:
handler: Callable[..., Any]
route_and_params = self.router.match(request.method, request.path)
if route_and_params is not None:
route, params = route_and_params
handler = route.handler
resolver.add_component(RouteComponent(route))
resolver.add_component(RouteParamsComponent(params))
else:
handler = self.handle_404
resolver.add_component(RouteComponent(None))
handler = resolver.resolve(handler)
for middleware in reversed(self.middleware):
handler = resolver.resolve(middleware(handler))
exc_info = None
response = handler()
except RequestHandled:
# This is used to break out of gunicorn's keep-alive loop.
# If we don't do this, then gunicorn might attempt to read
# from a closed socket.
raise NoMoreData()
except RequestParserNotAvailable:
exc_info = None
response = resolver.resolve(self.handle_415)()
except ParseError as e:
exc_info = None
response = resolver.resolve(self.handle_parse_error)(exception=e)
except Exception as e:
exc_info = sys.exc_info()
response = resolver.resolve(self.handle_exception)(exception=e)
content_length = response.get_content_length()
if content_length is not None:
response.headers.add("content-length", str(content_length))
start_response(response.status, list(response.headers), exc_info)
if response.status != HTTP_204:
wrapper = environ.get("wsgi.file_wrapper", FileWrapper)
return wrapper(response.stream)
else:
return []
def parse_headers(self, data):
cfg = self.cfg
headers = []
# Split lines on \r\n keeping the \r\n on each line
lines = [bytes_to_str(line) + "\r\n" for line in data.split(b"\r\n")]
# handle scheme headers
scheme_header = False
secure_scheme_headers = {}
if '*' in cfg.forwarded_allow_ips:
secure_scheme_headers = cfg.secure_scheme_headers
elif isinstance(self.unreader, SocketUnreader):
try:
remote_addr = self.unreader.sock.getpeername()
if self.unreader.sock.family in (socket.AF_INET,
socket.AF_INET6):
remote_host = remote_addr[0]
if remote_host in cfg.forwarded_allow_ips:
secure_scheme_headers = cfg.secure_scheme_headers
elif self.unreader.sock.family == socket.AF_UNIX:
secure_scheme_headers = cfg.secure_scheme_headers
except OSError:
raise NoMoreData()
# Parse headers into key/value pairs paying attention
# to continuation lines.
while lines:
if len(headers) >= self.limit_request_fields:
raise LimitRequestHeaders("limit request headers fields")
# Parse initial header name : value pair.
curr = lines.pop(0)
header_length = len(curr)
if curr.find(":") < 0:
raise InvalidHeader(curr.strip())
name, value = curr.split(":", 1)
if self.cfg.strip_header_spaces:
name = name.rstrip(" \t").upper()
else:
name = name.upper()
if HEADER_RE.search(name):
raise InvalidHeaderName(name)
name, value = name.strip(), [value.lstrip()]
# Consume value continuation lines
while lines and lines[0].startswith((" ", "\t")):
curr = lines.pop(0)
header_length += len(curr)
if header_length > self.limit_request_field_size > 0:
raise LimitRequestHeaders("limit request headers "
"fields size")
value.append(curr)
value = ''.join(value).rstrip()
if header_length > self.limit_request_field_size > 0:
raise LimitRequestHeaders("limit request headers fields size")
if name in secure_scheme_headers:
secure = value == secure_scheme_headers[name]
scheme = "https" if secure else "http"
if scheme_header:
if scheme != self.scheme:
raise InvalidSchemeHeaders()
else:
scheme_header = True
self.scheme = scheme
headers.append((name, value))
return headers
