auth-wip
This commit is contained in:
120
services/auth.py
120
services/auth.py
@@ -13,7 +13,7 @@ from auth.orm import Author, Role
|
||||
ALLOWED_HEADERS = ["Authorization", "Content-Type"]
|
||||
|
||||
|
||||
async def check_auth(req) -> Tuple[str, list[str]]:
|
||||
async def check_auth(req) -> Tuple[str, list[str], bool]:
|
||||
"""
|
||||
Проверка авторизации пользователя.
|
||||
|
||||
@@ -25,11 +25,12 @@ async def check_auth(req) -> Tuple[str, list[str]]:
|
||||
Возвращает:
|
||||
- user_id: str - Идентификатор пользователя
|
||||
- user_roles: list[str] - Список ролей пользователя
|
||||
- is_admin: bool - Флаг наличия у пользователя административных прав
|
||||
"""
|
||||
# Проверяем наличие токена
|
||||
token = req.headers.get("Authorization")
|
||||
if not token:
|
||||
return "", []
|
||||
return "", [], False
|
||||
|
||||
# Очищаем токен от префикса Bearer если он есть
|
||||
if token.startswith("Bearer "):
|
||||
@@ -39,8 +40,39 @@ async def check_auth(req) -> Tuple[str, list[str]]:
|
||||
|
||||
# Проверяем авторизацию внутренним механизмом
|
||||
logger.debug("Using internal authentication")
|
||||
return await verify_internal_auth(token)
|
||||
|
||||
user_id, user_roles = await verify_internal_auth(token)
|
||||
|
||||
# Проверяем наличие административных прав у пользователя
|
||||
is_admin = False
|
||||
if user_id:
|
||||
# Быстрая проверка на админ роли в кэше
|
||||
admin_roles = ['admin', 'super']
|
||||
for role in user_roles:
|
||||
if role in admin_roles:
|
||||
is_admin = True
|
||||
break
|
||||
|
||||
# Если в ролях нет админа, но есть ID - проверяем в БД
|
||||
if not is_admin:
|
||||
try:
|
||||
with local_session() as session:
|
||||
# Преобразуем user_id в число
|
||||
try:
|
||||
user_id_int = int(user_id.strip())
|
||||
except (ValueError, TypeError):
|
||||
logger.error(f"Невозможно преобразовать user_id {user_id} в число")
|
||||
else:
|
||||
# Проверяем наличие админских прав через БД
|
||||
from auth.orm import AuthorRole
|
||||
admin_role = session.query(AuthorRole).filter(
|
||||
AuthorRole.author == user_id_int,
|
||||
AuthorRole.role.in_(["admin", "super"])
|
||||
).first()
|
||||
is_admin = admin_role is not None
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка при проверке прав администратора: {e}")
|
||||
|
||||
return user_id, user_roles, is_admin
|
||||
|
||||
async def add_user_role(user_id: str, roles: list[str] = None):
|
||||
"""
|
||||
@@ -84,21 +116,36 @@ async def add_user_role(user_id: str, roles: list[str] = None):
|
||||
|
||||
|
||||
def login_required(f):
|
||||
"""Декоратор для проверки авторизации пользователя."""
|
||||
"""Декоратор для проверки авторизации пользователя. Требуется наличие роли 'reader'."""
|
||||
|
||||
@wraps(f)
|
||||
async def decorated_function(*args, **kwargs):
|
||||
from graphql.error import GraphQLError
|
||||
|
||||
info = args[1]
|
||||
req = info.context.get("request")
|
||||
user_id, user_roles = await check_auth(req)
|
||||
if user_id and user_roles:
|
||||
logger.info(f" got {user_id} roles: {user_roles}")
|
||||
info.context["user_id"] = user_id.strip()
|
||||
info.context["roles"] = user_roles
|
||||
author = await get_cached_author_by_user_id(user_id, get_with_stat)
|
||||
if not author:
|
||||
logger.error(f"author profile not found for user {user_id}")
|
||||
info.context["author"] = author
|
||||
user_id, user_roles, is_admin = await check_auth(req)
|
||||
|
||||
if not user_id:
|
||||
raise GraphQLError("Требуется авторизация")
|
||||
|
||||
# Проверяем наличие роли reader
|
||||
if 'reader' not in user_roles and not is_admin:
|
||||
logger.error(f"Пользователь {user_id} не имеет роли 'reader'")
|
||||
raise GraphQLError("У вас нет необходимых прав для доступа")
|
||||
|
||||
logger.info(f"Авторизован пользователь {user_id} с ролями: {user_roles}")
|
||||
info.context["user_id"] = user_id.strip()
|
||||
info.context["roles"] = user_roles
|
||||
|
||||
# Проверяем права администратора
|
||||
info.context["is_admin"] = is_admin
|
||||
|
||||
author = await get_cached_author_by_user_id(user_id, get_with_stat)
|
||||
if not author:
|
||||
logger.error(f"Профиль автора не найден для пользователя {user_id}")
|
||||
info.context["author"] = author
|
||||
|
||||
return await f(*args, **kwargs)
|
||||
|
||||
return decorated_function
|
||||
@@ -113,19 +160,24 @@ def login_accepted(f):
|
||||
req = info.context.get("request")
|
||||
|
||||
logger.debug("login_accepted: Проверка авторизации пользователя.")
|
||||
user_id, user_roles = await check_auth(req)
|
||||
user_id, user_roles, is_admin = await check_auth(req)
|
||||
logger.debug(f"login_accepted: user_id={user_id}, user_roles={user_roles}")
|
||||
|
||||
if user_id and user_roles:
|
||||
logger.info(f"login_accepted: Пользователь авторизован: {user_id} с ролями {user_roles}")
|
||||
info.context["user_id"] = user_id.strip()
|
||||
info.context["roles"] = user_roles
|
||||
|
||||
# Проверяем права администратора
|
||||
info.context["is_admin"] = is_admin
|
||||
|
||||
# Пробуем получить профиль автора
|
||||
author = await get_cached_author_by_user_id(user_id, get_with_stat)
|
||||
if author:
|
||||
logger.debug(f"login_accepted: Найден профиль автора: {author}")
|
||||
info.context["author"] = author.dict()
|
||||
# Используем флаг is_admin из контекста или передаем права владельца для собственных данных
|
||||
is_owner = True # Пользователь всегда является владельцем собственного профиля
|
||||
info.context["author"] = author.dict(access=is_owner or is_admin)
|
||||
else:
|
||||
logger.error(
|
||||
f"login_accepted: Профиль автора не найден для пользователя {user_id}. Используем базовые данные."
|
||||
@@ -135,7 +187,43 @@ def login_accepted(f):
|
||||
info.context["user_id"] = None
|
||||
info.context["roles"] = None
|
||||
info.context["author"] = None
|
||||
info.context["is_admin"] = False
|
||||
|
||||
return await f(*args, **kwargs)
|
||||
|
||||
return decorated_function
|
||||
|
||||
def author_required(f):
|
||||
"""Декоратор для проверки наличия роли 'author' у пользователя."""
|
||||
|
||||
@wraps(f)
|
||||
async def decorated_function(*args, **kwargs):
|
||||
from graphql.error import GraphQLError
|
||||
|
||||
info = args[1]
|
||||
req = info.context.get("request")
|
||||
user_id, user_roles, is_admin = await check_auth(req)
|
||||
|
||||
if not user_id:
|
||||
raise GraphQLError("Требуется авторизация")
|
||||
|
||||
# Проверяем наличие роли author
|
||||
if 'author' not in user_roles and not is_admin:
|
||||
logger.error(f"Пользователь {user_id} не имеет роли 'author'")
|
||||
raise GraphQLError("Для выполнения этого действия необходимы права автора")
|
||||
|
||||
logger.info(f"Авторизован автор {user_id} с ролями: {user_roles}")
|
||||
info.context["user_id"] = user_id.strip()
|
||||
info.context["roles"] = user_roles
|
||||
|
||||
# Проверяем права администратора
|
||||
info.context["is_admin"] = is_admin
|
||||
|
||||
author = await get_cached_author_by_user_id(user_id, get_with_stat)
|
||||
if not author:
|
||||
logger.error(f"Профиль автора не найден для пользователя {user_id}")
|
||||
info.context["author"] = author
|
||||
|
||||
return await f(*args, **kwargs)
|
||||
|
||||
return decorated_function
|
||||
|
||||
328
services/env.py
328
services/env.py
@@ -1,7 +1,10 @@
|
||||
from typing import Dict, List, Optional
|
||||
from typing import Dict, List, Optional, Set
|
||||
from dataclasses import dataclass
|
||||
import os
|
||||
import re
|
||||
from pathlib import Path
|
||||
from redis import Redis
|
||||
from settings import REDIS_URL
|
||||
from settings import REDIS_URL, ROOT_DIR
|
||||
from utils.logger import root_logger as logger
|
||||
|
||||
|
||||
@@ -23,85 +26,326 @@ class EnvSection:
|
||||
|
||||
class EnvManager:
|
||||
"""
|
||||
Менеджер переменных окружения с хранением в Redis
|
||||
Менеджер переменных окружения с хранением в Redis и синхронизацией с .env файлом
|
||||
"""
|
||||
|
||||
# Стандартные переменные окружения, которые следует исключить
|
||||
EXCLUDED_ENV_VARS: Set[str] = {
|
||||
"PATH", "SHELL", "USER", "HOME", "PWD", "TERM", "LANG",
|
||||
"PYTHONPATH", "_", "TMPDIR", "TERM_PROGRAM", "TERM_SESSION_ID",
|
||||
"XPC_SERVICE_NAME", "XPC_FLAGS", "SHLVL", "SECURITYSESSIONID",
|
||||
"LOGNAME", "OLDPWD", "ZSH", "PAGER", "LESS", "LC_CTYPE", "LSCOLORS",
|
||||
"SSH_AUTH_SOCK", "DISPLAY", "COLORTERM", "EDITOR", "VISUAL",
|
||||
"PYTHONDONTWRITEBYTECODE", "VIRTUAL_ENV", "PYTHONUNBUFFERED"
|
||||
}
|
||||
|
||||
# Секции для группировки переменных
|
||||
SECTIONS = {
|
||||
"AUTH": {
|
||||
"pattern": r"^(JWT|AUTH|SESSION|OAUTH|GITHUB|GOOGLE|FACEBOOK)_",
|
||||
"name": "Авторизация",
|
||||
"description": "Настройки системы авторизации"
|
||||
},
|
||||
"DATABASE": {
|
||||
"pattern": r"^(DB|DATABASE|POSTGRES|MYSQL|SQL)_",
|
||||
"name": "База данных",
|
||||
"description": "Настройки подключения к базам данных"
|
||||
},
|
||||
"CACHE": {
|
||||
"pattern": r"^(REDIS|CACHE|MEMCACHED)_",
|
||||
"name": "Кэширование",
|
||||
"description": "Настройки систем кэширования"
|
||||
},
|
||||
"SEARCH": {
|
||||
"pattern": r"^(ELASTIC|SEARCH|OPENSEARCH)_",
|
||||
"name": "Поиск",
|
||||
"description": "Настройки поисковых систем"
|
||||
},
|
||||
"APP": {
|
||||
"pattern": r"^(APP|PORT|HOST|DEBUG|DOMAIN|ENVIRONMENT|ENV|FRONTEND)_",
|
||||
"name": "Приложение",
|
||||
"description": "Основные настройки приложения"
|
||||
},
|
||||
"LOGGING": {
|
||||
"pattern": r"^(LOG|LOGGING|SENTRY|GLITCH|GLITCHTIP)_",
|
||||
"name": "Логирование",
|
||||
"description": "Настройки логирования и мониторинга"
|
||||
},
|
||||
"EMAIL": {
|
||||
"pattern": r"^(MAIL|EMAIL|SMTP)_",
|
||||
"name": "Электронная почта",
|
||||
"description": "Настройки отправки электронной почты"
|
||||
},
|
||||
"ANALYTICS": {
|
||||
"pattern": r"^(GA|GOOGLE_ANALYTICS|ANALYTICS)_",
|
||||
"name": "Аналитика",
|
||||
"description": "Настройки систем аналитики"
|
||||
},
|
||||
}
|
||||
|
||||
# Переменные, которые следует всегда помечать как секретные
|
||||
SECRET_VARS_PATTERNS = [
|
||||
r".*TOKEN.*", r".*SECRET.*", r".*PASSWORD.*", r".*KEY.*",
|
||||
r".*PWD.*", r".*PASS.*", r".*CRED.*"
|
||||
]
|
||||
|
||||
def __init__(self):
|
||||
self.redis = Redis.from_url(REDIS_URL)
|
||||
self.prefix = "env:"
|
||||
self.env_file_path = os.path.join(ROOT_DIR, '.env')
|
||||
|
||||
def get_all_variables(self) -> List[EnvSection]:
|
||||
"""
|
||||
Получение всех переменных окружения, сгруппированных по секциям
|
||||
"""
|
||||
try:
|
||||
# Получаем все ключи с префиксом env:
|
||||
keys = self.redis.keys(f"{self.prefix}*")
|
||||
variables: Dict[str, str] = {}
|
||||
# Получаем все переменные окружения из системы
|
||||
system_env = self._get_system_env_vars()
|
||||
|
||||
for key in keys:
|
||||
var_key = key.decode("utf-8").replace(self.prefix, "")
|
||||
value = self.redis.get(key)
|
||||
if value:
|
||||
variables[var_key] = value.decode("utf-8")
|
||||
# Получаем переменные из .env файла, если он существует
|
||||
dotenv_vars = self._get_dotenv_vars()
|
||||
|
||||
# Получаем все переменные из Redis
|
||||
redis_vars = self._get_redis_env_vars()
|
||||
|
||||
# Объединяем переменные, при этом redis_vars имеют наивысший приоритет,
|
||||
# за ними следуют переменные из .env, затем системные
|
||||
env_vars = {**system_env, **dotenv_vars, **redis_vars}
|
||||
|
||||
# Группируем переменные по секциям
|
||||
sections = [
|
||||
EnvSection(
|
||||
name="Авторизация",
|
||||
description="Настройки системы авторизации",
|
||||
variables=[
|
||||
EnvVariable(
|
||||
key="JWT_SECRET",
|
||||
value=variables.get("JWT_SECRET", ""),
|
||||
description="Секретный ключ для JWT токенов",
|
||||
type="string",
|
||||
is_secret=True,
|
||||
),
|
||||
],
|
||||
),
|
||||
EnvSection(
|
||||
name="Redis",
|
||||
description="Настройки подключения к Redis",
|
||||
variables=[
|
||||
EnvVariable(
|
||||
key="REDIS_URL",
|
||||
value=variables.get("REDIS_URL", ""),
|
||||
description="URL подключения к Redis",
|
||||
type="string",
|
||||
)
|
||||
],
|
||||
),
|
||||
# Добавьте другие секции по необходимости
|
||||
]
|
||||
|
||||
return sections
|
||||
return self._group_variables_by_sections(env_vars)
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка получения переменных: {e}")
|
||||
return []
|
||||
|
||||
def _get_system_env_vars(self) -> Dict[str, str]:
|
||||
"""
|
||||
Получает переменные окружения из системы, исключая стандартные
|
||||
"""
|
||||
env_vars = {}
|
||||
for key, value in os.environ.items():
|
||||
# Пропускаем стандартные переменные
|
||||
if key in self.EXCLUDED_ENV_VARS:
|
||||
continue
|
||||
# Пропускаем переменные с пустыми значениями
|
||||
if not value:
|
||||
continue
|
||||
env_vars[key] = value
|
||||
return env_vars
|
||||
|
||||
def _get_dotenv_vars(self) -> Dict[str, str]:
|
||||
"""
|
||||
Получает переменные из .env файла, если он существует
|
||||
"""
|
||||
env_vars = {}
|
||||
if os.path.exists(self.env_file_path):
|
||||
try:
|
||||
with open(self.env_file_path, 'r') as f:
|
||||
for line in f:
|
||||
line = line.strip()
|
||||
# Пропускаем пустые строки и комментарии
|
||||
if not line or line.startswith('#'):
|
||||
continue
|
||||
# Разделяем строку на ключ и значение
|
||||
if '=' in line:
|
||||
key, value = line.split('=', 1)
|
||||
key = key.strip()
|
||||
value = value.strip()
|
||||
# Удаляем кавычки, если они есть
|
||||
if value.startswith('"') and value.endswith('"'):
|
||||
value = value[1:-1]
|
||||
env_vars[key] = value
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка чтения .env файла: {e}")
|
||||
return env_vars
|
||||
|
||||
def _get_redis_env_vars(self) -> Dict[str, str]:
|
||||
"""
|
||||
Получает переменные окружения из Redis
|
||||
"""
|
||||
redis_vars = {}
|
||||
try:
|
||||
# Получаем все ключи с префиксом env:
|
||||
keys = self.redis.keys(f"{self.prefix}*")
|
||||
for key in keys:
|
||||
var_key = key.decode("utf-8").replace(self.prefix, "")
|
||||
value = self.redis.get(key)
|
||||
if value:
|
||||
redis_vars[var_key] = value.decode("utf-8")
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка получения переменных из Redis: {e}")
|
||||
return redis_vars
|
||||
|
||||
def _is_secret_variable(self, key: str) -> bool:
|
||||
"""
|
||||
Проверяет, является ли переменная секретной
|
||||
"""
|
||||
key_upper = key.upper()
|
||||
return any(re.match(pattern, key_upper) for pattern in self.SECRET_VARS_PATTERNS)
|
||||
|
||||
def _determine_variable_type(self, value: str) -> str:
|
||||
"""
|
||||
Определяет тип переменной на основе ее значения
|
||||
"""
|
||||
if value.lower() in ('true', 'false'):
|
||||
return "boolean"
|
||||
if value.isdigit():
|
||||
return "integer"
|
||||
if re.match(r"^\d+\.\d+$", value):
|
||||
return "float"
|
||||
# Проверяем на JSON объект или массив
|
||||
if (value.startswith('{') and value.endswith('}')) or (value.startswith('[') and value.endswith(']')):
|
||||
return "json"
|
||||
# Проверяем на URL
|
||||
if value.startswith(('http://', 'https://', 'redis://', 'postgresql://')):
|
||||
return "url"
|
||||
return "string"
|
||||
|
||||
def _group_variables_by_sections(self, variables: Dict[str, str]) -> List[EnvSection]:
|
||||
"""
|
||||
Группирует переменные по секциям
|
||||
"""
|
||||
# Создаем словарь для группировки переменных
|
||||
sections_dict = {section: [] for section in self.SECTIONS}
|
||||
other_variables = [] # Для переменных, которые не попали ни в одну секцию
|
||||
|
||||
# Распределяем переменные по секциям
|
||||
for key, value in variables.items():
|
||||
is_secret = self._is_secret_variable(key)
|
||||
var_type = self._determine_variable_type(value)
|
||||
|
||||
var = EnvVariable(
|
||||
key=key,
|
||||
value=value,
|
||||
type=var_type,
|
||||
is_secret=is_secret
|
||||
)
|
||||
|
||||
# Определяем секцию для переменной
|
||||
placed = False
|
||||
for section_id, section_config in self.SECTIONS.items():
|
||||
if re.match(section_config["pattern"], key, re.IGNORECASE):
|
||||
sections_dict[section_id].append(var)
|
||||
placed = True
|
||||
break
|
||||
|
||||
# Если переменная не попала ни в одну секцию
|
||||
if not placed:
|
||||
other_variables.append(var)
|
||||
|
||||
# Формируем результат
|
||||
result = []
|
||||
for section_id, variables in sections_dict.items():
|
||||
if variables: # Добавляем только непустые секции
|
||||
section_config = self.SECTIONS[section_id]
|
||||
result.append(
|
||||
EnvSection(
|
||||
name=section_config["name"],
|
||||
description=section_config["description"],
|
||||
variables=variables
|
||||
)
|
||||
)
|
||||
|
||||
# Добавляем прочие переменные, если они есть
|
||||
if other_variables:
|
||||
result.append(
|
||||
EnvSection(
|
||||
name="Прочие переменные",
|
||||
description="Переменные, не вошедшие в основные категории",
|
||||
variables=other_variables
|
||||
)
|
||||
)
|
||||
|
||||
return result
|
||||
|
||||
def update_variable(self, key: str, value: str) -> bool:
|
||||
"""
|
||||
Обновление значения переменной
|
||||
Обновление значения переменной в Redis и .env файле
|
||||
"""
|
||||
try:
|
||||
# Сохраняем в Redis
|
||||
full_key = f"{self.prefix}{key}"
|
||||
self.redis.set(full_key, value)
|
||||
|
||||
# Обновляем значение в .env файле
|
||||
self._update_dotenv_var(key, value)
|
||||
|
||||
# Обновляем переменную в текущем процессе
|
||||
os.environ[key] = value
|
||||
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка обновления переменной {key}: {e}")
|
||||
return False
|
||||
|
||||
def _update_dotenv_var(self, key: str, value: str) -> bool:
|
||||
"""
|
||||
Обновляет переменную в .env файле
|
||||
"""
|
||||
try:
|
||||
# Если файл .env не существует, создаем его
|
||||
if not os.path.exists(self.env_file_path):
|
||||
with open(self.env_file_path, 'w') as f:
|
||||
f.write(f"{key}={value}\n")
|
||||
return True
|
||||
|
||||
# Если файл существует, читаем его содержимое
|
||||
lines = []
|
||||
found = False
|
||||
|
||||
with open(self.env_file_path, 'r') as f:
|
||||
for line in f:
|
||||
if line.strip() and not line.strip().startswith('#'):
|
||||
if line.strip().startswith(f"{key}="):
|
||||
# Экранируем значение, если необходимо
|
||||
if ' ' in value or ',' in value or '"' in value or "'" in value:
|
||||
escaped_value = f'"{value}"'
|
||||
else:
|
||||
escaped_value = value
|
||||
lines.append(f"{key}={escaped_value}\n")
|
||||
found = True
|
||||
else:
|
||||
lines.append(line)
|
||||
else:
|
||||
lines.append(line)
|
||||
|
||||
# Если переменной не было в файле, добавляем ее
|
||||
if not found:
|
||||
# Экранируем значение, если необходимо
|
||||
if ' ' in value or ',' in value or '"' in value or "'" in value:
|
||||
escaped_value = f'"{value}"'
|
||||
else:
|
||||
escaped_value = value
|
||||
lines.append(f"{key}={escaped_value}\n")
|
||||
|
||||
# Записываем обновленный файл
|
||||
with open(self.env_file_path, 'w') as f:
|
||||
f.writelines(lines)
|
||||
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка обновления .env файла: {e}")
|
||||
return False
|
||||
|
||||
def update_variables(self, variables: List[EnvVariable]) -> bool:
|
||||
"""
|
||||
Массовое обновление переменных
|
||||
"""
|
||||
try:
|
||||
# Обновляем переменные в Redis
|
||||
pipe = self.redis.pipeline()
|
||||
for var in variables:
|
||||
full_key = f"{self.prefix}{var.key}"
|
||||
pipe.set(full_key, var.value)
|
||||
pipe.execute()
|
||||
|
||||
# Обновляем переменные в .env файле
|
||||
for var in variables:
|
||||
self._update_dotenv_var(var.key, var.value)
|
||||
|
||||
# Обновляем переменную в текущем процессе
|
||||
os.environ[var.key] = var.value
|
||||
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Ошибка массового обновления переменных: {e}")
|
||||
|
||||
Reference in New Issue
Block a user