forked from mtusi2026/mtusi2026lab3
160 lines
4.2 KiB
Python
160 lines
4.2 KiB
Python
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
|