forked from mtusi2026/mtusi2026lab2
260 lines
9.6 KiB
Python
260 lines
9.6 KiB
Python
"""HTTP/1.1 front end: request ids, structured logs, graceful SIGTERM shutdown."""
|
|
from __future__ import annotations
|
|
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
import json
|
|
import os
|
|
import platform
|
|
import signal
|
|
import sys
|
|
import threading
|
|
import time
|
|
import uuid
|
|
from urllib.parse import parse_qs, urlsplit
|
|
|
|
from . import __version__, logging_utils
|
|
from .api import Api, Request
|
|
from .cache import SessionCache
|
|
from .config import Config, ConfigError
|
|
from .db import Database
|
|
from .errors import ApiError, InvalidRequest, PayloadTooLarge, Unavailable
|
|
from .store import Store
|
|
|
|
MAX_REQUEST_ID_LENGTH = 128
|
|
MAX_LOGGED_LINE = 200
|
|
|
|
|
|
def sanitize_request_id(raw):
|
|
"""Echo a safe client id, otherwise generate one. Never trust raw input."""
|
|
if raw and len(raw) <= MAX_REQUEST_ID_LENGTH and all(0x21 <= ord(ch) <= 0x7E for ch in raw):
|
|
return raw
|
|
return uuid.uuid4().hex
|
|
|
|
|
|
def route_template(path):
|
|
for _method, pattern, _handler in Api.ROUTES:
|
|
if pattern.match(path):
|
|
return pattern.pattern.replace('[^/]+', '{chat_id}').strip('^$')
|
|
return 'unmatched'
|
|
|
|
|
|
def encode_payload(payload):
|
|
return json.dumps(payload, ensure_ascii=False, separators=(',', ':')).encode('utf-8')
|
|
|
|
|
|
class ApiServer(ThreadingHTTPServer):
|
|
"""Threaded server that tracks in-flight requests and stops accepting on demand."""
|
|
|
|
daemon_threads = True
|
|
allow_reuse_address = True
|
|
request_queue_size = 128
|
|
|
|
def __init__(self, address, api, config, logger, database):
|
|
self.api = api
|
|
self.config = config
|
|
self.logger = logger
|
|
self.database = database
|
|
self.shutting_down = False
|
|
self._active = 0
|
|
self._idle = threading.Condition()
|
|
super().__init__(address, ApiHandler)
|
|
|
|
def enter(self):
|
|
with self._idle:
|
|
self._active += 1
|
|
|
|
def leave(self):
|
|
with self._idle:
|
|
self._active -= 1
|
|
if self._active == 0:
|
|
self._idle.notify_all()
|
|
|
|
def wait_idle(self, timeout):
|
|
deadline = time.monotonic() + timeout
|
|
with self._idle:
|
|
while self._active > 0:
|
|
remaining = deadline - time.monotonic()
|
|
if remaining <= 0:
|
|
return False
|
|
self._idle.wait(remaining)
|
|
return True
|
|
|
|
|
|
class ApiHandler(BaseHTTPRequestHandler):
|
|
protocol_version = 'HTTP/1.1'
|
|
server_version = 'mtusi-messenger/' + __version__
|
|
sys_version = ''
|
|
timeout = 30
|
|
|
|
# --------------------------------------------------------- entry points
|
|
def do_GET(self):
|
|
self._handle()
|
|
|
|
do_HEAD = do_POST = do_PUT = do_PATCH = do_DELETE = do_OPTIONS = do_GET
|
|
|
|
def log_message(self, fmt, *args):
|
|
"""Base-class chatter stays debug-only; access logs are structured."""
|
|
self.server.logger.debug('http_note', extra={
|
|
'event': 'http_note', 'detail': (fmt % args)[:MAX_LOGGED_LINE]})
|
|
|
|
# ------------------------------------------------------------- pipeline
|
|
def _handle(self):
|
|
started = time.monotonic()
|
|
server = self.server
|
|
request_id = sanitize_request_id(self.headers.get('X-Request-Id'))
|
|
head_only = self.command == 'HEAD'
|
|
path = urlsplit(self.path).path
|
|
status, error_code = 500, None
|
|
self._last_exc = None
|
|
server.enter()
|
|
try:
|
|
if server.shutting_down:
|
|
raise Unavailable('Сервер завершает работу')
|
|
body = self._read_body()
|
|
query = parse_qs(urlsplit(self.path).query, keep_blank_values=True)
|
|
request = Request('GET' if head_only else self.command, path, query, self.headers,
|
|
body, request_id, self.client_address[0])
|
|
status, payload = server.api.dispatch(request)
|
|
encoded = encode_payload(payload)
|
|
except ApiError as exc:
|
|
self._last_exc = exc
|
|
status, error_code = exc.status, exc.code
|
|
encoded = self._error_payload(exc, request_id)
|
|
except Exception: # last resort: log privately, answer generically
|
|
server.logger.exception('unhandled_error', extra={
|
|
'event': 'unhandled_error', 'request_id': request_id,
|
|
'method': self.command, 'route': route_template(path)})
|
|
status, error_code = 500, 'internal_error'
|
|
encoded = self._error_payload(ApiError(), request_id)
|
|
finally:
|
|
server.leave()
|
|
server.logger.info('http_request', extra={
|
|
'event': 'http_request', 'request_id': request_id, 'method': self.command,
|
|
'route': route_template(path), 'status': status,
|
|
'duration_ms': round(1000 * (time.monotonic() - started), 3),
|
|
'error_code': error_code, 'client': self.client_address[0]})
|
|
self._send(status, encoded, request_id, head_only)
|
|
|
|
def _read_body(self):
|
|
if self.headers.get('Transfer-Encoding'):
|
|
self.close_connection = True
|
|
raise InvalidRequest('Transfer-Encoding не поддерживается')
|
|
raw_length = self.headers.get('Content-Length')
|
|
if raw_length is None:
|
|
return b''
|
|
try:
|
|
length = int(raw_length.strip())
|
|
except ValueError:
|
|
raise InvalidRequest('Некорректный Content-Length') from None
|
|
if length < 0:
|
|
raise InvalidRequest('Некорректный Content-Length')
|
|
if length > self.server.config.max_body_bytes:
|
|
self.close_connection = True
|
|
raise PayloadTooLarge('Тело запроса больше %d байт' % self.server.config.max_body_bytes)
|
|
if length == 0:
|
|
return b''
|
|
return self.rfile.read(length)
|
|
|
|
@staticmethod
|
|
def _error_payload(exc, request_id):
|
|
return encode_payload({'error': {
|
|
'code': exc.code, 'message': exc.message, 'request_id': request_id}})
|
|
|
|
def _send(self, status, encoded, request_id, head_only):
|
|
try:
|
|
self.send_response(status)
|
|
self.send_header('Content-Type', 'application/json; charset=utf-8')
|
|
self.send_header('X-Request-Id', request_id)
|
|
self.send_header('Cache-Control', 'no-store')
|
|
if status == 204:
|
|
self.send_header('Content-Length', '0')
|
|
if status == 503:
|
|
self.send_header('Retry-After', '1')
|
|
self.end_headers()
|
|
return
|
|
if status == 503:
|
|
self.send_header('Retry-After', '1')
|
|
if status == 401 and self._last_exc is not None:
|
|
www_auth = getattr(self._last_exc, 'www_authenticate', None)
|
|
if www_auth:
|
|
self.send_header('WWW-Authenticate', www_auth)
|
|
if self.close_connection:
|
|
self.send_header('Connection', 'close')
|
|
self.end_headers()
|
|
if not head_only and encoded:
|
|
self.wfile.write(encoded)
|
|
except (BrokenPipeError, ConnectionResetError):
|
|
self.close_connection = True
|
|
|
|
|
|
def build_server(config, logger, api, database):
|
|
"""Create the listening server; raises OSError when the port is taken."""
|
|
return ApiServer((config.host, config.port), api, config, logger, database)
|
|
|
|
|
|
def run(config, logger, database, cache):
|
|
"""Serve until SIGTERM/SIGINT, then drain in-flight work within the grace period."""
|
|
api = Api(config, Store(config, database, cache), database)
|
|
try:
|
|
server = build_server(config, logger, api, database)
|
|
except OSError as exc:
|
|
logger.error('listen_failed', extra={'event': 'listen_failed', 'detail': str(exc)})
|
|
return 1
|
|
stop = threading.Event()
|
|
|
|
def handle_signal(signum, _frame):
|
|
if stop.is_set():
|
|
return
|
|
stop.set()
|
|
server.shutting_down = True
|
|
logger.warning('shutdown_signal', extra={
|
|
'event': 'shutdown_signal', 'signal': signum,
|
|
'detail': 'stop accepting new requests'})
|
|
threading.Thread(target=server.shutdown, name='shutdown', daemon=True).start()
|
|
|
|
for name in ('SIGTERM', 'SIGINT'):
|
|
if hasattr(signal, name):
|
|
signal.signal(getattr(signal, name), handle_signal)
|
|
|
|
logger.info('server_started', extra=dict(
|
|
{'event': 'server_started', 'version': __version__,
|
|
'detail': 'pid %d, python %s' % (os.getpid(), platform.python_version())},
|
|
**config.as_log_fields()))
|
|
started = time.monotonic()
|
|
try:
|
|
server.serve_forever(poll_interval=0.2)
|
|
finally:
|
|
server.server_close()
|
|
drained = server.wait_idle(config.shutdown_grace_seconds)
|
|
database.close()
|
|
logger.info('server_stopped', extra={
|
|
'event': 'server_stopped',
|
|
'outcome': 'graceful' if drained else 'grace_period_exceeded',
|
|
'duration_ms': round(1000 * (time.monotonic() - started), 3)})
|
|
return 0
|
|
|
|
|
|
def main(argv=None):
|
|
try:
|
|
config = Config.from_env()
|
|
except ConfigError as exc:
|
|
print('configuration error: %s' % exc, file=sys.stderr)
|
|
return 2
|
|
logger = logging_utils.configure(config.log_level)
|
|
database = Database(config)
|
|
cache = SessionCache(config)
|
|
try:
|
|
database.open()
|
|
database.run_migrations()
|
|
cache.open()
|
|
except Exception as exc: # noqa: BLE001 - startup must fail loud and clear
|
|
logger.error('database_start_failed', extra={
|
|
'event': 'database_start_failed', 'detail': str(exc)})
|
|
database.close()
|
|
cache.close()
|
|
return 1
|
|
try:
|
|
return run(config, logger, database, cache)
|
|
finally:
|
|
cache.close()
|