585 lines
20 KiB
Python
585 lines
20 KiB
Python
import datetime as dt
|
|
import hashlib
|
|
import uuid
|
|
|
|
from argon2 import PasswordHasher
|
|
from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError
|
|
from argon2.low_level import Type
|
|
from psycopg.errors import UniqueViolation
|
|
|
|
from app import broker, storage, telemetry
|
|
from app.codec import (
|
|
USERNAME,
|
|
IDEMPOTENCY,
|
|
canonical_message,
|
|
decode_cursor,
|
|
detect_image,
|
|
encode_cursor,
|
|
expect_fields,
|
|
iso,
|
|
parse_uuid,
|
|
require_text,
|
|
utcnow,
|
|
)
|
|
from app.db import connection, jsonb
|
|
from app.errors import bad_request, conflict, not_found, too_large, unauthorized, unsupported
|
|
from app.images import validate_image
|
|
from app.settings import settings
|
|
|
|
BASIC = 'Basic realm="messenger", charset="UTF-8"'
|
|
BEARER = 'Bearer realm="messenger"'
|
|
_hasher = PasswordHasher(time_cost=1, memory_cost=8192, parallelism=1, hash_len=32, salt_len=16, type=Type.ID)
|
|
_dummy = None
|
|
|
|
|
|
def init_hasher():
|
|
global _dummy
|
|
_dummy = _hasher.hash("not-a-real-password")
|
|
|
|
|
|
def _user_json(row):
|
|
return {
|
|
"id": str(row["id"]),
|
|
"username": row["username"],
|
|
"display_name": row["display_name"],
|
|
"created_at": iso(row["created_at"]),
|
|
}
|
|
|
|
|
|
def _token_hash(token):
|
|
return hashlib.sha256(token.encode("utf-8")).digest()
|
|
|
|
|
|
def _password(value):
|
|
if not isinstance(value, str) or "\x00" in value or not (12 <= len(value) <= 128):
|
|
raise bad_request()
|
|
return value
|
|
|
|
|
|
def as_uuid(value):
|
|
if isinstance(value, uuid.UUID):
|
|
return value
|
|
return uuid.UUID(str(value))
|
|
|
|
|
|
def _username(value):
|
|
if not isinstance(value, str) or USERNAME.fullmatch(value) is None:
|
|
raise bad_request()
|
|
return value
|
|
|
|
|
|
def register(data):
|
|
expect_fields(data, ["username", "display_name", "password"], ["username", "display_name", "password"])
|
|
username = _username(data["username"])
|
|
display_name = require_text(data["display_name"], 1, 100)
|
|
password = _password(data["password"])
|
|
password_hash = _hasher.hash(password)
|
|
user_id = uuid.uuid4()
|
|
created_at = utcnow()
|
|
try:
|
|
with connection() as conn:
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO users (id, username, display_name, password_hash, created_at)
|
|
VALUES (%s, %s, %s, %s, %s)
|
|
""",
|
|
(user_id, username, display_name, password_hash, created_at),
|
|
)
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, created_at FROM users WHERE id = %s",
|
|
(user_id,),
|
|
).fetchone()
|
|
except UniqueViolation as exc:
|
|
raise conflict("Имя пользователя занято") from exc
|
|
return 201, _user_json(row)
|
|
|
|
|
|
def login(username, password):
|
|
if not isinstance(username, str) or not isinstance(password, str) or "\x00" in username or "\x00" in password:
|
|
raise unauthorized(BASIC)
|
|
with connection() as conn:
|
|
row = conn.execute(
|
|
"SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = %s",
|
|
(username,),
|
|
).fetchone()
|
|
stored = row["password_hash"] if row else _dummy
|
|
try:
|
|
_hasher.verify(stored, password)
|
|
valid = row is not None
|
|
except (VerifyMismatchError, VerificationError, InvalidHashError):
|
|
valid = False
|
|
if not valid:
|
|
raise unauthorized(BASIC)
|
|
token = secrets_token()
|
|
expires_at = utcnow() + dt.timedelta(seconds=settings.session_ttl)
|
|
with connection() as conn:
|
|
conn.execute(
|
|
"INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, %s)",
|
|
(_token_hash(token), row["id"], expires_at),
|
|
)
|
|
return 201, {
|
|
"token": token,
|
|
"token_type": "Bearer",
|
|
"expires_at": iso(expires_at),
|
|
"user": _user_json(row),
|
|
}
|
|
|
|
|
|
def secrets_token():
|
|
import secrets
|
|
|
|
return secrets.token_urlsafe(32)
|
|
|
|
|
|
def current_user(token):
|
|
if not token or len(token) < 32:
|
|
raise unauthorized(BEARER)
|
|
with connection() as conn:
|
|
row = conn.execute(
|
|
"""
|
|
SELECT u.id, u.username, u.display_name, u.created_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(token),),
|
|
).fetchone()
|
|
if not row:
|
|
raise unauthorized(BEARER)
|
|
return row
|
|
|
|
|
|
def ready_check():
|
|
with connection() as conn:
|
|
conn.execute("SELECT 1")
|
|
if not storage.ready() or not broker.ready():
|
|
raise unavailable()
|
|
|
|
|
|
def revoke(token):
|
|
user = current_user(token)
|
|
with connection() as conn:
|
|
conn.execute(
|
|
"UPDATE sessions SET revoked_at = NOW() WHERE token_hash = %s AND revoked_at IS NULL",
|
|
(_token_hash(token),),
|
|
)
|
|
return user
|
|
|
|
|
|
def create_chat(user, data):
|
|
expect_fields(data, ["title", "member_ids"], ["title", "member_ids"])
|
|
title = require_text(data["title"], 1, 100)
|
|
raw_members = data["member_ids"]
|
|
if not isinstance(raw_members, list) or not (1 <= len(raw_members) <= 100):
|
|
raise bad_request()
|
|
members = [parse_uuid(item) for item in raw_members]
|
|
if len(set(members)) != len(members):
|
|
raise bad_request()
|
|
if str(user["id"]) not in members:
|
|
raise bad_request()
|
|
chat_id = uuid.uuid4()
|
|
created_at = utcnow()
|
|
with connection() as conn:
|
|
found = conn.execute("SELECT id FROM users WHERE id = ANY(%s)", ([as_uuid(item) for item in members],)).fetchall()
|
|
if len(found) != len(members):
|
|
raise bad_request()
|
|
conn.execute(
|
|
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)",
|
|
(chat_id, title, created_at),
|
|
)
|
|
for position, member_id in enumerate(members):
|
|
conn.execute(
|
|
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
|
(chat_id, as_uuid(member_id), position),
|
|
)
|
|
return 201, {
|
|
"id": str(chat_id),
|
|
"title": title,
|
|
"member_ids": members,
|
|
"created_at": iso(created_at),
|
|
}
|
|
|
|
|
|
def _chat_json(conn, row):
|
|
members = conn.execute(
|
|
"SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY position",
|
|
(row["id"],),
|
|
).fetchall()
|
|
return {
|
|
"id": str(row["id"]),
|
|
"title": row["title"],
|
|
"member_ids": [str(item["user_id"]) for item in members],
|
|
"created_at": iso(row["created_at"]),
|
|
}
|
|
|
|
|
|
def list_chats(user, limit, cursor):
|
|
created_at = None
|
|
row_id = None
|
|
if cursor is not None:
|
|
created_at, row_id = decode_cursor(cursor, "chats", str(user["id"]))
|
|
with connection() as conn:
|
|
if created_at is None:
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at
|
|
FROM chats c
|
|
JOIN chat_members m ON m.chat_id = c.id
|
|
WHERE m.user_id = %s
|
|
ORDER BY c.created_at, c.id
|
|
LIMIT %s
|
|
""",
|
|
(user["id"], limit + 1),
|
|
).fetchall()
|
|
else:
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at
|
|
FROM chats c
|
|
JOIN chat_members m ON m.chat_id = c.id
|
|
WHERE m.user_id = %s AND (c.created_at, c.id) > (%s, %s)
|
|
ORDER BY c.created_at, c.id
|
|
LIMIT %s
|
|
""",
|
|
(user["id"], created_at, as_uuid(row_id), limit + 1),
|
|
).fetchall()
|
|
extra = len(rows) > limit
|
|
rows = rows[:limit]
|
|
items = [_chat_json(conn, row) for row in rows]
|
|
next_cursor = None
|
|
if extra and rows:
|
|
last = rows[-1]
|
|
next_cursor = encode_cursor("chats", str(user["id"]), last["created_at"], str(last["id"]))
|
|
return {"items": items, "next_cursor": next_cursor}
|
|
|
|
|
|
def get_chat(user, chat_id):
|
|
with connection() as conn:
|
|
row = _visible_chat(conn, user["id"], chat_id)
|
|
return _chat_json(conn, row)
|
|
|
|
|
|
def _visible_chat(conn, user_id, chat_id):
|
|
row = conn.execute(
|
|
"""
|
|
SELECT c.id, c.title, c.created_at
|
|
FROM chats c
|
|
JOIN chat_members m ON m.chat_id = c.id
|
|
WHERE c.id = %s AND m.user_id = %s
|
|
""",
|
|
(as_uuid(chat_id), as_uuid(user_id)),
|
|
).fetchone()
|
|
if not row:
|
|
raise not_found()
|
|
return row
|
|
|
|
|
|
def _message_json(row, attachment_ids):
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"sender_id": str(row["sender_id"]),
|
|
"text": row["text"],
|
|
"created_at": iso(row["created_at"]),
|
|
"attachment_ids": attachment_ids,
|
|
}
|
|
|
|
|
|
def _attachment_ids(conn, message_id):
|
|
rows = conn.execute(
|
|
"SELECT attachment_id FROM message_attachments WHERE message_id = %s ORDER BY position",
|
|
(message_id,),
|
|
).fetchall()
|
|
return [str(row["attachment_id"]) for row in rows]
|
|
|
|
|
|
def create_message(user, chat_id, key, data, path):
|
|
chat_uuid = as_uuid(chat_id)
|
|
if IDEMPOTENCY.fullmatch(key or "") is None:
|
|
raise bad_request()
|
|
expect_fields(data, ["text", "attachment_ids"], ["text"])
|
|
if not isinstance(data["text"], str) or "\x00" in data["text"] or len(data["text"]) > 4000:
|
|
raise bad_request()
|
|
text = data["text"]
|
|
if "attachment_ids" in data:
|
|
raw_ids = data["attachment_ids"]
|
|
if not isinstance(raw_ids, list) or len(raw_ids) > 10:
|
|
raise bad_request()
|
|
attachment_ids = [parse_uuid(item) for item in raw_ids]
|
|
if len(set(attachment_ids)) != len(attachment_ids):
|
|
raise bad_request()
|
|
else:
|
|
attachment_ids = []
|
|
if not text.strip() and not attachment_ids:
|
|
raise bad_request()
|
|
body_hash = canonical_message(text, attachment_ids)
|
|
lock = int.from_bytes(hashlib.sha256(f"{user['id']}|POST|{path}|{key}".encode("utf-8")).digest()[:8], "big", signed=True)
|
|
with connection() as conn:
|
|
_visible_chat(conn, user["id"], chat_id)
|
|
conn.execute("SELECT pg_advisory_xact_lock(%s)", (lock,))
|
|
existing = conn.execute(
|
|
"""
|
|
SELECT body_hash, response_json, created_at
|
|
FROM idempotency
|
|
WHERE user_id = %s AND method = 'POST' AND path = %s AND idem_key = %s
|
|
""",
|
|
(user["id"], path, key),
|
|
).fetchone()
|
|
if existing and existing["created_at"] >= utcnow() - dt.timedelta(seconds=settings.idempotency_ttl):
|
|
if bytes(existing["body_hash"]) != body_hash:
|
|
raise conflict("Ключ идемпотентности уже использован с другим телом")
|
|
stored = existing["response_json"]
|
|
if isinstance(stored, str):
|
|
import json
|
|
|
|
stored = json.loads(stored)
|
|
return 201, stored
|
|
if existing:
|
|
conn.execute(
|
|
"DELETE FROM idempotency WHERE user_id = %s AND method = 'POST' AND path = %s AND idem_key = %s",
|
|
(user["id"], path, key),
|
|
)
|
|
if attachment_ids:
|
|
rows = conn.execute(
|
|
"SELECT id, chat_id, status FROM attachments WHERE id = ANY(%s)",
|
|
([as_uuid(item) for item in attachment_ids],),
|
|
).fetchall()
|
|
found = {str(row["id"]): row for row in rows}
|
|
if len(found) != len(attachment_ids):
|
|
raise not_found()
|
|
for attachment_id in attachment_ids:
|
|
row = found[attachment_id]
|
|
if str(row["chat_id"]) != chat_id:
|
|
raise not_found()
|
|
if row["status"] == "failed":
|
|
raise conflict("Нельзя прикрепить неуспешное вложение")
|
|
message_id = uuid.uuid4()
|
|
created_at = utcnow()
|
|
conn.execute(
|
|
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES (%s, %s, %s, %s, %s)",
|
|
(message_id, chat_uuid, user["id"], text, created_at),
|
|
)
|
|
for position, attachment_id in enumerate(attachment_ids):
|
|
conn.execute(
|
|
"INSERT INTO message_attachments (message_id, attachment_id, position) VALUES (%s, %s, %s)",
|
|
(message_id, as_uuid(attachment_id), position),
|
|
)
|
|
stored = conn.execute(
|
|
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE id = %s",
|
|
(message_id,),
|
|
).fetchone()
|
|
payload = _message_json(stored, attachment_ids)
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO idempotency (user_id, method, path, idem_key, body_hash, status_code, response_json, created_at)
|
|
VALUES (%s, 'POST', %s, %s, %s, 201, %s, %s)
|
|
""",
|
|
(user["id"], path, key, body_hash, jsonb(payload), created_at),
|
|
)
|
|
return 201, payload
|
|
|
|
|
|
def list_messages(user, chat_id, limit, cursor):
|
|
chat_uuid = as_uuid(chat_id)
|
|
created_at = None
|
|
row_id = None
|
|
if cursor is not None:
|
|
created_at, row_id = decode_cursor(cursor, "messages", chat_id)
|
|
with connection() as conn:
|
|
_visible_chat(conn, user["id"], chat_uuid)
|
|
if created_at is None:
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE chat_id = %s
|
|
ORDER BY created_at, id
|
|
LIMIT %s
|
|
""",
|
|
(chat_uuid, limit + 1),
|
|
).fetchall()
|
|
else:
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT id, chat_id, sender_id, text, created_at
|
|
FROM messages
|
|
WHERE chat_id = %s AND (created_at, id) > (%s, %s)
|
|
ORDER BY created_at, id
|
|
LIMIT %s
|
|
""",
|
|
(chat_uuid, created_at, as_uuid(row_id), limit + 1),
|
|
).fetchall()
|
|
extra = len(rows) > limit
|
|
rows = rows[:limit]
|
|
items = [_message_json(row, _attachment_ids(conn, row["id"])) for row in rows]
|
|
next_cursor = None
|
|
if extra and rows:
|
|
last = rows[-1]
|
|
next_cursor = encode_cursor("messages", chat_id, last["created_at"], str(last["id"]))
|
|
return {"items": items, "next_cursor": next_cursor}
|
|
|
|
|
|
def _variants(conn, attachment_id):
|
|
rows = conn.execute(
|
|
"""
|
|
SELECT name, content_type, size_bytes, width, height, sha256
|
|
FROM attachment_variants
|
|
WHERE attachment_id = %s AND pipeline_version = 1
|
|
ORDER BY name
|
|
""",
|
|
(attachment_id,),
|
|
).fetchall()
|
|
return [
|
|
{
|
|
"name": row["name"],
|
|
"content_type": row["content_type"],
|
|
"size_bytes": row["size_bytes"],
|
|
"width": row["width"],
|
|
"height": row["height"],
|
|
"sha256": row["sha256"],
|
|
}
|
|
for row in rows
|
|
]
|
|
|
|
|
|
def _attachment_json(row, variants):
|
|
return {
|
|
"id": str(row["id"]),
|
|
"chat_id": str(row["chat_id"]),
|
|
"owner_id": str(row["owner_id"]),
|
|
"filename": row["filename"],
|
|
"content_type": row["content_type"],
|
|
"size_bytes": row["size_bytes"],
|
|
"sha256": row["sha256"],
|
|
"status": row["status"],
|
|
"variants": variants,
|
|
"error_code": row["error_code"],
|
|
"created_at": iso(row["created_at"]),
|
|
"updated_at": iso(row["updated_at"]),
|
|
}
|
|
|
|
|
|
def upload(user, chat_id, filename, content_type, data):
|
|
import hashlib as hl
|
|
|
|
if not data:
|
|
raise unsupported()
|
|
if len(data) > settings.max_upload:
|
|
raise too_large()
|
|
detected = detect_image(data, content_type)
|
|
if not detected:
|
|
raise unsupported()
|
|
validate_image(data)
|
|
with connection() as conn:
|
|
_visible_chat(conn, user["id"], chat_id)
|
|
attachment_id = uuid.uuid4()
|
|
created_at = utcnow()
|
|
digest = hl.sha256(data).hexdigest()
|
|
staging_key = f"staging/{attachment_id}"
|
|
storage.put(staging_key, data, detected, "staging")
|
|
carrier = telemetry.inject_carrier()
|
|
job_id = uuid.uuid4()
|
|
payload = {
|
|
"schema_version": 1,
|
|
"job_id": str(job_id),
|
|
"type": "attachment.process.v1",
|
|
"attachment_id": str(attachment_id),
|
|
"pipeline_version": 1,
|
|
"attempt": 1,
|
|
"created_at": iso(created_at),
|
|
}
|
|
if carrier.get("traceparent"):
|
|
payload["traceparent"] = carrier["traceparent"]
|
|
if carrier.get("tracestate"):
|
|
payload["tracestate"] = carrier["tracestate"]
|
|
row = {
|
|
"id": attachment_id,
|
|
"chat_id": chat_id,
|
|
"owner_id": user["id"],
|
|
"filename": filename,
|
|
"content_type": detected,
|
|
"size_bytes": len(data),
|
|
"sha256": digest,
|
|
"status": "queued",
|
|
"error_code": None,
|
|
"created_at": created_at,
|
|
"updated_at": created_at,
|
|
}
|
|
with connection() as conn:
|
|
_visible_chat(conn, user["id"], chat_id)
|
|
conn.execute(
|
|
"""
|
|
INSERT INTO attachments (
|
|
id, chat_id, owner_id, filename, content_type, size_bytes, sha256, status,
|
|
error_code, staging_key, pipeline_version, attempt, created_at, updated_at
|
|
) VALUES (%s, %s, %s, %s, %s, %s, %s, 'queued', NULL, %s, 1, 0, %s, %s)
|
|
""",
|
|
(
|
|
attachment_id,
|
|
as_uuid(chat_id),
|
|
user["id"],
|
|
filename,
|
|
detected,
|
|
len(data),
|
|
digest,
|
|
staging_key,
|
|
created_at,
|
|
created_at,
|
|
),
|
|
)
|
|
broker.insert_outbox(conn, payload, created_at)
|
|
try:
|
|
with connection() as conn:
|
|
broker.publish_pending(conn, job_id)
|
|
except Exception:
|
|
telemetry.log_event("job.publish_deferred", severity="WARNING", job_id=str(job_id))
|
|
telemetry.log_event("attachment.accepted", attachment_id=str(attachment_id), size_bytes=len(data), content_type=detected)
|
|
return 202, _attachment_json(row, [])
|
|
|
|
|
|
def get_attachment(user, attachment_id):
|
|
attachment_uuid = as_uuid(attachment_id)
|
|
with connection() as conn:
|
|
row = _visible_attachment(conn, user["id"], attachment_uuid)
|
|
return _attachment_json(row, _variants(conn, attachment_uuid))
|
|
|
|
|
|
def _visible_attachment(conn, user_id, attachment_id):
|
|
row = conn.execute("SELECT * FROM attachments WHERE id = %s", (as_uuid(attachment_id),)).fetchone()
|
|
if not row:
|
|
raise not_found()
|
|
member = conn.execute(
|
|
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
|
(row["chat_id"], user_id),
|
|
).fetchone()
|
|
if not member:
|
|
raise not_found()
|
|
return row
|
|
|
|
|
|
def download(user, attachment_id, variant):
|
|
attachment_uuid = as_uuid(attachment_id)
|
|
if variant not in {"original", "thumbnail", "crop", "optimized"}:
|
|
raise bad_request()
|
|
with connection() as conn:
|
|
row = _visible_attachment(conn, user["id"], attachment_uuid)
|
|
if row["status"] != "ready":
|
|
raise conflict("Вложение ещё не готово")
|
|
if variant == "original":
|
|
key = row["original_key"]
|
|
content_type = row["content_type"]
|
|
else:
|
|
found = conn.execute(
|
|
"""
|
|
SELECT object_key, content_type
|
|
FROM attachment_variants
|
|
WHERE attachment_id = %s AND name = %s AND pipeline_version = 1
|
|
""",
|
|
(attachment_uuid, variant),
|
|
).fetchone()
|
|
if not found:
|
|
raise not_found()
|
|
key = found["object_key"]
|
|
content_type = found["content_type"]
|
|
return storage.get(key, variant), content_type
|