Files
mtusi2026lab5/src/server.py
T

297 lines
12 KiB
Python

"""Bounded threaded API; persistent correctness state is shared across replicas."""
import concurrent.futures
import http.server
import json
import logging
import os
import time
import signal
import socket
import threading
import uuid
from urllib.parse import parse_qs, urlsplit
from objects import bounded_upload, receive, filename, unavailable
from common import APIError, identifier, invalid, missing, page_args
LOG = logging.getLogger('messenger')
def unique_object(pairs):
result = {}
for key, value in pairs:
if key in result:
invalid()
result[key] = value
return result
class Handler(http.server.BaseHTTPRequestHandler):
protocol_version = 'HTTP/1.1'
def setup(self):
super().setup()
self.connection.settimeout(3)
def send_error(self, code, message=None, explain=None):
# BaseHTTPRequestHandler otherwise emits HTML without contract headers.
self.request_id = uuid.uuid4().hex
self.route = ''
self.close_connection = True
status = 413 if code == 413 else 400
self.reply(status, {'error': {'code': 'payload_too_large' if status == 413 else 'invalid_request', 'message': 'Некорректный HTTP-запрос', 'request_id': self.request_id}})
def log_message(self, *args):
pass
def reply(self, status, body):
if status == 200 and isinstance(body, tuple):
return self.download(*body)
raw = b'' if status == 204 else json.dumps(body, ensure_ascii=False, allow_nan=False).encode('utf-8')
if status >= 400:
self.close_connection = True
self.send_response(status)
self.send_header('Content-Type', 'application/json')
self.send_header('Content-Length', str(len(raw)))
if self.close_connection:
self.send_header('Connection', 'close')
self.send_header('X-Request-Id', self.request_id)
self.send_header('X-Instance-Id', self.server.instance_id)
if status == 401 and self.server.store.persistent:
self.send_header('WWW-Authenticate', 'Basic realm="messenger", charset="UTF-8"' if self.route == '/api/v1/auth/sessions' else 'Bearer realm="messenger"')
self.end_headers()
if self.command != 'HEAD':
self.wfile.write(raw)
def download(self, row, response, chunk):
stream = response['Body']
try:
self.send_response(200)
self.send_header('Content-Type', row['content_type'])
self.send_header('Content-Length', str(row['size_bytes']))
self.send_header('X-Request-Id', self.request_id)
self.send_header('X-Instance-Id', self.server.instance_id)
self.send_header('X-Content-Type-Options', 'nosniff')
self.send_header('Cache-Control', 'private, no-store')
self.end_headers()
deadline = time.monotonic() + 15
while chunk:
self.wfile.write(chunk)
if time.monotonic() > deadline:
raise TimeoutError()
chunk = stream.read(64 * 1024)
finally:
stream.close()
def body(self):
lengths = self.headers.get_all('Content-Length', [])
if len(lengths) != 1 or self.headers.get('Transfer-Encoding'):
invalid()
try:
length = int(lengths[0])
except ValueError:
invalid()
if length > 32768:
raise APIError(413, 'payload_too_large', 'Максимальный JSON — 32768 байт')
if length <= 0:
invalid()
if self.headers.get_content_type() != 'application/json':
raise APIError(415, 'unsupported_media_type', 'Требуется application/json')
try:
raw = self.rfile.read(length)
if len(raw) != length:
invalid()
return json.loads(raw.decode('utf-8'), object_pairs_hook=unique_object, parse_constant=lambda _: invalid())
except (ValueError, UnicodeError, RecursionError):
invalid()
def dispatch(self):
self.request_id = uuid.uuid4().hex
self.route = urlsplit(self.path).path
status = 500
try:
status, result = self.route_request()
except APIError as exc:
status = exc.status
result = {'error': {'code': exc.code, 'message': exc.message, 'request_id': self.request_id}}
except Exception:
# No bodies, credentials, tokens, SQL or exception details in logs/responses.
LOG.error('request_failed request_id=%s', self.request_id)
result = {'error': {'code': 'internal_error', 'message': 'Внутренняя ошибка', 'request_id': self.request_id}}
try:
self.reply(status, result)
except Exception:
self.close_connection = True
LOG.info('method=%s status=%s request_id=%s', self.command, status, self.request_id)
def route_request(self):
method, path, store = self.command, self.route, self.server.store
if method == 'GET' and path in ('/health/live', '/health/ready'):
if path.endswith('ready'):
store.ready()
return 200, {'status': 'ok'}
if method == 'POST' and path == '/api/v1/users':
return 201, store.register(self.body())
if store.persistent and method == 'POST' and path == '/api/v1/auth/sessions':
if self.headers.get('Transfer-Encoding') or self.headers.get('Content-Length', '0') != '0':
invalid()
return 201, store.login(self.headers)
actor = store.authenticate(self.headers)
if store.persistent and method == 'DELETE' and path == '/api/v1/auth/sessions/current':
store.logout(self.headers)
return 204, None
if method == 'GET' and path == '/api/v1/users/me':
return 200, actor
query = parse_qs(urlsplit(self.path).query, keep_blank_values=True)
if path == '/api/v1/chats':
if method == 'POST':
return 201, store.create_chat(actor, self.body())
if method == 'GET':
scope = 'chats:' + actor['id']
limit, cursor = page_args(query, scope)
return 200, store.list_chats(actor, limit, cursor, scope)
parts = path.split('/')
if len(parts) in (5, 6) and parts[1:4] == ['api', 'v1', 'attachments'] and method == 'GET':
row = store.attachment(actor, identifier(parts[4]))
if len(parts) == 5:
if query:
invalid()
return 200, store.attachment_public(row)
if parts[5] == 'content':
if set(query) - {'variant'} or any(len(v) != 1 for v in query.values()):
invalid()
if row['state'] != 'ready':
raise APIError(409, 'conflict', 'Вложение ещё не готово')
variant = query.get('variant', ['original'])[0]
if variant != 'original':
item = next((v for v in row['variants'] if v['name'] == variant), None)
if item is None:
missing()
row = dict(row, object_key=item['object_key'], content_type=item['content_type'], size_bytes=item['size_bytes'])
response = store.objects.get(row['object_key'])
try:
chunk = response['Body'].read(64 * 1024)
if response['ContentLength'] != row['size_bytes'] or not chunk:
unavailable()
except Exception:
response['Body'].close()
unavailable()
return 200, (row, response, chunk)
if len(parts) in (5, 6) and parts[1:4] == ['api', 'v1', 'chats']:
chat_id = identifier(parts[4])
if store.access_mode == 'baseline':
store.chat(actor, chat_id)
if len(parts) == 5 and method == 'GET':
return 200, store.chat(actor, chat_id)
if len(parts) == 6 and parts[5] == 'attachments' and method == 'POST':
store.chat(actor, chat_id)
if set(query) != {'filename'} or len(query['filename']) != 1:
invalid()
name = filename(query['filename'][0])
with bounded_upload():
with receive(self) as (source, length, mime, digest):
return 202, store.upload(actor, chat_id, name, source, length, mime, digest)
if len(parts) == 6 and parts[5] == 'messages':
if method == 'POST':
keys = self.headers.get_all('Idempotency-Key', [])
return 201, store.send(actor, chat_id, self.body(), keys[0] if len(keys) == 1 else None)
if method == 'GET':
scope = 'messages:' + chat_id
limit, cursor = page_args(query, scope)
return 200, store.history(actor, chat_id, limit, cursor, scope)
missing()
do_GET = do_POST = do_DELETE = do_PUT = do_PATCH = do_OPTIONS = dispatch
class Server(http.server.HTTPServer):
request_queue_size = 64
allow_reuse_address = True
def __init__(self, address, store):
self.store = store
self.instance_id = uuid.uuid4().hex
workers = int(os.environ.get('HTTP_WORKERS', '16'))
if not 1 <= workers <= 128:
raise ValueError('HTTP_WORKERS must be 1..128')
self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=workers)
self.slots = threading.BoundedSemaphore(workers * 2)
self.connections = set()
self.connections_lock = threading.Lock()
super().__init__(address, Handler)
def process_request(self, request, address):
if not self.slots.acquire(blocking=False):
rid = uuid.uuid4().hex
raw = json.dumps({'error': {'code': 'unavailable', 'message': 'Очередь запросов заполнена', 'request_id': rid}}).encode()
try:
request.settimeout(0.2)
request.sendall(('HTTP/1.0 503 Service Unavailable\r\nContent-Type: application/json\r\nX-Instance-Id: ' + self.instance_id + '\r\nX-Request-Id: ' + rid + '\r\nContent-Length: ' + str(len(raw)) + '\r\n\r\n').encode() + raw)
except OSError:
pass
self.shutdown_request(request)
return
with self.connections_lock:
self.connections.add(request)
self.executor.submit(self.worker, request, address)
def worker(self, request, address):
try:
self.finish_request(request, address)
except OSError:
pass
finally:
self.shutdown_request(request)
with self.connections_lock:
self.connections.discard(request)
self.slots.release()
def close_connections(self):
with self.connections_lock:
connections = list(self.connections)
for connection in connections:
try:
connection.shutdown(socket.SHUT_RDWR)
except OSError:
pass
def server_close(self):
super().server_close()
# Bound draining even when a slow client keeps an incomplete request alive.
deadline = threading.Timer(5, self.close_connections)
deadline.start()
try:
self.executor.shutdown(wait=True)
finally:
deadline.cancel()
def main():
logging.basicConfig(level=os.environ.get('LOG_LEVEL', 'INFO'), format='%(asctime)s %(levelname)s %(message)s')
from postgres import Store
store = Store()
server = Server((os.environ.get('APP_HOST', '0.0.0.0'), int(os.environ.get('APP_PORT', '8080'))), store)
stopping = threading.Event()
def stop(signum, frame):
if not stopping.is_set():
stopping.set()
LOG.info('shutdown_started signal=%s', signum)
threading.Thread(target=server.shutdown, daemon=True).start()
signal.signal(signal.SIGUSR1, lambda *_: LOG.warning('pool_stats instance=%s stats=%s', server.instance_id, json.dumps(store.pool.get_stats())))
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
LOG.info('started port=%s', server.server_address[1])
try:
server.serve_forever(poll_interval=0.1)
finally:
server.server_close()
store.close()
LOG.info('shutdown_complete')
if __name__ == '__main__':
main()