forked from mtusi2026/mtusi2026lab4
356 lines
18 KiB
Python
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"'})
|