forked from mtusi2026/mtusi2026lab3
324 lines
14 KiB
Python
324 lines
14 KiB
Python
import base64
|
|
import hashlib
|
|
import io
|
|
import json
|
|
import os
|
|
import re
|
|
import secrets
|
|
import socket
|
|
import uuid
|
|
import warnings
|
|
from datetime import datetime, timedelta, timezone
|
|
|
|
import boto3
|
|
import psycopg
|
|
from psycopg.types.json import Jsonb
|
|
from argon2 import PasswordHasher
|
|
from fastapi import FastAPI, Request
|
|
from fastapi.responses import JSONResponse, Response
|
|
from jsonschema import Draft202012Validator, FormatChecker
|
|
from PIL import Image
|
|
from starlette.concurrency import run_in_threadpool
|
|
|
|
app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
|
|
INSTANCE = socket.gethostname()
|
|
LAB = int(os.getenv('LAB_NUMBER', '4'))
|
|
DSN = os.environ['DATABASE_URL']
|
|
BUCKET = os.getenv('S3_BUCKET', 'attachments')
|
|
ph = PasswordHasher()
|
|
schemas = json.load(open('contracts/openapi.json'))['components']['schemas']
|
|
Image.MAX_IMAGE_PIXELS = 40_000_000
|
|
warnings.simplefilter('error', Image.DecompressionBombWarning)
|
|
|
|
|
|
def s3():
|
|
return boto3.client('s3', endpoint_url=os.environ['S3_ENDPOINT'],
|
|
aws_access_key_id=os.environ['S3_ACCESS_KEY'],
|
|
aws_secret_access_key=os.environ['S3_SECRET_KEY'],
|
|
region_name='us-east-1',
|
|
config=boto3.session.Config(connect_timeout=2, read_timeout=5, retries={'max_attempts': 0}))
|
|
|
|
|
|
def now():
|
|
return datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
|
|
|
|
|
|
def uid(value):
|
|
try:
|
|
return str(uuid.UUID(value))
|
|
except (ValueError, TypeError, AttributeError):
|
|
fail(400)
|
|
|
|
|
|
def fail(status):
|
|
raise APIError(status)
|
|
|
|
|
|
class APIError(Exception):
|
|
def __init__(self, status):
|
|
self.status = status
|
|
|
|
|
|
CODES = {400: 'invalid_request', 401: 'unauthorized', 404: 'not_found',
|
|
409: 'conflict', 413: 'payload_too_large', 415: 'unsupported_media_type',
|
|
503: 'unavailable', 500: 'internal_error'}
|
|
|
|
|
|
def error(status, request_id, path):
|
|
code = CODES[status]
|
|
headers = {}
|
|
if status == 401:
|
|
headers['WWW-Authenticate'] = ('Basic realm="messenger", charset="UTF-8"'
|
|
if path.endswith('/auth/sessions') else 'Bearer realm="messenger"')
|
|
return JSONResponse({'error': {'code': code, 'message': code, 'request_id': request_id}},
|
|
status_code=status, headers=headers)
|
|
|
|
|
|
@app.middleware('http')
|
|
async def headers_and_errors(request, call_next):
|
|
request_id = secrets.token_hex(16)
|
|
try:
|
|
response = await call_next(request)
|
|
except APIError as exc:
|
|
response = error(exc.status, request_id, request.url.path)
|
|
except (psycopg.OperationalError, psycopg.InterfaceError):
|
|
response = error(503, request_id, request.url.path)
|
|
except Exception:
|
|
import logging
|
|
logging.exception('Request failed')
|
|
response = error(500, request_id, request.url.path)
|
|
response.headers['X-Request-Id'] = request_id
|
|
response.headers['X-Instance-Id'] = INSTANCE
|
|
return response
|
|
|
|
|
|
def validate(body, name):
|
|
if not Draft202012Validator(schemas[name], format_checker=FormatChecker()).is_valid(body):
|
|
fail(400)
|
|
return body
|
|
|
|
|
|
def user(db, request):
|
|
auth = request.headers.get('authorization', '')
|
|
if not auth.startswith('Bearer '):
|
|
fail(401)
|
|
token = hashlib.sha256(auth[7:].encode()).hexdigest()
|
|
row = db.execute('SELECT u.doc FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token=%s AND s.expires_at>now()', (token,)).fetchone()
|
|
if not row:
|
|
fail(401)
|
|
return row[0]
|
|
|
|
|
|
def chat(db, ident, actor):
|
|
ident = uid(ident)
|
|
row = db.execute('SELECT doc FROM chats WHERE id=%s', (ident,)).fetchone()
|
|
if not row or actor['id'] not in row[0]['member_ids']:
|
|
fail(404)
|
|
return row[0]
|
|
|
|
|
|
def attachment(db, ident, actor):
|
|
row = db.execute('SELECT doc FROM attachments WHERE id=%s', (uid(ident),)).fetchone()
|
|
if not row:
|
|
fail(404)
|
|
chat(db, row[0]['chat_id'], actor)
|
|
return row[0]
|
|
|
|
|
|
def page(db, request, table, scope, actor):
|
|
raw = request.query_params.get('limit', '50')
|
|
if not re.fullmatch('[0-9]+', raw) or not 1 <= int(raw) <= 100:
|
|
fail(400)
|
|
limit = int(raw)
|
|
cursor = request.query_params.get('cursor')
|
|
after = None
|
|
if cursor:
|
|
try:
|
|
decoded = json.loads(base64.urlsafe_b64decode(cursor.encode()))
|
|
if len(decoded) != 3 or decoded[0] != scope:
|
|
fail(400)
|
|
datetime.fromisoformat(decoded[1].replace('Z', '+00:00'))
|
|
uid(decoded[2])
|
|
after = decoded[1:]
|
|
except Exception:
|
|
fail(400)
|
|
if table == 'chats':
|
|
where, args = "doc->'member_ids' ? %s", [actor['id']]
|
|
else:
|
|
where, args = "chat_id=%s", [scope]
|
|
if after:
|
|
where += " AND (doc->>'created_at',id)>(%s,%s::uuid)"
|
|
args += after
|
|
rows = db.execute(f"SELECT doc FROM {table} WHERE {where} ORDER BY doc->>'created_at',id LIMIT %s", args + [limit+1]).fetchall()
|
|
items = [r[0] for r in rows[:limit]]
|
|
next_cursor = None
|
|
if len(rows) > limit:
|
|
last = items[-1]
|
|
next_cursor = base64.urlsafe_b64encode(json.dumps([scope,last['created_at'],last['id']]).encode()).decode()
|
|
return {'items': items, 'next_cursor': next_cursor}
|
|
|
|
|
|
@app.get('/health/live')
|
|
def live():
|
|
return {'status': 'ok'}
|
|
|
|
|
|
@app.get('/health/ready')
|
|
def ready():
|
|
with psycopg.connect(DSN, connect_timeout=2) as db:
|
|
db.execute('SELECT count(*) FROM sessions')
|
|
if LAB >= 4:
|
|
try:
|
|
s3().head_bucket(Bucket=BUCKET)
|
|
except Exception:
|
|
fail(503)
|
|
return {'status': 'ok'}
|
|
|
|
|
|
@app.api_route('/api/v1/{path:path}', methods=['GET', 'POST', 'DELETE'])
|
|
async def api(request: Request, path: str):
|
|
# Read bounded chunks before JSON parsing/image decoding.
|
|
limit = 10*1024*1024 if path.endswith('/attachments') else 65536
|
|
data = bytearray()
|
|
async for chunk in request.stream():
|
|
if len(data)+len(chunk) > limit:
|
|
fail(413)
|
|
data.extend(chunk)
|
|
return await run_in_threadpool(handle, request, path, bytes(data))
|
|
|
|
|
|
def handle(request, path, raw):
|
|
method = request.method
|
|
parts = path.split('/')
|
|
body = None
|
|
if method == 'POST' and path != 'auth/sessions' and not path.endswith('/attachments'):
|
|
try:
|
|
body = json.loads(raw)
|
|
except (ValueError, UnicodeError):
|
|
fail(400)
|
|
with psycopg.connect(DSN) as db:
|
|
if path == 'users' and method == 'POST':
|
|
validate(body, 'CreateUser')
|
|
if not body['display_name'].strip():
|
|
fail(400)
|
|
doc = {'id': str(uuid.uuid4()), 'username': body['username'], 'display_name': body['display_name'], 'created_at': now()}
|
|
hashed = ph.hash(body['password'])
|
|
if not db.execute('INSERT INTO users(id,username,password,doc) VALUES (%s,%s,%s,%s) ON CONFLICT(username) DO NOTHING RETURNING id', (doc['id'],doc['username'],hashed,Jsonb(doc))).fetchone():
|
|
fail(409)
|
|
return JSONResponse(doc, 201)
|
|
if path == 'auth/sessions' and method == 'POST':
|
|
try:
|
|
auth = request.headers.get('authorization', '')
|
|
if not auth.startswith('Basic ') or raw:
|
|
fail(401)
|
|
username, password = base64.b64decode(auth[6:], validate=True).decode().split(':',1)
|
|
row = db.execute('SELECT password,doc FROM users WHERE username=%s',(username,)).fetchone()
|
|
if not row:
|
|
fail(401)
|
|
ph.verify(row[0],password)
|
|
except Exception:
|
|
fail(401)
|
|
token = secrets.token_urlsafe(32)
|
|
expiry = datetime.now(timezone.utc)+timedelta(seconds=int(os.getenv('SESSION_TTL_SECONDS','3600')))
|
|
db.execute('INSERT INTO sessions VALUES(%s,%s,%s)', (hashlib.sha256(token.encode()).hexdigest(),row[1]['id'],expiry))
|
|
return JSONResponse({'token':token,'token_type':'Bearer','expires_at':expiry.isoformat().replace('+00:00','Z'),'user':row[1]},201)
|
|
actor = user(db, request)
|
|
if path == 'users/me' and method == 'GET':
|
|
return actor
|
|
if path == 'auth/sessions/current' and method == 'DELETE':
|
|
db.execute('DELETE FROM sessions WHERE token=%s',(hashlib.sha256(request.headers['authorization'][7:].encode()).hexdigest(),))
|
|
return Response(status_code=204)
|
|
if path == 'chats':
|
|
if method == 'GET':
|
|
return page(db,request,'chats','chats:'+actor['id'],actor)
|
|
if method == 'POST':
|
|
validate(body,'CreateChat')
|
|
if not body['title'].strip() or actor['id'] not in body['member_ids']:
|
|
fail(400)
|
|
for ident in body['member_ids']:
|
|
if not db.execute('SELECT id FROM users WHERE id=%s',(uid(ident),)).fetchone():
|
|
fail(400)
|
|
doc = dict(body,id=str(uuid.uuid4()),created_at=now())
|
|
db.execute('INSERT INTO chats VALUES(%s,%s)',(doc['id'],Jsonb(doc)))
|
|
return JSONResponse(doc,201)
|
|
if parts[0] == 'chats' and len(parts) >= 2:
|
|
current = chat(db, parts[1], actor)
|
|
if len(parts) == 2 and method == 'GET':
|
|
return current
|
|
if len(parts) == 3 and parts[2] == 'messages':
|
|
if method == 'GET':
|
|
return page(db,request,'messages',current['id'],actor)
|
|
if method == 'POST':
|
|
validate(body,'CreateMessage')
|
|
attachments = body.get('attachment_ids',[]) if LAB >= 4 else []
|
|
if not body['text'].strip() and not attachments:
|
|
fail(400)
|
|
key = request.headers.get('idempotency-key','')
|
|
if not re.fullmatch(r'[A-Za-z0-9._:-]{1,128}',key):
|
|
fail(400)
|
|
for ident in attachments:
|
|
att = attachment(db,ident,actor)
|
|
if att['chat_id'] != current['id']:
|
|
fail(404)
|
|
normalized = {'text':body['text'],'attachment_ids':attachments}
|
|
# A transaction-scoped shared lock serializes the entire lookup+insert.
|
|
scope = actor['id']+':'+current['id']+':'+key
|
|
db.execute('SELECT pg_advisory_xact_lock(hashtextextended(%s,0))',(scope,))
|
|
old = db.execute('SELECT body,doc FROM messages WHERE sender_id=%s AND chat_id=%s AND idem_key=%s AND saved_at>now()-interval \'24 hours\'',(actor['id'],current['id'],key)).fetchone()
|
|
if old:
|
|
if old[0] != normalized:
|
|
fail(409)
|
|
return JSONResponse(old[1],201)
|
|
doc = {'id':str(uuid.uuid4()),'chat_id':current['id'],'sender_id':actor['id'],'text':body['text'],'created_at':now()}
|
|
if LAB >= 4:
|
|
doc['attachment_ids'] = attachments
|
|
db.execute('INSERT INTO messages(id,chat_id,sender_id,idem_key,body,doc) VALUES(%s,%s,%s,%s,%s,%s)',(doc['id'],current['id'],actor['id'],key,Jsonb(normalized),Jsonb(doc)))
|
|
return JSONResponse(doc,201)
|
|
if LAB >= 4 and len(parts) == 3 and parts[2] == 'attachments' and method == 'POST':
|
|
filename = request.query_params.get('filename','')
|
|
if not 1 <= len(filename) <= 255 or any(c in '/\\' or ord(c)<32 or 127<=ord(c)<=159 for c in filename):
|
|
fail(400)
|
|
mime = request.headers.get('content-type','')
|
|
if mime not in ('image/png','image/jpeg'):
|
|
fail(415)
|
|
try:
|
|
with Image.open(io.BytesIO(raw)) as image:
|
|
if image.width*image.height > 40_000_000:
|
|
fail(413)
|
|
if image.format not in ('PNG','JPEG') or Image.MIME[image.format] != mime:
|
|
fail(415)
|
|
image.verify()
|
|
with Image.open(io.BytesIO(raw)) as image:
|
|
image.load()
|
|
except APIError:
|
|
raise
|
|
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
|
|
fail(413)
|
|
except Exception:
|
|
fail(415)
|
|
ident, stamp = str(uuid.uuid4()), now()
|
|
doc = {'id':ident,'chat_id':current['id'],'owner_id':actor['id'],'filename':filename,'content_type':mime,'size_bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest(),'status':'ready','variants':[],'error_code':None,'created_at':stamp,'updated_at':stamp}
|
|
try:
|
|
s3().put_object(Bucket=BUCKET,Key=ident,Body=raw,ContentType=mime)
|
|
except Exception:
|
|
fail(503)
|
|
db.execute('INSERT INTO attachments VALUES(%s,%s,%s)',(ident,current['id'],Jsonb(doc)))
|
|
return JSONResponse(doc,201)
|
|
if LAB >= 4 and parts[0] == 'attachments' and len(parts) in (2,3) and method == 'GET':
|
|
doc = attachment(db,parts[1],actor)
|
|
if len(parts) == 2:
|
|
return doc
|
|
if parts[2] == 'content':
|
|
if request.query_params.get('variant','original') != 'original':
|
|
fail(404)
|
|
try:
|
|
obj = s3().get_object(Bucket=BUCKET,Key=doc['id'])
|
|
try:
|
|
content = obj['Body'].read(10*1024*1024+1)
|
|
finally:
|
|
obj['Body'].close()
|
|
except Exception:
|
|
fail(503)
|
|
return Response(content,media_type=doc['content_type'])
|
|
fail(404)
|