Files
mtusi2026lab4/main.py
T
2026-11-12 14:37:43 +03:00

356 lines
18 KiB
Python

import base64
import hashlib
import hmac
import json
import os
import re
import secrets
import uuid
from datetime import datetime, timezone, timedelta
from contextlib import contextmanager
import psycopg
from psycopg.rows import dict_row
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, Response
from PIL import Image, UnidentifiedImageError
import io
import boto3
from botocore.exceptions import BotoCoreError, ClientError
from pydantic import BaseModel, ConfigDict, Field, field_validator
DATABASE_URL = os.environ.get('DATABASE_URL', 'postgresql://messenger:messenger@localhost:5432/messenger')
INSTANCE_ID = os.environ.get('INSTANCE_ID', 'api-local')
app = FastAPI(title='Messenger S3', version='1.4.0')
S3_BUCKET=os.environ.get('S3_BUCKET','messenger-attachments')
def s3():
return boto3.client('s3',endpoint_url=os.environ.get('S3_ENDPOINT','http://s3:9000'),region_name='us-east-1',aws_access_key_id=os.environ.get('S3_ACCESS_KEY_ID'),aws_secret_access_key=os.environ.get('S3_SECRET_ACCESS_KEY'))
def utc(value):
return value.astimezone(timezone.utc).isoformat(timespec='milliseconds').replace('+00:00','Z')
def db():
return psycopg.connect(DATABASE_URL, row_factory=dict_row)
@contextmanager
def transaction():
with db() as conn:
with conn.transaction():
yield conn
def public_user(row):
return {k:(utc(row[k]) if k=='created_at' else str(row[k]) if k=='id' else row[k]) for k in ('id','username','display_name','created_at')}
def public_chat(conn, row):
members=conn.execute('SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id',(row['id'],)).fetchall()
return {'id':str(row['id']),'title':row['title'],'member_ids':[str(x['user_id']) for x in members],'created_at':utc(row['created_at'])}
def public_message(row):
result={k:(utc(row[k]) if k=='created_at' else str(row[k]) if k in ('id','chat_id','sender_id') else row[k]) for k in ('id','chat_id','sender_id','text','created_at')}
result['attachment_ids']=[str(v) for v in row.get('attachment_ids',[])]
return result
def public_attachment(row):
result={k:(utc(row[k]) if k in ('created_at','updated_at') else str(row[k]) if k in ('id','chat_id','owner_id') else row[k]) for k in ('id','chat_id','owner_id','filename','content_type','size_bytes','sha256','status','created_at','updated_at')}
result.update(variants=[],error_code=None)
return result
def err(request,status,code='invalid_request',message='Некорректный запрос',challenge=None):
headers={'WWW-Authenticate':challenge} if challenge else {}
return JSONResponse(status_code=status,headers=headers,content={'error':{'code':code,'message':message,'request_id':request.state.request_id}})
@app.middleware('http')
async def middleware(request:Request, call_next):
request.state.request_id=str(uuid.uuid4())
try:
response=await call_next(request)
except Exception:
response=err(request,500,'internal_error','Внутренняя ошибка сервера')
response.headers['X-Request-Id']=request.state.request_id
response.headers['X-Instance-Id']=INSTANCE_ID
return response
@app.exception_handler(RequestValidationError)
async def validation(request,exc):
return err(request,400)
class Strict(BaseModel):
model_config=ConfigDict(extra='forbid')
class CreateUser(Strict):
username:str=Field(min_length=3,max_length=32,pattern=r'^[a-z0-9_]{3,32}$')
display_name:str=Field(min_length=1,max_length=100)
password:str=Field(min_length=8,max_length=128)
@field_validator('display_name')
@classmethod
def nonblank(cls,v):
if not v.strip(): raise ValueError('blank')
return v
class CreateChat(Strict):
title:str=Field(min_length=1,max_length=100)
member_ids:list[uuid.UUID]=Field(min_length=1,max_length=100)
@field_validator('title')
@classmethod
def nonblank(cls,v):
if not v.strip(): raise ValueError('blank')
return v
class CreateMessage(Strict):
text:str=Field(max_length=4000)
attachment_ids:list[uuid.UUID]=Field(default_factory=list,max_length=10)
@field_validator('text')
@classmethod
def nonblank(cls,v):
return v
def password_hash(password):
salt=secrets.token_bytes(16)
result=hashlib.scrypt(password.encode(),salt=salt,n=16384,r=8,p=1)
return 'scrypt$'+salt.hex()+'$'+result.hex()
def verify(password,encoded):
try:
_,salt,digest=encoded.split('$')
candidate=hashlib.scrypt(password.encode(),salt=bytes.fromhex(salt),n=16384,r=8,p=1)
return hmac.compare_digest(candidate,bytes.fromhex(digest))
except (ValueError,TypeError): return False
def actor(request,conn):
header=request.headers.get('authorization','')
if not header.startswith('Bearer '): return None
token=header[7:]
if not token: return None
digest=hashlib.sha256(token.encode()).hexdigest()
return conn.execute('SELECT u.* FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.expires_at>now() AND s.revoked_at IS NULL',(digest,)).fetchone()
def require(request,conn):
user=actor(request,conn)
return user, None if user else err(request,401,'unauthorized','Требуется Bearer-сессия','Bearer')
def parse_uuid(value):
try: return uuid.UUID(value)
except (ValueError,TypeError): return None
def encode_cursor(resource,row):
payload=json.dumps({'resource':resource,'created_at':row['created_at'].astimezone(timezone.utc).isoformat(timespec='microseconds'),'id':str(row['id'])},separators=(',',':'))
return base64.urlsafe_b64encode(payload.encode()).decode().rstrip('=')
def decode_cursor(cursor,resource):
if cursor is None: return None
try:
d=json.loads(base64.urlsafe_b64decode(cursor+'='*(-len(cursor)%4)))
if set(d)!={'resource','created_at','id'} or d['resource']!=resource: return False
return (datetime.fromisoformat(d['created_at'].replace('Z','+00:00')),uuid.UUID(d['id']))
except Exception: return False
@app.get('/health/live')
def live(): return {'status':'ok'}
@app.get('/health/ready')
def ready():
with db() as conn: conn.execute('SELECT 1')
return {'status':'ok'}
@app.post('/api/v1/users',status_code=201)
def register(body:CreateUser,request:Request):
with transaction() as conn:
if conn.execute('SELECT 1 FROM users WHERE username=%s',(body.username,)).fetchone():
return err(request,409,'conflict','Имя пользователя занято')
row=conn.execute('INSERT INTO users(username,display_name,password_hash) VALUES (%s,%s,%s) RETURNING *',(body.username,body.display_name,password_hash(body.password))).fetchone()
return public_user(row)
@app.post('/api/v1/auth/sessions',status_code=201)
def login(request:Request):
auth=request.headers.get('authorization','')
try:
if not auth.startswith('Basic '): raise ValueError()
credentials=base64.b64decode(auth[6:],validate=True).decode('utf-8')
username,password=credentials.split(':',1)
except (ValueError,UnicodeError): return err(request,401,'unauthorized','Неверные учётные данные','Basic')
with transaction() as conn:
user=conn.execute('SELECT * FROM users WHERE username=%s',(username,)).fetchone()
if not user or not verify(password,user['password_hash']): return err(request,401,'unauthorized','Неверные учётные данные','Basic')
token=secrets.token_urlsafe(48)
expires=datetime.now(timezone.utc)+timedelta(hours=24)
conn.execute('INSERT INTO sessions(user_id,token_hash,expires_at) VALUES (%s,%s,%s)',(user['id'],hashlib.sha256(token.encode()).hexdigest(),expires))
return {'token':token,'token_type':'Bearer','expires_at':utc(expires),'user':public_user(user)}
@app.delete('/api/v1/auth/sessions/current',status_code=204)
def logout(request:Request):
with transaction() as conn:
user,e=require(request,conn)
if e:return e
digest=hashlib.sha256(request.headers['authorization'][7:].encode()).hexdigest()
conn.execute('UPDATE sessions SET revoked_at=now() WHERE token_hash=%s',(digest,))
return Response(status_code=204)
@app.get('/api/v1/users/me')
def me(request:Request):
with db() as conn:
user,e=require(request,conn)
return e or public_user(user)
@app.post('/api/v1/chats',status_code=201)
def create_chat(body:CreateChat,request:Request):
with transaction() as conn:
user,e=require(request,conn)
if e:return e
members=body.member_ids
if len(set(members))!=len(members) or user['id'] not in members:
return err(request,400)
found=conn.execute('SELECT count(*) AS n FROM users WHERE id=ANY(%s)',(members,)).fetchone()['n']
if found!=len(members):return err(request,400)
row=conn.execute('INSERT INTO chats(title) VALUES (%s) RETURNING *',(body.title,)).fetchone()
for member in members: conn.execute('INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)',(row['id'],member))
return public_chat(conn,row)
def member_chat(conn,chat_id,user_id):
return conn.execute('SELECT c.* FROM chats c JOIN chat_members cm ON cm.chat_id=c.id WHERE c.id=%s AND cm.user_id=%s',(chat_id,user_id)).fetchone()
@app.get('/api/v1/chats')
def list_chats(request:Request,limit:int=50,cursor:str|None=None):
if not 1<=limit<=100:return err(request,400)
with db() as conn:
user,e=require(request,conn)
if e:return e
marker=decode_cursor(cursor,'chats:'+str(user['id']))
if marker is False:return err(request,400)
query='SELECT c.* FROM chats c JOIN chat_members cm ON cm.chat_id=c.id WHERE cm.user_id=%s'
params=[user['id']]
if marker:
query+=' AND (c.created_at,c.id)>(%s,%s)';params.extend(marker)
rows=conn.execute(query+' ORDER BY c.created_at,c.id LIMIT %s',(*params,limit+1)).fetchall()
page=rows[:limit]
return {'items':[public_chat(conn,r) for r in page],'next_cursor':encode_cursor('chats:'+str(user['id']),page[-1]) if len(rows)>limit else None}
@app.get('/api/v1/chats/{chat_id}')
def get_chat(chat_id:str,request:Request):
with db() as conn:
user,e=require(request,conn)
if e:return e
cid=parse_uuid(chat_id)
if cid is None:return err(request,400)
row=member_chat(conn,cid,user['id'])
return public_chat(conn,row) if row else err(request,404,'not_found','Чат не найден')
@app.post('/api/v1/chats/{chat_id}/messages',status_code=201)
def send(chat_id:str,body:CreateMessage,request:Request):
key=request.headers.get('Idempotency-Key','')
if not re.fullmatch(r'[A-Za-z0-9._:-]{1,128}',key,flags=re.ASCII):
return err(request,400,'invalid_request','Требуется корректный Idempotency-Key')
if not body.text.strip() and not body.attachment_ids:return err(request,400)
if len(set(body.attachment_ids))!=len(body.attachment_ids):return err(request,400)
with transaction() as conn:
user,e=require(request,conn)
if e:return e
cid=parse_uuid(chat_id)
if cid is None:return err(request,400)
if not member_chat(conn,cid,user['id']):return err(request,404,'not_found','Чат не найден')
if body.attachment_ids:
found=conn.execute('SELECT count(*) AS n FROM attachments WHERE id=ANY(%s) AND chat_id=%s AND status=%s',(body.attachment_ids,cid,'ready')).fetchone()['n']
if found!=len(body.attachment_ids):return err(request,400)
# UNIQUE constraint serializes concurrent calls on all replicas.
# The message and idempotency record commit atomically.
fingerprint=hashlib.sha256(json.dumps({'text':body.text,'attachment_ids':[str(x) for x in body.attachment_ids]},sort_keys=True,separators=(',',':'),ensure_ascii=False).encode()).hexdigest()
conn.execute("""INSERT INTO message_idempotency(user_id,chat_id,key,fingerprint,message_id)
VALUES (%s,%s,%s,%s,NULL) ON CONFLICT DO NOTHING""",(user['id'],cid,key,fingerprint))
record=conn.execute("""SELECT fingerprint,message_id FROM message_idempotency
WHERE user_id=%s AND chat_id=%s AND key=%s FOR UPDATE""",(user['id'],cid,key)).fetchone()
if record['fingerprint']!=fingerprint:
return err(request,409,'conflict','Ключ уже использован для другого сообщения')
if record['message_id'] is not None:
row=conn.execute('SELECT * FROM messages WHERE id=%s',(record['message_id'],)).fetchone()
return public_message(row)
row=conn.execute('INSERT INTO messages(chat_id,sender_id,text,attachment_ids) VALUES (%s,%s,%s,%s) RETURNING *',(cid,user['id'],body.text,body.attachment_ids)).fetchone()
conn.execute("""UPDATE message_idempotency SET message_id=%s
WHERE user_id=%s AND chat_id=%s AND key=%s""",(row['id'],user['id'],cid,key))
return public_message(row)
@app.get('/api/v1/chats/{chat_id}/messages')
def list_messages(chat_id:str,request:Request,limit:int=50,cursor:str|None=None):
if not 1<=limit<=100:return err(request,400)
with db() as conn:
user,e=require(request,conn)
if e:return e
cid=parse_uuid(chat_id)
if cid is None:return err(request,400)
marker=decode_cursor(cursor,'messages:'+str(cid))
if marker is False:return err(request,400)
if not member_chat(conn,cid,user['id']):return err(request,404,'not_found','Чат не найден')
query='SELECT * FROM messages WHERE chat_id=%s';params=[cid]
if marker:
query+=' AND (created_at,id)>(%s,%s)';params.extend(marker)
rows=conn.execute(query+' ORDER BY created_at,id LIMIT %s',(*params,limit+1)).fetchall()
page=rows[:limit]
return {'items':[public_message(r) for r in page],'next_cursor':encode_cursor('messages:'+str(cid),page[-1]) if len(rows)>limit else None}
@app.post('/api/v1/chats/{chat_id}/attachments',status_code=201)
async def upload(chat_id:str,request:Request,filename:str=''):
if not filename or len(filename)>255 or filename in ('.','..') or '/' in filename or '\\' in filename or any(ord(c)<32 or ord(c)==127 for c in filename):
return err(request,400)
cid=parse_uuid(chat_id)
if cid is None:return err(request,400)
with db() as conn:
user,e=require(request,conn)
if e:return e
if not member_chat(conn,cid,user['id']):return err(request,404,'not_found','Чат не найден')
owner=user['id']
declared=request.headers.get('content-type','').split(';')[0].strip().lower()
if declared not in ('image/png','image/jpeg'):return err(request,400)
if request.headers.get('content-length'):
try:
if int(request.headers['content-length'])>10485760:return err(request,413,'payload_too_large','Файл слишком большой')
except ValueError:return err(request,400)
data=bytearray()
async for chunk in request.stream():
if len(data)+len(chunk)>10485760:return err(request,413,'payload_too_large','Файл слишком большой')
data.extend(chunk)
if not data:return err(request,400)
try:
Image.MAX_IMAGE_PIXELS=40000000
with Image.open(io.BytesIO(data)) as img:
actual={'PNG':'image/png','JPEG':'image/jpeg'}.get(img.format)
if actual!=declared or img.width*img.height>40000000:return err(request,400)
img.verify()
except (UnidentifiedImageError,ValueError,OSError,Image.DecompressionBombError,Image.DecompressionBombWarning):return err(request,400)
aid=uuid.uuid4()
object_key='attachments/'+str(cid)+'/'+str(aid)
try:
s3().put_object(Bucket=S3_BUCKET,Key=object_key,Body=bytes(data),ContentType=actual)
except (BotoCoreError,ClientError,Exception):return err(request,503,'storage_unavailable','S3 недоступно')
try:
with transaction() as conn:
row=conn.execute('INSERT INTO attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,status,object_key) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s) RETURNING *',(aid,cid,owner,filename,actual,len(data),hashlib.sha256(data).hexdigest(),'ready',object_key)).fetchone()
return public_attachment(row)
except Exception:
try:s3().delete_object(Bucket=S3_BUCKET,Key=object_key)
except Exception:pass
return err(request,503,'storage_unavailable','Не удалось сохранить метаданные')
def get_attachment_row(request,attachment_id):
aid=parse_uuid(attachment_id)
if aid is None:return None,err(request,400)
with db() as conn:
user,e=require(request,conn)
if e:return None,e
row=conn.execute('SELECT a.* FROM attachments a JOIN chat_members cm ON cm.chat_id=a.chat_id WHERE a.id=%s AND cm.user_id=%s',(aid,user['id'])).fetchone()
if row is None:return None,err(request,404,'not_found','Вложение не найдено')
return row,None
@app.get('/api/v1/attachments/{attachment_id}')
def attachment_metadata(attachment_id:str,request:Request):
row,e=get_attachment_row(request,attachment_id)
return e or public_attachment(row)
@app.get('/api/v1/attachments/{attachment_id}/content')
def attachment_content(attachment_id:str,request:Request,variant:str='original'):
row,e=get_attachment_row(request,attachment_id)
if e:return e
if variant!='original':return err(request,400)
try:
obj=s3().get_object(Bucket=S3_BUCKET,Key=row['object_key'])
data=obj['Body'].read(10485761)
if len(data)!=row['size_bytes'] or hashlib.sha256(data).hexdigest()!=row['sha256']:
return err(request,503,'storage_unavailable','Неверная контрольная сумма')
except Exception:return err(request,503,'storage_unavailable','S3 недоступно')
return Response(content=data,media_type=row['content_type'],headers={'Cache-Control':'private, no-store','Content-Disposition':'attachment; filename="image"'})