100 lines
3.6 KiB
Python
100 lines
3.6 KiB
Python
import asyncio
|
|
import os
|
|
from dataclasses import dataclass
|
|
|
|
from starlette.requests import Request
|
|
|
|
from .errors import error_response
|
|
from .middleware import is_upload
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Limits:
|
|
max_users: int = 1000
|
|
max_chats: int = 1000
|
|
max_messages: int = 10000
|
|
max_text_bytes: int = 16 * 1024 * 1024
|
|
max_request_bytes: int = 64 * 1024
|
|
max_inflight: int = 32
|
|
message_rate: int = 1000
|
|
message_burst: int = 1000
|
|
|
|
@classmethod
|
|
def from_env(cls):
|
|
values = {}
|
|
for name, default in cls().__dict__.items():
|
|
value = int(os.getenv(name.upper(), str(default)))
|
|
if value < 1:
|
|
raise ValueError(f'{name.upper()} must be positive')
|
|
values[name] = value
|
|
return cls(**values)
|
|
|
|
|
|
limits = Limits.from_env()
|
|
|
|
|
|
class ResourceLimitMiddleware:
|
|
def __init__(self, app, settings=limits):
|
|
self.app = app
|
|
self.settings = settings
|
|
self.active = 0
|
|
|
|
async def __call__(self, scope, receive, send):
|
|
if scope['type'] != 'http' or scope['path'].startswith('/health/'):
|
|
return await self.app(scope, receive, send)
|
|
|
|
request = Request(scope)
|
|
|
|
async def reject(status, code, message):
|
|
response = error_response(request, status, code, message)
|
|
if status == 503:
|
|
response.headers['Retry-After'] = '1'
|
|
await response(scope, receive, send)
|
|
|
|
if self.active >= self.settings.max_inflight:
|
|
return await reject(503, 'unavailable', 'Слишком много одновременных запросов')
|
|
self.active += 1
|
|
try:
|
|
# The upload endpoint authenticates and bounds its stream itself.
|
|
if is_upload(scope['method'], scope['path']):
|
|
return await self.app(scope, receive, send)
|
|
length = request.headers.get('content-length')
|
|
if length is not None:
|
|
try:
|
|
size = int(length)
|
|
if size < 0:
|
|
raise ValueError()
|
|
except ValueError:
|
|
return await reject(400, 'invalid_request', 'Неверный Content-Length')
|
|
if size > self.settings.max_request_bytes:
|
|
return await reject(413, 'payload_too_large', 'Тело запроса слишком большое')
|
|
|
|
body = bytearray()
|
|
try:
|
|
async with asyncio.timeout(5):
|
|
while True:
|
|
message = await receive()
|
|
if message['type'] == 'http.disconnect':
|
|
return
|
|
chunk = message.get('body', b'')
|
|
if len(body) + len(chunk) > self.settings.max_request_bytes:
|
|
return await reject(413, 'payload_too_large', 'Тело запроса слишком большое')
|
|
body.extend(chunk)
|
|
if not message.get('more_body', False):
|
|
break
|
|
except TimeoutError:
|
|
return await reject(503, 'unavailable', 'Истекло время чтения запроса')
|
|
|
|
delivered = False
|
|
|
|
async def buffered_receive():
|
|
nonlocal delivered
|
|
if not delivered:
|
|
delivered = True
|
|
return {'type': 'http.request', 'body': bytes(body), 'more_body': False}
|
|
return await receive()
|
|
|
|
await self.app(scope, buffered_receive, send)
|
|
finally:
|
|
self.active -= 1
|