import hashlib import secrets from datetime import datetime, timedelta, timezone from redis import Redis from redis.backoff import NoBackoff from redis.exceptions import RedisError from redis.retry import Retry from sqlalchemy.orm import Session from app.core.config import settings from app.db.models import User from app.repositories.session_repository import SessionRepository from app.repositories.user_repository import UserRepository from app.services.user_service import password_hasher class InvalidCredentialsError(Exception): pass class InvalidSessionError(Exception): pass class AuthService: def __init__(self, db: Session): self.db = db self.sessions = SessionRepository(db) self.users = UserRepository(db) self._redis_available = True self.redis = Redis.from_url( settings.cache_url, decode_responses=True, socket_connect_timeout=0.5, socket_timeout=0.5, retry_on_timeout=False, retry=Retry(NoBackoff(), 0), ) @staticmethod def _hash_token(token: str) -> str: return hashlib.sha256(token.encode("utf-8")).hexdigest() def create_session(self, username: str, password: str) -> dict: user = self.users.get_by_username(username) if user is None or not password_hasher.verify( password, user.password_hash ): raise InvalidCredentialsError("Invalid username or password") token = secrets.token_urlsafe(32) token_hash = self._hash_token(token) expires_at = datetime.now(timezone.utc) + timedelta( seconds=settings.session_ttl_seconds ) try: self.sessions.create( user_id=user.id, token_hash=token_hash, expires_at=expires_at, ) self.db.commit() except Exception: self.db.rollback() raise self._cache_session(token_hash, user.id, expires_at) return { "token": token, "token_type": "Bearer", "expires_at": expires_at, "user": user, } def _cache_session( self, token_hash: str, user_id, expires_at, ) -> None: if not self._redis_available: return ttl = max( 1, int((expires_at - datetime.now(timezone.utc)).total_seconds()), ) try: self.redis.setex( f"session:{token_hash}", ttl, str(user_id), ) except RedisError: self._redis_available = False def authenticate(self, token: str) -> User: token_hash = self._hash_token(token) cached_user_id = None if self._redis_available: try: cached_user_id = self.redis.get( f"session:{token_hash}" ) except RedisError: self._redis_available = False session = self.sessions.get_valid_session(token_hash) if session is None: if self._redis_available: try: self.redis.delete(f"session:{token_hash}") except RedisError: self._redis_available = False raise InvalidSessionError( "Session is invalid or expired" ) if cached_user_id is None: self._cache_session( token_hash, session.user_id, session.expires_at, ) return session.user def delete_session(self, token: str) -> None: token_hash = self._hash_token(token) try: deleted = self.sessions.delete_by_token_hash(token_hash) if not deleted: raise InvalidSessionError( "Session is invalid or expired" ) self.db.commit() except Exception: self.db.rollback() raise if self._redis_available: try: self.redis.delete(f"session:{token_hash}") except RedisError: self._redis_available = False