forked from mtusi2026/mtusi2026lab2
Подтверждённые сообщения и действующие сессии переживают перезапуск, история читается по индексу, копия восстанавливается в новый том. Co-authored-by: Cursor <cursoragent@cursor.com>
732 lines
27 KiB
Python
732 lines
27 KiB
Python
import json
|
|
import os
|
|
import re
|
|
import signal
|
|
import socket
|
|
import sys
|
|
import threading
|
|
import time
|
|
import uuid
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from urllib.parse import parse_qs, urlsplit
|
|
import base64
|
|
|
|
import cursor
|
|
import db
|
|
import passwords
|
|
import sessions
|
|
from errors import DependencyDown
|
|
|
|
MAX_BODY = 65536
|
|
DEFAULT_INFLIGHT_BODIES = 32
|
|
USERNAME = re.compile(r'^[a-z0-9_]{3,32}$')
|
|
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
|
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
|
|
|
|
|
class State:
|
|
def __init__(self, max_inflight_bodies):
|
|
self.accepting = True
|
|
slots = int(max_inflight_bodies)
|
|
if slots < 1:
|
|
slots = 1
|
|
self.body_slots = threading.BoundedSemaphore(slots)
|
|
|
|
|
|
class Limiter:
|
|
def __init__(self, max_per_second):
|
|
self.max_per_second = max_per_second
|
|
self._lock = threading.Lock()
|
|
self._recent = []
|
|
|
|
def allow(self):
|
|
if self.max_per_second <= 0:
|
|
return True
|
|
now = time.monotonic()
|
|
with self._lock:
|
|
self._recent = [stamp for stamp in self._recent if now - stamp < 1]
|
|
if len(self._recent) >= self.max_per_second:
|
|
return False
|
|
self._recent.append(now)
|
|
return True
|
|
|
|
|
|
def canonical_uuid(value):
|
|
if not isinstance(value, str):
|
|
return None
|
|
try:
|
|
return str(uuid.UUID(value))
|
|
except ValueError:
|
|
return None
|
|
|
|
|
|
def make_server(state, limiter, host, port):
|
|
class Handler(BaseHTTPRequestHandler):
|
|
def address_string(self):
|
|
return self.client_address[0]
|
|
|
|
def log_message(self, fmt, *args):
|
|
return
|
|
|
|
def do_GET(self):
|
|
self._handle()
|
|
|
|
def do_POST(self):
|
|
self._handle()
|
|
|
|
def do_PUT(self):
|
|
self._handle()
|
|
|
|
def do_PATCH(self):
|
|
self._handle()
|
|
|
|
def do_DELETE(self):
|
|
self._handle()
|
|
|
|
def _handle(self):
|
|
self.request_id = str(uuid.uuid4())
|
|
self._status = '-'
|
|
try:
|
|
self.connection.settimeout(15)
|
|
except OSError:
|
|
pass
|
|
try:
|
|
self._route()
|
|
except DependencyDown as exc:
|
|
print('dependency %s' % type(exc).__name__, flush=True)
|
|
if self._status == '-':
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
except Exception as exc:
|
|
print('internal %s' % type(exc).__name__, flush=True)
|
|
if self._status == '-':
|
|
self._error(500, 'internal_error', 'Внутренняя ошибка')
|
|
|
|
def _route(self):
|
|
parsed = urlsplit(self.path)
|
|
path = parsed.path
|
|
query = parse_qs(parsed.query, keep_blank_values=True)
|
|
if path == '/health/live' and self.command == 'GET':
|
|
self._json(200, {'status': 'ok'})
|
|
return
|
|
if not state.accepting:
|
|
self._error(503, 'unavailable', 'Сервер останавливается')
|
|
return
|
|
if path == '/health/ready' and self.command == 'GET':
|
|
self._ready()
|
|
return
|
|
if path == '/api/v1/users' and self.command == 'POST':
|
|
self._register()
|
|
return
|
|
if path == '/api/v1/auth/sessions' and self.command == 'POST':
|
|
self._login()
|
|
return
|
|
if path.startswith('/api/'):
|
|
self._api(path, query)
|
|
return
|
|
if path in ('/health/live', '/health/ready', '/api/v1/users', '/api/v1/auth/sessions'):
|
|
self._error(400, 'invalid_request', 'Метод не поддерживается')
|
|
return
|
|
self._error(404, 'not_found', 'Объект не найден')
|
|
|
|
def _ready(self):
|
|
try:
|
|
db.ping()
|
|
sessions.ping()
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
self._json(200, {'status': 'ok'})
|
|
|
|
def _api(self, path, query):
|
|
if not limiter.allow():
|
|
self._discard_body()
|
|
self._error(429, 'rate_limited', 'Слишком много запросов', retry_after=1)
|
|
return
|
|
user = self._user()
|
|
if user is None:
|
|
return
|
|
if path == '/api/v1/auth/sessions/current' and self.command == 'DELETE':
|
|
self._logout()
|
|
return
|
|
if path == '/api/v1/users/me' and self.command == 'GET':
|
|
self._json(200, user)
|
|
return
|
|
if path == '/api/v1/chats' and self.command == 'POST':
|
|
self._create_chat(user)
|
|
return
|
|
if path == '/api/v1/chats' and self.command == 'GET':
|
|
self._list_chats(user, query)
|
|
return
|
|
chat_match = re.fullmatch(r'/api/v1/chats/([^/]+)', path)
|
|
if chat_match and self.command == 'GET':
|
|
self._get_chat(user, chat_match.group(1))
|
|
return
|
|
msg_match = re.fullmatch(r'/api/v1/chats/([^/]+)/messages', path)
|
|
if msg_match and self.command == 'POST':
|
|
self._create_message(user, msg_match.group(1))
|
|
return
|
|
if msg_match and self.command == 'GET':
|
|
self._list_messages(user, msg_match.group(1), query)
|
|
return
|
|
self._error(404, 'not_found', 'Объект не найден')
|
|
|
|
def _user(self):
|
|
# X-User-Id is ignored from lab2. Basic is only valid on POST /auth/sessions.
|
|
scheme, value = _authorization(self.headers.get('Authorization'))
|
|
if scheme != 'bearer' or not sessions.token_shape(value):
|
|
self._discard_body()
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE)
|
|
return None
|
|
try:
|
|
user_id = sessions.read(value)
|
|
if user_id is None:
|
|
self._discard_body()
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE)
|
|
return None
|
|
user = db.get_user(user_id)
|
|
except DependencyDown:
|
|
self._discard_body()
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return None
|
|
if user is None:
|
|
self._discard_body()
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE)
|
|
return None
|
|
self._bearer = value
|
|
return user
|
|
|
|
def _logout(self):
|
|
self._discard_body()
|
|
if self._status != '-':
|
|
return
|
|
try:
|
|
gone = sessions.revoke(getattr(self, '_bearer', ''))
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if not gone:
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BEARER_CHALLENGE)
|
|
return
|
|
self._json(204, None)
|
|
|
|
def _login(self):
|
|
if not limiter.allow():
|
|
self._discard_body()
|
|
self._error(429, 'rate_limited', 'Слишком много запросов', retry_after=1)
|
|
return
|
|
raw_body, rejected = self._optional_empty_body()
|
|
if rejected:
|
|
return
|
|
if raw_body:
|
|
self._error(400, 'invalid_request', 'Тело запроса не нужно')
|
|
return
|
|
username, password = _basic_credentials(self.headers.get('Authorization'))
|
|
if username is None:
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BASIC_CHALLENGE)
|
|
return
|
|
try:
|
|
found = db.get_credentials(username)
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if found is None:
|
|
passwords.verify_password(passwords.DUMMY_HASH, password)
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BASIC_CHALLENGE)
|
|
return
|
|
user, password_hash = found
|
|
if not passwords.verify_password(password_hash, password):
|
|
self._error(401, 'unauthorized', 'Пользователь не опознан', challenge=BASIC_CHALLENGE)
|
|
return
|
|
try:
|
|
token, expires_at = sessions.create(user['id'])
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
self._json(201, {
|
|
'token': token,
|
|
'token_type': 'Bearer',
|
|
'expires_at': expires_at,
|
|
'user': user,
|
|
})
|
|
|
|
def _discard_body(self):
|
|
length, problem = _parse_content_length(self.headers.get('Content-Length'))
|
|
if problem == 'missing':
|
|
return
|
|
if problem == 'too_big':
|
|
self._reject_too_large()
|
|
return
|
|
if problem == 'bad':
|
|
self.close_connection = True
|
|
return
|
|
if length == 0:
|
|
return
|
|
data, busy = self._read_exact(length)
|
|
if busy or data is None or len(data) != length:
|
|
self.close_connection = True
|
|
|
|
def _optional_empty_body(self):
|
|
length, problem = _parse_content_length(self.headers.get('Content-Length'))
|
|
if problem == 'missing' or length == 0:
|
|
return b'', False
|
|
if problem == 'too_big':
|
|
self._reject_too_large()
|
|
self._error(413, 'payload_too_large', 'Тело запроса слишком большое')
|
|
return None, True
|
|
if problem == 'bad':
|
|
self.close_connection = True
|
|
self._error(400, 'invalid_request', 'Некорректный запрос')
|
|
return None, True
|
|
raw, busy = self._read_exact(length)
|
|
if busy:
|
|
self._error(503, 'unavailable', 'Слишком много одновременных тел запроса')
|
|
return None, True
|
|
if raw is None or len(raw) != length:
|
|
self.close_connection = True
|
|
self._error(400, 'invalid_request', 'Некорректный запрос')
|
|
return None, True
|
|
return raw.strip(), False
|
|
|
|
def _read_exact(self, length):
|
|
if length == 0:
|
|
return b'', False
|
|
if not state.body_slots.acquire(blocking=False):
|
|
self.close_connection = True
|
|
return None, True
|
|
try:
|
|
return self.rfile.read(length), False
|
|
finally:
|
|
state.body_slots.release()
|
|
|
|
def _reject_too_large(self):
|
|
self.close_connection = True
|
|
if not state.body_slots.acquire(blocking=False):
|
|
return
|
|
previous = self.connection.gettimeout()
|
|
self.connection.settimeout(0.2)
|
|
try:
|
|
remaining = MAX_BODY
|
|
while remaining > 0:
|
|
try:
|
|
chunk = self.rfile.read(min(8192, remaining))
|
|
except (TimeoutError, socket.timeout, OSError):
|
|
break
|
|
if not chunk:
|
|
break
|
|
remaining -= len(chunk)
|
|
finally:
|
|
state.body_slots.release()
|
|
try:
|
|
self.connection.settimeout(previous)
|
|
except OSError:
|
|
pass
|
|
|
|
def _register(self):
|
|
if not limiter.allow():
|
|
self._discard_body()
|
|
self._error(429, 'rate_limited', 'Слишком много запросов', retry_after=1)
|
|
return
|
|
body, problem = self._json_body({'username', 'display_name', 'password'})
|
|
if problem:
|
|
return
|
|
username = body['username']
|
|
display_name = body['display_name']
|
|
password = body['password']
|
|
if not isinstance(username, str) or USERNAME.fullmatch(username) is None:
|
|
self._error(400, 'invalid_request', 'Некорректный username')
|
|
return
|
|
if not _text_ok(display_name, 100):
|
|
self._error(400, 'invalid_request', 'Некорректный display_name')
|
|
return
|
|
if not _password_ok(password):
|
|
self._error(400, 'invalid_request', 'Некорректный пароль')
|
|
return
|
|
try:
|
|
status, user = db.create_user(username, display_name, passwords.hash_password(password))
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if status == 'conflict':
|
|
self._error(409, 'conflict', 'Такой username уже занят')
|
|
return
|
|
if status != 'ok':
|
|
self._error(400, 'invalid_request', 'Некорректные поля JSON')
|
|
return
|
|
self._json(201, user)
|
|
|
|
def _create_chat(self, user):
|
|
body, problem = self._json_body({'title', 'member_ids'})
|
|
if problem:
|
|
return
|
|
title = body['title']
|
|
member_ids = body['member_ids']
|
|
if not _text_ok(title, 100):
|
|
self._error(400, 'invalid_request', 'Некорректный title')
|
|
return
|
|
parsed_ids, ok = _member_ids(member_ids, user['id'])
|
|
if not ok:
|
|
self._error(400, 'invalid_request', 'Некорректный список участников')
|
|
return
|
|
try:
|
|
status, chat = db.create_chat(user['id'], title, parsed_ids)
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if status != 'ok':
|
|
self._error(400, 'invalid_request', 'Некорректный список участников')
|
|
return
|
|
self._json(201, chat)
|
|
|
|
def _list_chats(self, user, query):
|
|
limit, page_cursor, problem = _page_args(query, 'chats', user['id'])
|
|
if problem:
|
|
self._error(400, 'invalid_request', problem)
|
|
return
|
|
try:
|
|
items, nxt = db.list_chats(user['id'], limit, page_cursor)
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
self._json(200, {'items': items, 'next_cursor': nxt})
|
|
|
|
def _get_chat(self, user, raw_chat_id):
|
|
chat_id = canonical_uuid(raw_chat_id)
|
|
if chat_id is None:
|
|
self._error(400, 'invalid_request', 'Некорректный UUID')
|
|
return
|
|
try:
|
|
chat = db.get_chat(chat_id, user['id'])
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if chat is None:
|
|
self._error(404, 'not_found', 'Объект не найден')
|
|
return
|
|
self._json(200, chat)
|
|
|
|
def _create_message(self, user, raw_chat_id):
|
|
chat_id = canonical_uuid(raw_chat_id)
|
|
if chat_id is None:
|
|
self._error(400, 'invalid_request', 'Некорректный UUID')
|
|
return
|
|
body, problem = self._json_body({'text'})
|
|
if problem:
|
|
return
|
|
text = body['text']
|
|
if not _text_ok(text, 4000):
|
|
self._error(400, 'invalid_request', 'Некорректный текст сообщения')
|
|
return
|
|
try:
|
|
status, message = db.add_message(chat_id, user['id'], text)
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if status == 'missing':
|
|
self._error(404, 'not_found', 'Объект не найден')
|
|
return
|
|
if status == 'full':
|
|
self._error(503, 'unavailable', 'Достигнут предел числа сообщений')
|
|
return
|
|
self._json(201, message)
|
|
|
|
def _list_messages(self, user, raw_chat_id, query):
|
|
chat_id = canonical_uuid(raw_chat_id)
|
|
if chat_id is None:
|
|
self._error(400, 'invalid_request', 'Некорректный UUID')
|
|
return
|
|
limit, page_cursor, problem = _page_args(query, 'msgs', chat_id)
|
|
if problem:
|
|
self._error(400, 'invalid_request', problem)
|
|
return
|
|
try:
|
|
status, items, nxt = db.list_messages(chat_id, user['id'], limit, page_cursor)
|
|
except DependencyDown:
|
|
self._error(503, 'unavailable', 'Сервис временно недоступен')
|
|
return
|
|
if status == 'missing':
|
|
self._error(404, 'not_found', 'Объект не найден')
|
|
return
|
|
self._json(200, {'items': items, 'next_cursor': nxt})
|
|
|
|
def _json_body(self, fields):
|
|
raw, code, message = self._read_body()
|
|
if code:
|
|
self._error(code, _error_code(code), message)
|
|
return None, True
|
|
try:
|
|
body = json.loads(raw.decode('utf-8'))
|
|
except (UnicodeError, json.JSONDecodeError):
|
|
self._error(400, 'invalid_request', 'Некорректный JSON')
|
|
return None, True
|
|
if not isinstance(body, dict) or set(body) != fields:
|
|
self._error(400, 'invalid_request', 'Некорректные поля JSON')
|
|
return None, True
|
|
return body, False
|
|
|
|
def _read_body(self):
|
|
length, problem = _parse_content_length(self.headers.get('Content-Length'))
|
|
if problem == 'missing' or problem == 'bad':
|
|
self.close_connection = True
|
|
return None, 400, 'Некорректный JSON'
|
|
if problem == 'too_big':
|
|
self._reject_too_large()
|
|
return None, 413, 'Тело запроса слишком большое'
|
|
if not _json_content_type(self.headers.get('Content-Type', '')):
|
|
self._read_exact(length)
|
|
return None, 415, 'Нужен Content-Type application/json'
|
|
raw, busy = self._read_exact(length)
|
|
if busy:
|
|
return None, 503, 'Слишком много одновременных тел запроса'
|
|
if raw is None or len(raw) != length:
|
|
self.close_connection = True
|
|
return None, 400, 'Некорректный JSON'
|
|
return raw, None, None
|
|
|
|
def _error(self, status, code, message, retry_after=None, challenge=None):
|
|
self._json(status, {
|
|
'error': {
|
|
'code': code,
|
|
'message': message,
|
|
'request_id': self.request_id,
|
|
}
|
|
}, retry_after=retry_after, challenge=challenge)
|
|
|
|
def _json(self, status, payload, retry_after=None, challenge=None):
|
|
if self._status != '-':
|
|
return
|
|
if status == 204:
|
|
body = b''
|
|
else:
|
|
body = json.dumps(payload, ensure_ascii=False).encode('utf-8')
|
|
self.send_response(status)
|
|
if status != 204:
|
|
self.send_header('Content-Type', 'application/json; charset=utf-8')
|
|
self.send_header('Content-Length', str(len(body)))
|
|
self.send_header('X-Request-Id', self.request_id)
|
|
if challenge is not None:
|
|
self.send_header('WWW-Authenticate', challenge)
|
|
if retry_after is not None:
|
|
self.send_header('Retry-After', str(retry_after))
|
|
self.end_headers()
|
|
if body:
|
|
self.wfile.write(body)
|
|
self._status = status
|
|
path = urlsplit(self.path).path
|
|
print('%s %s %s %s' % (self.request_id, self.command, path, status), flush=True)
|
|
|
|
class Server(ThreadingHTTPServer):
|
|
allow_reuse_address = True
|
|
daemon_threads = True
|
|
|
|
return Server((host, port), Handler)
|
|
|
|
|
|
def _error_code(status):
|
|
return {
|
|
400: 'invalid_request',
|
|
413: 'payload_too_large',
|
|
415: 'unsupported_media_type',
|
|
503: 'unavailable',
|
|
}.get(status, 'invalid_request')
|
|
|
|
|
|
def _json_content_type(value):
|
|
if not value:
|
|
return False
|
|
media = value.split(';', 1)[0].strip().lower()
|
|
return media == 'application/json'
|
|
|
|
|
|
def _parse_content_length(raw):
|
|
if raw is None:
|
|
return None, 'missing'
|
|
text = raw.strip()
|
|
if not re.fullmatch(r'[0-9]+', text):
|
|
return None, 'bad'
|
|
digits = text.lstrip('0') or '0'
|
|
if len(digits) > 7:
|
|
return None, 'too_big'
|
|
try:
|
|
length = int(digits)
|
|
except ValueError:
|
|
return None, 'too_big'
|
|
if length > MAX_BODY:
|
|
return length, 'too_big'
|
|
return length, None
|
|
|
|
|
|
def _text_ok(value, limit):
|
|
return (
|
|
isinstance(value, str)
|
|
and 1 <= len(value) <= limit
|
|
and value.strip() != ''
|
|
)
|
|
|
|
|
|
def _password_ok(value):
|
|
return (
|
|
isinstance(value, str)
|
|
and 12 <= len(value) <= 128
|
|
and value.strip() != ''
|
|
)
|
|
|
|
|
|
def _member_ids(value, owner_id):
|
|
if not isinstance(value, list) or not 1 <= len(value) <= 100:
|
|
return None, False
|
|
parsed = []
|
|
for item in value:
|
|
item_id = canonical_uuid(item)
|
|
if item_id is None:
|
|
return None, False
|
|
parsed.append(item_id)
|
|
if len(set(parsed)) != len(parsed):
|
|
return None, False
|
|
if owner_id not in parsed:
|
|
return None, False
|
|
return parsed, True
|
|
|
|
|
|
def _page_args(query, kind, owner_id):
|
|
if 'limit' not in query:
|
|
limit = 50
|
|
else:
|
|
raw = query['limit']
|
|
if len(raw) != 1 or re.fullmatch(r'[0-9]+', raw[0]) is None:
|
|
return None, None, 'Некорректный limit'
|
|
digits = raw[0].lstrip('0') or '0'
|
|
if len(digits) > 3:
|
|
return None, None, 'Некорректный limit'
|
|
try:
|
|
limit = int(digits)
|
|
except ValueError:
|
|
return None, None, 'Некорректный limit'
|
|
if limit < 1 or limit > 100:
|
|
return None, None, 'Некорректный limit'
|
|
if 'cursor' not in query:
|
|
return limit, None, None
|
|
raw_cursor = query['cursor']
|
|
if len(raw_cursor) != 1 or raw_cursor[0] == '':
|
|
return None, None, 'Некорректный cursor'
|
|
page_cursor = cursor.read_cursor(raw_cursor[0], kind, owner_id)
|
|
if page_cursor is None:
|
|
return None, None, 'Некорректный cursor'
|
|
return limit, page_cursor, None
|
|
|
|
|
|
def _authorization(header):
|
|
if not header:
|
|
return None, None
|
|
parts = header.split(None, 1)
|
|
if len(parts) != 2:
|
|
return None, None
|
|
return parts[0].lower(), parts[1].strip()
|
|
|
|
|
|
def _basic_credentials(header):
|
|
scheme, value = _authorization(header)
|
|
if scheme != 'basic' or not value:
|
|
return None, None
|
|
try:
|
|
raw = base64.b64decode(value, validate=True)
|
|
text = raw.decode('utf-8')
|
|
except (ValueError, UnicodeError):
|
|
return None, None
|
|
if ':' not in text:
|
|
return None, None
|
|
username, password = text.split(':', 1)
|
|
if USERNAME.fullmatch(username) is None or password == '':
|
|
return None, None
|
|
return username, password
|
|
|
|
|
|
def _positive_int(name, default):
|
|
raw = os.environ.get(name, str(default))
|
|
try:
|
|
value = int(raw)
|
|
except ValueError:
|
|
print('bad integer %s' % name, flush=True)
|
|
return None
|
|
return value
|
|
|
|
|
|
def wait_until_ready(stop):
|
|
deadline = time.monotonic() + 75
|
|
while not stop['flag']:
|
|
try:
|
|
applied = db.apply_migrations()
|
|
db.open_pool()
|
|
sessions.open_client()
|
|
sessions.ping()
|
|
db.ping()
|
|
if applied:
|
|
print('migrations applied: %s' % ','.join(applied), flush=True)
|
|
else:
|
|
print('migrations already applied', flush=True)
|
|
return True
|
|
except RuntimeError:
|
|
print('configuration error', flush=True)
|
|
return False
|
|
except Exception as exc:
|
|
print('waiting for postgres/redis: %s' % type(exc).__name__, flush=True)
|
|
db.close_pool()
|
|
sessions.close_client()
|
|
if time.monotonic() > deadline:
|
|
print('dependencies not ready', flush=True)
|
|
return False
|
|
time.sleep(1)
|
|
return False
|
|
|
|
|
|
def main():
|
|
host = os.environ.get('APP_HOST', '0.0.0.0')
|
|
port = _positive_int('APP_PORT', 8080)
|
|
message_cap = _positive_int('MAX_MESSAGES', 100000)
|
|
max_per_second = _positive_int('MAX_PER_SECOND', 10000)
|
|
max_inflight_bodies = _positive_int('MAX_INFLIGHT_BODIES', DEFAULT_INFLIGHT_BODIES)
|
|
ttl = _positive_int('SESSION_TTL_SECONDS', 3600)
|
|
if None in (port, message_cap, max_per_second, max_inflight_bodies, ttl) or ttl < 1:
|
|
sys.exit(1)
|
|
sessions.configure(ttl)
|
|
db.configure(message_cap)
|
|
stop = {'flag': False}
|
|
|
|
def stop_waiting(signum, frame):
|
|
stop['flag'] = True
|
|
print('signal %s during startup' % signum, flush=True)
|
|
|
|
signal.signal(signal.SIGTERM, stop_waiting)
|
|
signal.signal(signal.SIGINT, stop_waiting)
|
|
if not wait_until_ready(stop):
|
|
db.close_pool()
|
|
sessions.close_client()
|
|
sys.exit(0 if stop['flag'] else 1)
|
|
|
|
state = State(max_inflight_bodies)
|
|
limiter = Limiter(max_per_second)
|
|
httpd = make_server(state, limiter, host, port)
|
|
|
|
def stop_serving(signum, frame):
|
|
state.accepting = False
|
|
print('signal %s: stop accepting' % signum, flush=True)
|
|
threading.Thread(target=httpd.shutdown, daemon=True).start()
|
|
|
|
signal.signal(signal.SIGTERM, stop_serving)
|
|
signal.signal(signal.SIGINT, stop_serving)
|
|
print(
|
|
'listen http://%s:%s ttl=%s max_messages=%s pool=%s-%s'
|
|
% (host, port, ttl, message_cap, db.POOL_MIN, db.POOL_MAX),
|
|
flush=True,
|
|
)
|
|
try:
|
|
httpd.serve_forever()
|
|
finally:
|
|
httpd.server_close()
|
|
db.close_pool()
|
|
sessions.close_client()
|
|
print('process stopped', flush=True)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|