async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if self.allow_any or scope["type"] not in (
"http",
"websocket",
): # pragma: no cover
await self.app(scope, receive, send)
return
headers = Headers(scope=scope)
host = headers.get("host", "").split(":")[0]
is_valid_host = False
found_www_redirect = False
for pattern in self.allowed_hosts:
if host == pattern or (
pattern.startswith("*") and host.endswith(pattern[1:])
):
is_valid_host = True
break
elif "www." + host == pattern:
found_www_redirect = True
if is_valid_host:
await self.app(scope, receive, send)
else:
response: Response
if found_www_redirect and self.www_redirect:
url = URL(scope=scope)
redirect_url = url.replace(netloc="www." + url.netloc)
response = RedirectResponse(url=str(redirect_url))
else:
response = PlainTextResponse("Invalid host header", status_code=400)
await response(scope, receive, send)
async def __call__(
self, scope, receive, send
) -> None:
if scope["type"] != "http": # pragma: no cover
handler = await self.app(scope, receive, send)
await handler.__call__(receive, send)
return
method = scope["method"]
headers = Headers(scope=scope)
origin = headers.get("origin")
if origin is None:
handler = await self.app(scope, receive, send)
await handler.__call__(receive, send)
return
if method == "OPTIONS" and "access-control-request-method" in headers:
response = self.preflight_response(request_headers=headers)
await response(scope, receive, send)
return
await self.simple_response(
scope, receive, send, request_headers=headers
)
def __init__(self, function: Callable[..., Any],
callback: Union[Dict[str, Any], bool]) -> None:
self.__function = function
self.__attribute_finders = self.__prepare_and_validate_finders(
callback)
self.__headers = Headers()
self.__params: Dict[str, str] = {}
self.__invalid_callback_object = ""
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
if scope["type"] == "http":
headers = Headers(scope=scope)
if "gzip" in headers.get("Accept-Encoding", ""):
responder = GZipResponder(self.app, self.minimum_size)
await responder(scope, receive, send)
return
await self.app(scope, receive, send)
def __call__(self, scope: Scope) -> ASGIInstance:
if scope["type"] in ("http", "websocket") and not self.allow_any:
headers = Headers(scope=scope)
host = headers.get("host")
if host not in self.allowed_hosts:
return PlainTextResponse("Invalid host header",
status_code=400)
return self.app(scope)
def is_not_modified(self, stat_headers: typing.Dict[str, str]) -> bool:
etag = stat_headers["etag"]
last_modified = stat_headers["last-modified"]
req_headers = Headers(scope=self.scope)
if etag == req_headers.get("if-none-match"):
return True
if "if-modified-since" not in req_headers:
return False
last_req_time = req_headers["if-modified-since"]
return parsedate(last_req_time) >= parsedate(last_modified) # type: ignore
def matches(self, scope: Scope) -> typing.Tuple[Match, Scope]:
headers = Headers(scope=scope)
host = headers.get("host", "").split(":")[0]
match = self.host_regex.match(host)
if match:
matched_params = match.groupdict()
for key, value in matched_params.items():
matched_params[key] = self.param_convertors[key].convert(value)
path_params = dict(scope.get("path_params", {}))
path_params.update(matched_params)
child_scope = {"path_params": path_params, "endpoint": self.app}
return Match.FULL, child_scope
return Match.NONE, {}
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
headers = Headers(scope=scope)
self.should_decode_from_msgpack_to_json = (
"application/x-msgpack" in headers.get("content-type", "")
)
# Take an initial guess, although we eventually may not
# be able to do the conversion.
self.should_encode_from_json_to_msgpack = (
"application/x-msgpack" in headers.getlist("accept")
)
self.receive = receive
self.send = send
await self.app(scope, self.receive_with_msgpack, self.send_with_msgpack)
def __call__(self, scope: Scope) -> ASGIInstance:
if scope["type"] == "http":
method = scope["method"]
headers = Headers(scope=scope)
origin = headers.get("origin")
if origin is not None:
if method == "OPTIONS" and "access-control-request-method" in headers:
return self.preflight_response(request_headers=headers)
else:
return functools.partial(self.simple_response,
scope=scope,
request_headers=headers)
return self.app(scope)
async def __call__(self, scope: Scope, receive: Receive,
send: Send) -> None:
if scope["type"] == "http":
headers = Headers(scope=scope)
accepted = {
item.strip()
for item in headers.get("accept-encoding", "").split(",")
if item
}
responder = CompressionResponder(self.app, self.minimum_size,
accepted,
self.compression_registry)
await responder(scope, receive, send)
return
await self.app(scope, receive, send)
def __call__(self, scope: Scope) -> ASGIInstance:
if scope["type"] in ("http", "websocket") and not self.allow_any:
headers = Headers(scope=scope)
host = headers.get("host", "").split(":")[0]
for pattern in self.allowed_hosts:
if (
host == pattern
or pattern.startswith("*")
and host.endswith(pattern[1:])
):
break
else:
return PlainTextResponse("Invalid host header", status_code=400)
return self.app(scope)
def test_player_json(service, steam_id, mod_date):
resp = service.get("/player/{0}.json".format(steam_id))
obj_defacto = resp.json()
obj_expected = read_json_sample("player_{}".format(steam_id))
assert obj_defacto == obj_expected
resp = service.get("/player/{0}".format(steam_id))
assert resp.template.name == "player_stats.html"
context = resp.context
assert "request" in context
assert "steam_id" in context
assert context["steam_id"] == steam_id
del context["request"]
del context["steam_id"]
obj_defacto = context
assert obj_defacto == obj_expected
assert resp.headers["last-modified"] == mod_date
service.get(
"/player/{0}.json".format(steam_id),
304,
headers=Headers({"If-Modified-Since": mod_date}),
)
def client_response_hook(self, span, resp_data):
"""used to capture the response data
this function is called twice, once during each resp_phase"""
resp_phase = resp_data['type']
if resp_phase == "http.response.start":
status_code = resp_data["status"]
set_status_code(span, status_code)
headers = dict(Headers(raw=resp_data['headers']))
should_capture_body = self._capture_headers(
self._process_response_headers,
self.HTTP_RESPONSE_HEADER_PREFIX, span, headers,
self._process_response_body)
span.set_attribute('hypertrace.capture', should_capture_body)
elif resp_phase == 'http.response.body':
should_capture = span.attributes.get('hypertrace.capture')
if should_capture:
body_data = resp_data['body']
body_str = None
if isinstance(body_data, bytes):
body_str = body_data.decode('UTF8', 'backslashreplace')
else:
body_str = body_data
resp_body_str = self.grab_first_n_bytes(body_str)
span.set_attribute('http.response.body', resp_body_str)
async def __call__(self, scope: Scope, receive: Receive,
send: Send) -> None:
headers = Headers(scope=scope)
url = URL(scope=scope)
log_debug(message=f'[API Server] {url}',
data={'headers': f'{headers}'})
await self.app(scope, receive, send)
async def __call__(self, scope: Scope, receive: Receive,
send: Send) -> None:
if scope["type"] == "http":
headers = Headers(scope=scope)
if "br" in headers.get("Accept-Encoding", ""):
responder = BrotliResponder(
self.app,
self.quality,
self.mode,
self.lgwin,
self.lgblock,
self.minimum_size,
)
await responder(scope, receive, send)
return
await self.app(scope, receive, send)
async def get_sequence(checksum: str,
start: int = 0,
end: int = 0,
accept: str = ""):
"""
Return Refget sequence based on checksum value.
str start: Start point of the sequence defined in checksum.
str end: End point of the sequence defined in checksum.
"""
headers = Headers()
params = {"accept": accept}
if start < end:
params["start"] = start
params["end"] = end
url_path = "sequence/" + checksum
try:
result = await create_request_coroutine(
url_list=metadata_url_list(checksum),
url_path=url_path,
headers=headers,
params=params,
)
if result == "":
return HTTPException(status_code=HTTP_404_NOT_FOUND,
detail="Not Found")
return result
except Exception as e:
logger.log("DEBUG", "Unhandled exception in get_sequence " + str(e))
async def get_response(self, path: str, scope: Scope) -> Response:
response = await super().get_response(path, scope)
if isinstance(response, FileResponse):
etag = await _hash_file(response.path)
response.headers["etag"] = etag
if self.is_not_modified(response.headers, Headers(scope=scope)):
return NotModifiedResponse(response.headers)
return response
def __init__(self, request: HTTPConnection):
super().__init__(
request.scope["method"],
str(URL(scope=request.scope)),
None,
Headers(scope=request.scope),
)
self._orig_request = request
async def gzippable_app(scope: Scope, receive: Receive,
send: Send) -> None:
headers = Headers(scope=scope)
if "gzip" in headers.getlist("accept-encoding"):
body = gzip.compress(b"Hello, world!")
response = PlainTextResponse(
content=body,
headers={
"Content-Encoding": "gzip",
"Content-Length": str(len(body))
},
)
else:
response = PlainTextResponse("Hello, world!")
response.headers["Vary"] = "Accept-Encoding"
await response(scope, receive, send)
async def __call__(self, scope: Scope, receive: Receive,
send: Send) -> None:
if scope["type"] != "http":
await self.app(scope, receive, send)
return
headers = Headers(scope=scope)
span_ctx = headers.get("x-noc-span-ctx", 0)
span_id = headers.get("x-noc-span", 0)
sample = 1 if span_ctx and span_id else 0
with Span(
server=self.service_name,
service="api",
sample=sample,
parent=span_id,
context=span_ctx,
in_label=scope["path"],
):
await self.app(scope, receive, send)
def __init__(self, headers: Headers):
super().__init__(
status_code=304,
headers={
name: value
for name, value in headers.items()
if name in self.NOT_MODIFIED_HEADERS
},
)
async def __call__(self, scope: Scope, receive: Receive, send: Send):
if scope["type"] != "http":
await self.app(scope, receive, send)
return
method = scope["method"]
headers = Headers(scope=scope)
await self.response(scope, receive, send, request_headers=headers)
def test_partial():
from starlette.datastructures import Headers
class Header(Model):
token: str
header = Header(**Headers({"token": "123", "test": "12345g"}))
assert header.token == "123"
assert header.dict() == {"token": "123"}
async def asgi(self, receive: Receive, send: Send, scope: Scope, path: str) -> None:
if not self.config_checked:
await self.check_config()
self.config_checked = True
method = scope["method"]
headers = Headers(scope=scope)
response = await self.get_response(path, method, headers)
await response(receive, send)
async def send_with_logging(self, message: Message) -> None:
if message["type"] == "http.response.start":
self._response_status_code = message.get("status")
headers = Headers(raw=message["headers"])
self.should_log_response_body = "application/json" in headers.get(
"content-type", "")
await self.send(message)
elif message["type"] == "http.response.body":
if not self.should_log_response_body:
await self.send(message)
return
body: bytes = message.get("body", b"")
self._response_body.extend(body)
await self.send(message)
def get_jwt(self, header: Headers) -> str:
if "Authorization" not in header:
return
token = header.get("Authorization")
scheme, jwt = token.split()
if scheme.lower() != "bearer":
raise InvalidAuthorizationToken("header dose not start \
with 'Bearer'")
return jwt
def get_context(self, scope):
request_method = scope.get("method")
if request_method:
trace_name = f"starlette_http_{request_method.lower()}"
else:
trace_name = "starlette_http"
headers = Headers(scope=scope)
return {
"name": trace_name,
"type": "http_server",
"request.host": headers.get("host"),
"request.method": request_method,
"request.path": scope.get("path"),
"request.content_length": int(headers.get("content-length", 0)),
"request.user_agent": headers.get("user-agent"),
"request.scheme": scope.get("scheme"),
"request.query": scope.get("query_string").decode("ascii"),
}
def test_check_auth_error_auth_error():
"""Test: check_auth(request: Request) -> None
Error: Auth error."""
scope = {'type': 'http'}
request = Request(scope)
request._headers = Headers(headers={'X-Key': 'fake-key'})
with pytest.raises(HTTPException) as ex:
check_auth(request)
assert ex.value.status_code == 400
assert ex.value.detail == 'Auth error'
def __call__(self, scope: Scope) -> ASGIInstance:
if scope["type"] in ("http", "websocket") and not self.allow_any:
headers = Headers(scope=scope)
host = headers.get("host", "").split(":")[0]
found_www_redirect = False
for pattern in self.allowed_hosts:
if host == pattern or (pattern.startswith("*")
and host.endswith(pattern[1:])):
break
elif "www." + host == pattern:
found_www_redirect = True
else:
if found_www_redirect and self.www_redirect:
url = URL(scope=scope)
redirect_url = url.replace(netloc="www." + url.netloc)
return RedirectResponse(url=str(redirect_url))
return PlainTextResponse("Invalid host header",
status_code=400)
return self.app(scope)
async def get_data_from_response(message: dict, config: Config, event_type: str) -> dict:
"""Loads data from response for APM capturing.
Args:
message (dict)
config (Config)
event_type (str)
Returns:
dict
"""
result = {}
if "status_code" in message:
result["status_code"] = message["status"]
if config.capture_headers and "headers" in message:
headers = Headers(raw=message["headers"])
result["headers"] = {key: ";".join(headers.getlist(key)) for key in compat.iterkeys(headers)}
return result
