"""Lab2 API. PostgreSQL is the sole source of truth, including sessions.""" import base64 import hashlib import json import os import re import secrets import uuid import threading import time from concurrent.futures import ThreadPoolExecutor, TimeoutError as FutureTimeout from datetime import datetime, timezone from pathlib import Path from argon2 import PasswordHasher from argon2.exceptions import VerificationError, InvalidHashError from flask import Flask, g, jsonify, request from jsonschema import Draft202012Validator, FormatChecker, ValidationError from psycopg import Error as DatabaseError from psycopg.errors import UniqueViolation from psycopg.rows import dict_row from psycopg_pool import ConnectionPool, PoolTimeout from redis import Redis from redis.exceptions import RedisError from redis.retry import Retry from redis.backoff import NoBackoff from werkzeug.exceptions import HTTPException ROOT = Path(__file__).resolve().parents[1] app = Flask(__name__) app.config['MAX_CONTENT_LENGTH'] = 65536 passwords = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2) dummy_hash = passwords.hash(secrets.token_urlsafe(32)) ttl = int(os.environ.get('SESSION_TTL_SECONDS', '3600')) if ttl < 1: raise ValueError('SESSION_TTL_SECONDS must be positive') dsn = Path(os.environ['DATABASE_URL_FILE']).read_text().strip() if os.environ.get('DATABASE_URL_FILE') else os.environ['DATABASE_URL'] pool = ConnectionPool(dsn, min_size=1, max_size=8, timeout=3, kwargs={'row_factory': dict_row, 'connect_timeout': 3, 'options': '-c statement_timeout=3000 -c lock_timeout=2000'}) # Cache only immutable public profiles, never sessions or authorization decisions. cache_url = Path(os.environ['CACHE_URL_FILE']).read_text().strip() if os.environ.get('CACHE_URL_FILE') else os.environ.get('CACHE_URL', 'redis://cache:6379/0') cache = Redis.from_url(cache_url, socket_connect_timeout=0.2, socket_timeout=0.2, max_connections=8, decode_responses=True, retry=Retry(NoBackoff(), 0), retry_on_timeout=False) PROFILE_CACHE_TTL = 60 # Socket timeouts do not bound DNS resolution. Limit the complete optional-cache # operation, bound outstanding work and skip calls briefly after a failure. cache_workers = ThreadPoolExecutor(max_workers=2, thread_name_prefix='profile-cache') cache_slots = threading.BoundedSemaphore(2) cache_breaker_lock = threading.Lock() cache_retry_after = 0.0 def cache_call(method, *args): global cache_retry_after with cache_breaker_lock: if time.monotonic() < cache_retry_after: raise RedisError('Optional cache circuit open') if not cache_slots.acquire(blocking=False): raise RedisError('Optional cache busy') try: future = cache_workers.submit(getattr(cache, method), *args) except Exception: cache_slots.release() raise future.add_done_callback(lambda _: cache_slots.release()) try: return future.result(timeout=0.25) except (RedisError, FutureTimeout): with cache_breaker_lock: cache_retry_after = time.monotonic() + 2 raise RedisError('Optional cache unavailable') from None schemas = json.loads((ROOT/'contracts/openapi.json').read_text())['components']['schemas'] class APIError(Exception): def __init__(self, status, code, message): self.status, self.code, self.message = status, code, message def invalid(message='Invalid request'): raise APIError(400, 'invalid_request', message) def unauthorized(): raise APIError(401, 'unauthorized', 'Authentication required') @app.before_request def request_id(): g.request_id = uuid.uuid4().hex @app.after_request def headers(response): response.headers['X-Request-Id'] = g.request_id response.headers['Cache-Control'] = 'no-store' if response.status_code == 401: response.headers['WWW-Authenticate'] = ('Basic realm="messenger", charset="UTF-8"' if request.path == '/api/v1/auth/sessions' else 'Bearer realm="messenger"') return response @app.errorhandler(Exception) def error(exc): if isinstance(exc, APIError): status, code, message = exc.status, exc.code, exc.message elif isinstance(exc, UniqueViolation): status, code, message = 409, 'conflict', 'Username already registered' elif isinstance(exc, (DatabaseError, PoolTimeout)): status, code, message = 503, 'unavailable', 'Storage temporarily unavailable' elif isinstance(exc, HTTPException): status = exc.code code = {400:'invalid_request',404:'not_found',405:'not_found',413:'payload_too_large',415:'unsupported_media_type'}.get(status,'invalid_request') message = 'Request rejected' else: app.logger.error('Unhandled exception class=%s request_id=%s', type(exc).__name__, g.request_id) status, code, message = 500, 'internal_error', 'Internal error' return jsonify(error={'code':code,'message':message,'request_id':g.request_id}), status def wire(row): return {k: (str(v) if isinstance(v, uuid.UUID) else v.astimezone(timezone.utc).isoformat().replace('+00:00','Z') if isinstance(v,datetime) else v) for k,v in row.items()} def body(schema): if not request.is_json: raise APIError(415,'unsupported_media_type','Expected application/json') data = request.get_json() try: Draft202012Validator(schemas[schema], format_checker=FormatChecker()).validate(data) except ValidationError: invalid() for value in data.values(): if isinstance(value,str) and not value.strip(): invalid('Blank strings are not allowed') return data def uid(value): try: return str(uuid.UUID(value)) except (ValueError,TypeError,AttributeError): invalid('Invalid UUID') def token_digest(token): return hashlib.sha256(token.encode()).hexdigest() def authenticate(conn): auth = request.headers.get('Authorization','').split() if len(auth)!=2 or auth[0].lower()!='bearer' or len(auth[1])>256: unauthorized() g.token_hash = token_digest(auth[1]) session = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at>clock_timestamp()', (g.token_hash,)).fetchone() if session is None: unauthorized() user_id = str(session['user_id']) key = 'profile:v1:' + user_id try: encoded = cache_call('get', key) if encoded: profile = json.loads(encoded) Draft202012Validator(schemas['User'], format_checker=FormatChecker()).validate(profile) if profile['id'] == user_id: return profile except (RedisError, ValueError, ValidationError): pass # PostgreSQL remains authoritative and is never bypassed for sessions. row = conn.execute('SELECT id,username,display_name,created_at FROM users WHERE id=%s', (user_id,)).fetchone() if row is None: unauthorized() profile = wire(row) try: cache_call('setex', key, PROFILE_CACHE_TTL, json.dumps(profile)) except RedisError: pass return profile def chat(conn, chat_id, user_id): row = conn.execute('SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s',(chat_id,user_id)).fetchone() if row is None: raise APIError(404,'not_found','Object not found') result = wire(row) result['member_ids'] = [str(x['user_id']) for x in conn.execute('SELECT user_id FROM members WHERE chat_id=%s ORDER BY user_id',(chat_id,))] return result def page_args(scope): if set(request.args)-{'limit','cursor'} or any(len(request.args.getlist(k))!=1 for k in request.args): invalid() value = request.args.get('limit','50') if not re.fullmatch(r'[0-9]{1,3}',value) or not 1<=int(value)<=100: invalid('Invalid limit') after = None if 'cursor' in request.args: try: encoded=request.args['cursor'] if len(encoded)>1024: invalid() cursor=json.loads(base64.b64decode(encoded,altchars=b'-_',validate=True)) if len(cursor)!=3 or cursor[0]!=scope: invalid() stamp=datetime.fromisoformat(cursor[1].replace('Z','+00:00')) if stamp.tzinfo is None: invalid() after=(stamp,uid(cursor[2])) except (ValueError,TypeError,KeyError,IndexError): invalid('Invalid cursor') return int(value), after def page(rows,limit,scope): items=rows[:limit] cursor=None if len(rows)>limit: last=items[-1] cursor=base64.urlsafe_b64encode(json.dumps([scope,last['created_at'],last['id']]).encode()).decode() return jsonify(items=items,next_cursor=cursor) @app.get('/health/live') def live(): return jsonify(status='ok') @app.get('/health/ready') def ready(): with pool.connection() as conn: conn.execute('SELECT 1 FROM schema_migrations LIMIT 1') return jsonify(status='ok') @app.post('/api/v1/users') def register(): data=body('CreateUser') hashed=passwords.hash(data['password']) 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.uuid4(),data['username'],data['display_name'],hashed)).fetchone() return jsonify(wire(row)),201 @app.post('/api/v1/auth/sessions') def login(): if request.get_data(): invalid('Login has no request body') auth=request.headers.get('Authorization','').split() try: if len(auth)!=2 or auth[0].lower()!='basic': unauthorized() username,password=base64.b64decode(auth[1],validate=True).decode('utf-8').split(':',1) except (ValueError,UnicodeError): unauthorized() with pool.connection() as conn: row=conn.execute('SELECT * FROM users WHERE username=%s',(username,)).fetchone() try: valid=passwords.verify(row['password_hash'] if row else dummy_hash,password) except (VerificationError,InvalidHashError): valid=False if not valid or row is None: unauthorized() token=secrets.token_urlsafe(32) session=conn.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES(%s,%s,clock_timestamp()+(%s * interval '1 second')) RETURNING expires_at",(token_digest(token),row['id'],ttl)).fetchone() user=wire({k:v for k,v in row.items() if k!='password_hash'}) return jsonify(token=token,token_type='Bearer',expires_at=wire(session)['expires_at'],user=user),201 @app.delete('/api/v1/auth/sessions/current') def logout(): with pool.connection() as conn: authenticate(conn) conn.execute('DELETE FROM sessions WHERE token_hash=%s',(g.token_hash,)) return '',204 @app.get('/api/v1/users/me') def me(): with pool.connection() as conn: result=wire(authenticate(conn)) return jsonify(result) @app.post('/api/v1/chats') def create_chat(): with pool.connection() as conn: actor=authenticate(conn) data=body('CreateChat') ids=[uid(x) for x in data['member_ids']] if len(set(ids))!=len(ids) or str(actor['id']) not in ids: invalid() known=conn.execute('SELECT id FROM users WHERE id=ANY(%s::uuid[])',(ids,)).fetchall() if len(known)!=len(ids): invalid('Unknown member') chat_id=uuid.uuid4() conn.execute('INSERT INTO chats(id,title) VALUES(%s,%s)',(chat_id,data['title'])) for member in ids: conn.execute('INSERT INTO members(chat_id,user_id) VALUES(%s,%s)',(chat_id,member)) result=chat(conn,chat_id,actor['id']) return jsonify(result),201 @app.get('/api/v1/chats') def chats(): with pool.connection() as conn: actor=authenticate(conn) scope='chats:'+str(actor['id']) limit,after=page_args(scope) sql='SELECT c.* FROM chats c JOIN members m ON m.chat_id=c.id WHERE m.user_id=%s' args=[actor['id']] if after: sql+=' AND (c.created_at,c.id)>(%s,%s)'; args.extend(after) sql+=' ORDER BY c.created_at,c.id LIMIT %s'; args.append(limit+1) rows=[chat(conn,x['id'],actor['id']) for x in conn.execute(sql,args).fetchall()] return page(rows,limit,scope) @app.get('/api/v1/chats/') def get_chat(chat_id): with pool.connection() as conn: actor=authenticate(conn) result=chat(conn,uid(chat_id),actor['id']) return jsonify(result) @app.route('/api/v1/chats//messages',methods=['GET','POST']) def messages(chat_id): with pool.connection() as conn: actor=authenticate(conn) chat_id=uid(chat_id) chat(conn,chat_id,actor['id']) if request.method=='POST': data=body('CreateMessage') row=conn.execute('INSERT INTO messages(id,chat_id,sender_id,text) VALUES(%s,%s,%s,%s) RETURNING *',(uuid.uuid4(),chat_id,actor['id'],data['text'])).fetchone() result=wire(row) else: scope='messages:'+chat_id limit,after=page_args(scope) sql='SELECT * FROM messages WHERE chat_id=%s'; args=[chat_id] if after: sql+=' AND (created_at,id)>(%s,%s)'; args.extend(after) sql+=' ORDER BY created_at,id LIMIT %s'; args.append(limit+1) rows=[wire(x) for x in conn.execute(sql,args).fetchall()] return (jsonify(result),201) if request.method=='POST' else page(rows,limit,scope)