forked from mtusi2026/mtusi2026lab2
ЛР 2 — БВТ2304 — Гончаревская.Е.А. - на 3
This commit is contained in:
@@ -0,0 +1,796 @@
|
||||
import base64
|
||||
import datetime as dt
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import signal
|
||||
import threading
|
||||
import uuid
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
|
||||
import psycopg
|
||||
from psycopg import rows
|
||||
from psycopg.errors import UniqueViolation
|
||||
from psycopg_pool import ConnectionPool, PoolTimeout
|
||||
import redis
|
||||
from argon2 import PasswordHasher, exceptions as argon2_exceptions
|
||||
from argon2.low_level import Type
|
||||
|
||||
HOST = os.getenv("APP_HOST", "0.0.0.0")
|
||||
PORT = int(os.getenv("APP_PORT", "8080"))
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
DATABASE_URL_FILE = os.getenv("DATABASE_URL_FILE", "/run/secrets/database_url")
|
||||
REDIS_URL_FILE = os.getenv("REDIS_URL_FILE", "/run/secrets/redis_url")
|
||||
MAX_BODY_SIZE = 16 * 1024 * 1024
|
||||
|
||||
logging.basicConfig(level=os.getenv("LOG_LEVEL", "INFO"), format="%(asctime)s %(levelname)s %(message)s")
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
pool = None
|
||||
redis_client = None
|
||||
password_hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1, hash_len=32, salt_len=16, type=Type.ID)
|
||||
shutting_down = False
|
||||
server = None
|
||||
|
||||
|
||||
def read_secret(path):
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
|
||||
|
||||
def now_utc():
|
||||
return dt.datetime.now(dt.timezone.utc)
|
||||
|
||||
|
||||
def format_time(value):
|
||||
if value.tzinfo is None:
|
||||
value = value.replace(tzinfo=dt.timezone.utc)
|
||||
return value.astimezone(dt.timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def new_id():
|
||||
return str(uuid.uuid4())
|
||||
|
||||
|
||||
def error_body(code, message, request_id):
|
||||
return {"error": {"code": code, "message": message, "request_id": request_id}}
|
||||
|
||||
|
||||
def json_bytes(value):
|
||||
return json.dumps(value, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
|
||||
|
||||
|
||||
def valid_username(value):
|
||||
return isinstance(value, str) and re.fullmatch(r"[a-z0-9_]{3,32}", value) is not None
|
||||
|
||||
|
||||
def valid_nonblank_string(value, maximum):
|
||||
return isinstance(value, str) and 1 <= len(value) <= maximum and bool(value.strip())
|
||||
|
||||
|
||||
def valid_uuid(value):
|
||||
try:
|
||||
uuid.UUID(value)
|
||||
return True
|
||||
except (ValueError, AttributeError, TypeError):
|
||||
return False
|
||||
|
||||
|
||||
def parse_json_object(raw):
|
||||
try:
|
||||
value = json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError):
|
||||
raise ValueError
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError
|
||||
return value
|
||||
|
||||
|
||||
def encode_cursor(scope, created_at, object_id):
|
||||
payload = json.dumps(
|
||||
{"scope": scope, "created_at": format_time(created_at), "id": str(object_id)},
|
||||
separators=(",", ":"),
|
||||
ensure_ascii=False,
|
||||
).encode("utf-8")
|
||||
return base64.urlsafe_b64encode(payload).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(cursor):
|
||||
try:
|
||||
raw = cursor.encode("ascii")
|
||||
raw += b"=" * (-len(raw) % 4)
|
||||
value = json.loads(base64.urlsafe_b64decode(raw).decode("utf-8"))
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError
|
||||
if not all(isinstance(value.get(key), str) and value[key] for key in ("scope", "created_at", "id")):
|
||||
raise ValueError
|
||||
object_id = uuid.UUID(value["id"])
|
||||
created_at = dt.datetime.fromisoformat(value["created_at"].replace("Z", "+00:00"))
|
||||
if created_at.tzinfo is None:
|
||||
raise ValueError
|
||||
return value["scope"], created_at, str(object_id)
|
||||
except (ValueError, UnicodeError, json.JSONDecodeError, KeyError, TypeError):
|
||||
raise ValueError
|
||||
|
||||
|
||||
def validate_keys(value, required):
|
||||
return set(value) == set(required)
|
||||
|
||||
|
||||
def apply_migrations():
|
||||
migration_dir = Path(__file__).resolve().parent / "migrations"
|
||||
with pool.connection() as conn:
|
||||
conn.execute(
|
||||
"CREATE TABLE IF NOT EXISTS schema_migrations (version TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT now())"
|
||||
)
|
||||
conn.execute("SELECT pg_advisory_xact_lock(%s)", (7202026,))
|
||||
for migration in sorted(migration_dir.glob("*.sql")):
|
||||
version = migration.name
|
||||
exists = conn.execute(
|
||||
"SELECT 1 FROM schema_migrations WHERE version = %s", (version,)
|
||||
).fetchone()
|
||||
if exists:
|
||||
continue
|
||||
migration_sql = migration.read_text(encoding="utf-8")
|
||||
for statement in migration_sql.split(";"):
|
||||
if statement.strip():
|
||||
conn.execute(statement)
|
||||
conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,))
|
||||
logger.info("migration applied version=%s", version)
|
||||
|
||||
|
||||
def init_services():
|
||||
global pool, redis_client
|
||||
if SESSION_TTL_SECONDS < 1:
|
||||
raise RuntimeError("SESSION_TTL_SECONDS must be positive")
|
||||
database_url = read_secret(DATABASE_URL_FILE)
|
||||
redis_url = read_secret(REDIS_URL_FILE)
|
||||
pool = ConnectionPool(
|
||||
conninfo=database_url,
|
||||
min_size=1,
|
||||
max_size=10,
|
||||
timeout=5,
|
||||
kwargs={"row_factory": rows.dict_row},
|
||||
open=True,
|
||||
)
|
||||
pool.wait(timeout=30)
|
||||
apply_migrations()
|
||||
redis_client = redis.Redis.from_url(
|
||||
redis_url,
|
||||
decode_responses=True,
|
||||
socket_connect_timeout=1,
|
||||
socket_timeout=1,
|
||||
health_check_interval=30,
|
||||
)
|
||||
try:
|
||||
redis_client.ping()
|
||||
logger.info("session cache connected")
|
||||
except redis.RedisError:
|
||||
logger.warning("session cache unavailable; PostgreSQL fallback is active")
|
||||
|
||||
|
||||
def best_effort_cache_delete(key):
|
||||
try:
|
||||
redis_client.delete(key)
|
||||
except redis.RedisError:
|
||||
logger.warning("session cache delete failed; PostgreSQL remains authoritative")
|
||||
|
||||
|
||||
def cache_session(token_hash, user_id, expires_at):
|
||||
ttl = max(1, int((expires_at - now_utc()).total_seconds()))
|
||||
payload = json.dumps({"user_id": str(user_id), "expires_at": format_time(expires_at)}, separators=(",", ":"))
|
||||
try:
|
||||
redis_client.set("session:" + token_hash, payload, ex=ttl)
|
||||
except redis.RedisError:
|
||||
logger.warning("session cache write failed; PostgreSQL remains authoritative")
|
||||
|
||||
|
||||
def public_user(row):
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": format_time(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def public_chat(row, member_ids):
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": [str(value) for value in member_ids],
|
||||
"created_at": format_time(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def public_message(row):
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"sender_id": str(row["sender_id"]),
|
||||
"text": row["text"],
|
||||
"created_at": format_time(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def parse_limit_cursor(query):
|
||||
limit_values = query.get("limit", ["50"])
|
||||
cursor_values = query.get("cursor", [None])
|
||||
if len(limit_values) != 1 or len(cursor_values) != 1:
|
||||
raise ValueError
|
||||
try:
|
||||
limit = int(limit_values[0])
|
||||
except (TypeError, ValueError):
|
||||
raise ValueError
|
||||
if limit < 1 or limit > 100 or str(limit) != limit_values[0].lstrip("+"):
|
||||
raise ValueError
|
||||
cursor = cursor_values[0]
|
||||
if cursor == "":
|
||||
raise ValueError
|
||||
return limit, cursor
|
||||
|
||||
|
||||
def authenticate_basic(header):
|
||||
if not header or not header.startswith("Basic "):
|
||||
return None
|
||||
try:
|
||||
decoded = base64.b64decode(header[6:], validate=True).decode("utf-8")
|
||||
username, password = decoded.split(":", 1)
|
||||
except (ValueError, UnicodeDecodeError):
|
||||
return None
|
||||
if not valid_username(username) or not isinstance(password, str):
|
||||
return None
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
|
||||
(username,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
password_hasher.verify(row["password_hash"], password)
|
||||
return row
|
||||
except (argon2_exceptions.VerifyMismatchError, argon2_exceptions.InvalidHashError, argon2_exceptions.VerificationError):
|
||||
return None
|
||||
|
||||
|
||||
def authenticate_bearer(header):
|
||||
if not header or not header.startswith("Bearer "):
|
||||
return None
|
||||
token = header[7:].strip()
|
||||
if len(token) < 32 or len(token) > 256 or " " in token:
|
||||
return None
|
||||
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
cached_user_id = None
|
||||
try:
|
||||
cached = redis_client.get("session:" + token_hash)
|
||||
if cached:
|
||||
cached_value = json.loads(cached)
|
||||
cached_user_id = cached_value.get("user_id")
|
||||
cached_expiry = dt.datetime.fromisoformat(cached_value["expires_at"].replace("Z", "+00:00"))
|
||||
if cached_expiry <= now_utc() or not valid_uuid(cached_user_id):
|
||||
cached_user_id = None
|
||||
except (redis.RedisError, ValueError, TypeError, KeyError, AttributeError):
|
||||
cached_user_id = None
|
||||
logger.warning("session cache read failed; PostgreSQL fallback is active")
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
if cached_user_id and valid_uuid(cached_user_id):
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = %s AND s.user_id = %s
|
||||
AND s.revoked_at IS NULL AND s.expires_at > now()
|
||||
""",
|
||||
(token_hash, uuid.UUID(cached_user_id)),
|
||||
).fetchone()
|
||||
else:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()
|
||||
""",
|
||||
(token_hash,),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
best_effort_cache_delete("session:" + token_hash)
|
||||
return None
|
||||
if cached_user_id is None:
|
||||
cache_session(token_hash, row["id"], row["expires_at"])
|
||||
return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"],
|
||||
"created_at": row["created_at"], "token_hash": token_hash, "expires_at": row["expires_at"]}
|
||||
except (psycopg.Error, PoolTimeout):
|
||||
logger.exception("database unavailable during authentication")
|
||||
raise
|
||||
|
||||
|
||||
class MessengerServer(ThreadingHTTPServer):
|
||||
daemon_threads = True
|
||||
allow_reuse_address = True
|
||||
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
protocol_version = "HTTP/1.1"
|
||||
|
||||
def setup(self):
|
||||
super().setup()
|
||||
self.request_id = new_id()
|
||||
self.response_status = 500
|
||||
self.actor = None
|
||||
|
||||
def log_message(self, fmt, *args):
|
||||
logger.info("%s %s %s request_id=%s user=%s", self.command, self.path.split("?", 1)[0],
|
||||
self.response_status, self.request_id, (self.actor.get("id", "-") if self.actor else "-"))
|
||||
|
||||
def send_json(self, status, payload, challenge=None):
|
||||
data = json_bytes(payload)
|
||||
self.response_status = status
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(data)))
|
||||
self.send_header("X-Request-Id", self.request_id)
|
||||
if challenge:
|
||||
self.send_header("WWW-Authenticate", challenge)
|
||||
self.end_headers()
|
||||
self.wfile.write(data)
|
||||
|
||||
def send_empty(self, status):
|
||||
self.response_status = status
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Length", "0")
|
||||
self.send_header("X-Request-Id", self.request_id)
|
||||
self.end_headers()
|
||||
|
||||
def send_error_json(self, status, code, message, challenge=None):
|
||||
self.send_json(status, error_body(code, message, self.request_id), challenge)
|
||||
|
||||
def unavailable(self):
|
||||
self.send_error_json(503, "unavailable", "Service temporarily unavailable")
|
||||
|
||||
def read_body(self):
|
||||
value = self.headers.get("Content-Length")
|
||||
if value is None:
|
||||
raise ValueError
|
||||
try:
|
||||
length = int(value)
|
||||
except ValueError:
|
||||
raise ValueError
|
||||
if length < 0:
|
||||
raise ValueError
|
||||
if length > MAX_BODY_SIZE:
|
||||
raise OverflowError
|
||||
return self.rfile.read(length)
|
||||
|
||||
def require_json(self):
|
||||
if self.headers.get_content_type() != "application/json":
|
||||
self.send_error_json(415, "unsupported_media_type", "Content-Type must be application/json")
|
||||
return None
|
||||
try:
|
||||
return parse_json_object(self.read_body())
|
||||
except OverflowError:
|
||||
self.send_error_json(413, "payload_too_large", "Request body is too large")
|
||||
except ValueError:
|
||||
self.send_error_json(400, "invalid_request", "Invalid JSON request")
|
||||
return None
|
||||
|
||||
def identify(self):
|
||||
user = authenticate_bearer(self.headers.get("Authorization"))
|
||||
if user is None:
|
||||
self.send_error_json(401, "unauthorized", "Valid Bearer session required",
|
||||
'Bearer realm="messenger"')
|
||||
return None
|
||||
self.actor = user
|
||||
return user
|
||||
|
||||
def check_ready_for_write(self):
|
||||
if shutting_down:
|
||||
self.send_error_json(503, "unavailable", "Service is shutting down")
|
||||
return False
|
||||
return True
|
||||
|
||||
def do_GET(self):
|
||||
self.dispatch("GET")
|
||||
|
||||
def do_POST(self):
|
||||
self.dispatch("POST")
|
||||
|
||||
def do_DELETE(self):
|
||||
self.dispatch("DELETE")
|
||||
|
||||
def do_PUT(self):
|
||||
self.send_error_json(404, "not_found", "Object not found")
|
||||
|
||||
def do_PATCH(self):
|
||||
self.send_error_json(404, "not_found", "Object not found")
|
||||
|
||||
def dispatch(self, method):
|
||||
try:
|
||||
self.route(method)
|
||||
except (psycopg.Error, PoolTimeout):
|
||||
logger.exception("database operation failed request_id=%s", self.request_id)
|
||||
if not self.wfile.closed:
|
||||
try:
|
||||
self.unavailable()
|
||||
except OSError:
|
||||
pass
|
||||
except redis.RedisError:
|
||||
logger.exception("cache operation failed request_id=%s", self.request_id)
|
||||
if not self.wfile.closed:
|
||||
try:
|
||||
self.unavailable()
|
||||
except OSError:
|
||||
pass
|
||||
except Exception:
|
||||
logger.exception("unexpected request error request_id=%s", self.request_id)
|
||||
if not self.wfile.closed:
|
||||
try:
|
||||
self.send_error_json(500, "internal_error", "Internal server error")
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def route(self, method):
|
||||
parsed = urlsplit(self.path)
|
||||
parts = [part for part in parsed.path.split("/") if part]
|
||||
query = parse_qs(parsed.query, keep_blank_values=True)
|
||||
|
||||
if method == "GET" and parts == ["health", "live"]:
|
||||
self.send_json(200, {"status": "ok"})
|
||||
return
|
||||
if method == "GET" and parts == ["health", "ready"]:
|
||||
if shutting_down:
|
||||
self.unavailable()
|
||||
return
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
conn.execute("SELECT 1")
|
||||
self.send_json(200, {"status": "ok"})
|
||||
except (psycopg.Error, PoolTimeout):
|
||||
self.unavailable()
|
||||
return
|
||||
if shutting_down:
|
||||
self.unavailable()
|
||||
return
|
||||
|
||||
if method == "POST" and parts == ["api", "v1", "users"]:
|
||||
self.create_user()
|
||||
return
|
||||
if method == "POST" and parts == ["api", "v1", "auth", "sessions"]:
|
||||
self.create_session()
|
||||
return
|
||||
if method == "DELETE" and parts == ["api", "v1", "auth", "sessions", "current"]:
|
||||
self.delete_session()
|
||||
return
|
||||
if method == "GET" and parts == ["api", "v1", "users", "me"]:
|
||||
user = self.identify()
|
||||
if user is not None:
|
||||
self.send_json(200, public_user(user))
|
||||
return
|
||||
|
||||
if parts[:3] == ["api", "v1", "chats"]:
|
||||
if len(parts) == 3:
|
||||
if method == "POST":
|
||||
self.create_chat()
|
||||
return
|
||||
if method == "GET":
|
||||
self.list_chats(query)
|
||||
return
|
||||
if len(parts) == 4 and method == "GET":
|
||||
if not valid_uuid(parts[3]):
|
||||
if self.identify() is not None:
|
||||
self.send_error_json(400, "invalid_request", "Invalid chat UUID")
|
||||
return
|
||||
self.get_chat(parts[3])
|
||||
return
|
||||
if len(parts) == 5 and parts[4] == "messages":
|
||||
if not valid_uuid(parts[3]):
|
||||
if self.identify() is not None:
|
||||
self.send_error_json(400, "invalid_request", "Invalid chat UUID")
|
||||
return
|
||||
if method == "POST":
|
||||
self.create_message(parts[3])
|
||||
return
|
||||
if method == "GET":
|
||||
self.list_messages(parts[3], query)
|
||||
return
|
||||
self.send_error_json(404, "not_found", "Object not found")
|
||||
|
||||
def create_user(self):
|
||||
if not self.check_ready_for_write():
|
||||
return
|
||||
body = self.require_json()
|
||||
if body is None:
|
||||
return
|
||||
if not validate_keys(body, {"username", "display_name", "password"}):
|
||||
self.send_error_json(400, "invalid_request", "Invalid user fields")
|
||||
return
|
||||
username = body["username"]
|
||||
display_name = body["display_name"]
|
||||
password = body["password"]
|
||||
if (not valid_username(username) or not valid_nonblank_string(display_name, 100)
|
||||
or not isinstance(password, str) or not 12 <= len(password) <= 128):
|
||||
self.send_error_json(400, "invalid_request", "Invalid user fields")
|
||||
return
|
||||
password_hash = password_hasher.hash(password)
|
||||
user_id = new_id()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
INSERT INTO users(id, username, display_name, password_hash)
|
||||
VALUES (%s, %s, %s, %s)
|
||||
RETURNING id, username, display_name, created_at
|
||||
""",
|
||||
(uuid.UUID(user_id), username, display_name, password_hash),
|
||||
).fetchone()
|
||||
except UniqueViolation:
|
||||
self.send_error_json(409, "conflict", "Username is already in use")
|
||||
return
|
||||
self.send_json(201, public_user(row))
|
||||
|
||||
def create_session(self):
|
||||
if not self.check_ready_for_write():
|
||||
return
|
||||
user = authenticate_basic(self.headers.get("Authorization"))
|
||||
if user is None:
|
||||
self.send_error_json(401, "unauthorized", "Invalid username or password",
|
||||
'Basic realm="messenger", charset="UTF-8"')
|
||||
return
|
||||
token = secrets.token_urlsafe(32)
|
||||
token_hash = hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
expires_at = now_utc() + dt.timedelta(seconds=SESSION_TTL_SECONDS)
|
||||
with pool.connection() as conn:
|
||||
conn.execute(
|
||||
"INSERT INTO sessions(token_hash, user_id, expires_at) VALUES (%s, %s, %s)",
|
||||
(token_hash, user["id"], expires_at),
|
||||
)
|
||||
cache_session(token_hash, user["id"], expires_at)
|
||||
self.send_json(201, {
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": format_time(expires_at),
|
||||
"user": public_user(user),
|
||||
})
|
||||
|
||||
def delete_session(self):
|
||||
if not self.check_ready_for_write():
|
||||
return
|
||||
user = self.identify()
|
||||
if user is None:
|
||||
return
|
||||
with pool.connection() as conn:
|
||||
conn.execute("UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL", (user["token_hash"],))
|
||||
best_effort_cache_delete("session:" + user["token_hash"])
|
||||
self.send_empty(204)
|
||||
|
||||
def create_chat(self):
|
||||
if not self.check_ready_for_write():
|
||||
return
|
||||
user = self.identify()
|
||||
if user is None:
|
||||
return
|
||||
body = self.require_json()
|
||||
if body is None:
|
||||
return
|
||||
if not validate_keys(body, {"title", "member_ids"}):
|
||||
self.send_error_json(400, "invalid_request", "Invalid chat fields")
|
||||
return
|
||||
title = body["title"]
|
||||
member_ids = body["member_ids"]
|
||||
if (not valid_nonblank_string(title, 100) or not isinstance(member_ids, list)
|
||||
or not 1 <= len(member_ids) <= 100):
|
||||
self.send_error_json(400, "invalid_request", "Invalid chat fields")
|
||||
return
|
||||
if any(not isinstance(value, str) or not valid_uuid(value) for value in member_ids):
|
||||
self.send_error_json(400, "invalid_request", "Invalid chat members")
|
||||
return
|
||||
member_ids = [str(uuid.UUID(value)) for value in member_ids]
|
||||
if len(member_ids) != len(set(member_ids)):
|
||||
self.send_error_json(400, "invalid_request", "Invalid chat members")
|
||||
return
|
||||
if user["id"] not in member_ids:
|
||||
self.send_error_json(400, "invalid_request", "Chat must include the current user")
|
||||
return
|
||||
chat_id = new_id()
|
||||
try:
|
||||
with pool.connection() as conn:
|
||||
existing = conn.execute(
|
||||
"SELECT id FROM users WHERE id = ANY(%s)",
|
||||
([uuid.UUID(value) for value in member_ids],),
|
||||
).fetchall()
|
||||
if len(existing) != len(member_ids):
|
||||
self.send_error_json(400, "invalid_request", "Unknown chat member")
|
||||
return
|
||||
row = conn.execute(
|
||||
"INSERT INTO chats(id, title) VALUES (%s, %s) RETURNING id, title, created_at",
|
||||
(uuid.UUID(chat_id), title),
|
||||
).fetchone()
|
||||
conn.cursor().executemany(
|
||||
"INSERT INTO chat_members(chat_id, user_id, position) VALUES (%s, %s, %s)",
|
||||
[(uuid.UUID(chat_id), uuid.UUID(member_id), position) for position, member_id in enumerate(member_ids)],
|
||||
)
|
||||
self.send_json(201, public_chat(row, member_ids))
|
||||
except psycopg.errors.ForeignKeyViolation:
|
||||
self.send_error_json(400, "invalid_request", "Unknown chat member")
|
||||
|
||||
def list_chats(self, query):
|
||||
user = self.identify()
|
||||
if user is None:
|
||||
return
|
||||
try:
|
||||
limit, cursor = parse_limit_cursor(query)
|
||||
except ValueError:
|
||||
self.send_error_json(400, "invalid_request", "Invalid pagination parameters")
|
||||
return
|
||||
marker = None
|
||||
if cursor is not None:
|
||||
try:
|
||||
marker = decode_cursor(cursor)
|
||||
except ValueError:
|
||||
self.send_error_json(400, "invalid_request", "Invalid cursor")
|
||||
return
|
||||
if marker[0] != "chats:" + user["id"]:
|
||||
self.send_error_json(400, "invalid_request", "Cursor does not belong to this request")
|
||||
return
|
||||
sql = """
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
array_agg(cm_all.user_id ORDER BY cm_all.position) AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm_all ON cm_all.chat_id = c.id
|
||||
WHERE EXISTS (
|
||||
SELECT 1 FROM chat_members mine
|
||||
WHERE mine.chat_id = c.id AND mine.user_id = %s
|
||||
)
|
||||
"""
|
||||
params = [user["id"]]
|
||||
if marker is not None:
|
||||
sql += " AND (c.created_at, c.id) > (%s, %s)"
|
||||
params.extend([marker[1], uuid.UUID(marker[2])])
|
||||
sql += " GROUP BY c.id ORDER BY c.created_at, c.id LIMIT %s"
|
||||
params.append(limit + 1)
|
||||
with pool.connection() as conn:
|
||||
rows = conn.execute(sql, params).fetchall()
|
||||
has_more = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
items = [public_chat(row, row["member_ids"]) for row in rows]
|
||||
next_cursor = encode_cursor("chats:" + user["id"], rows[-1]["created_at"], rows[-1]["id"]) if has_more else None
|
||||
self.send_json(200, {"items": items, "next_cursor": next_cursor})
|
||||
|
||||
def get_chat(self, chat_id):
|
||||
user = self.identify()
|
||||
if user is None:
|
||||
return
|
||||
with pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at,
|
||||
array_agg(cm_all.user_id ORDER BY cm_all.position) AS member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm_all ON cm_all.chat_id = c.id
|
||||
WHERE c.id = %s AND EXISTS (
|
||||
SELECT 1 FROM chat_members mine
|
||||
WHERE mine.chat_id = c.id AND mine.user_id = %s
|
||||
)
|
||||
GROUP BY c.id
|
||||
""",
|
||||
(uuid.UUID(chat_id), user["id"]),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
self.send_error_json(404, "not_found", "Object not found")
|
||||
return
|
||||
self.send_json(200, public_chat(row, row["member_ids"]))
|
||||
|
||||
def create_message(self, chat_id):
|
||||
if not self.check_ready_for_write():
|
||||
return
|
||||
user = self.identify()
|
||||
if user is None:
|
||||
return
|
||||
body = self.require_json()
|
||||
if body is None:
|
||||
return
|
||||
if not validate_keys(body, {"text"}):
|
||||
self.send_error_json(400, "invalid_request", "Invalid message fields")
|
||||
return
|
||||
message_text = body["text"]
|
||||
if not isinstance(message_text, str) or len(message_text) > 4000 or not message_text.strip():
|
||||
self.send_error_json(400, "invalid_request", "Invalid message text")
|
||||
return
|
||||
message_id = new_id()
|
||||
with pool.connection() as conn:
|
||||
allowed = conn.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(uuid.UUID(chat_id), user["id"]),
|
||||
).fetchone()
|
||||
if allowed is None:
|
||||
self.send_error_json(404, "not_found", "Object not found")
|
||||
return
|
||||
row = conn.execute(
|
||||
"""
|
||||
INSERT INTO messages(id, chat_id, sender_id, text)
|
||||
VALUES (%s, %s, %s, %s)
|
||||
RETURNING id, chat_id, sender_id, text, created_at
|
||||
""",
|
||||
(uuid.UUID(message_id), uuid.UUID(chat_id), user["id"], message_text),
|
||||
).fetchone()
|
||||
self.send_json(201, public_message(row))
|
||||
|
||||
def list_messages(self, chat_id, query):
|
||||
user = self.identify()
|
||||
if user is None:
|
||||
return
|
||||
try:
|
||||
limit, cursor = parse_limit_cursor(query)
|
||||
except ValueError:
|
||||
self.send_error_json(400, "invalid_request", "Invalid pagination parameters")
|
||||
return
|
||||
marker = None
|
||||
if cursor is not None:
|
||||
try:
|
||||
marker = decode_cursor(cursor)
|
||||
except ValueError:
|
||||
self.send_error_json(400, "invalid_request", "Invalid cursor")
|
||||
return
|
||||
if marker[0] != "messages:" + chat_id:
|
||||
self.send_error_json(400, "invalid_request", "Cursor does not belong to this chat")
|
||||
return
|
||||
with pool.connection() as conn:
|
||||
allowed = conn.execute(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(uuid.UUID(chat_id), user["id"]),
|
||||
).fetchone()
|
||||
if allowed is None:
|
||||
self.send_error_json(404, "not_found", "Object not found")
|
||||
return
|
||||
sql = """
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = %s
|
||||
"""
|
||||
params = [uuid.UUID(chat_id)]
|
||||
if marker is not None:
|
||||
sql += " AND (created_at, id) > (%s, %s)"
|
||||
params.extend([marker[1], uuid.UUID(marker[2])])
|
||||
sql += " ORDER BY created_at, id LIMIT %s"
|
||||
params.append(limit + 1)
|
||||
rows = conn.execute(sql, params).fetchall()
|
||||
has_more = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
items = [public_message(row) for row in rows]
|
||||
next_cursor = encode_cursor("messages:" + chat_id, rows[-1]["created_at"], rows[-1]["id"]) if has_more else None
|
||||
self.send_json(200, {"items": items, "next_cursor": next_cursor})
|
||||
|
||||
|
||||
def handle_signal(signum, frame):
|
||||
global shutting_down
|
||||
shutting_down = True
|
||||
logger.info("shutdown requested signal=%s", signum)
|
||||
if server is not None:
|
||||
threading.Thread(target=server.shutdown, daemon=True).start()
|
||||
|
||||
|
||||
def main():
|
||||
global server
|
||||
init_services()
|
||||
server = MessengerServer((HOST, PORT), Handler)
|
||||
signal.signal(signal.SIGTERM, handle_signal)
|
||||
signal.signal(signal.SIGINT, handle_signal)
|
||||
logger.info("server started host=%s port=%s", HOST, PORT)
|
||||
try:
|
||||
server.serve_forever(poll_interval=0.2)
|
||||
finally:
|
||||
server.server_close()
|
||||
if pool is not None:
|
||||
pool.close()
|
||||
if redis_client is not None:
|
||||
redis_client.close()
|
||||
logger.info("server stopped")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in New Issue
Block a user