Vladless
831 lines
38 KiB
Python
831 lines
38 KiB
Python
import asyncio
|
||
|
||
from datetime import datetime, timezone
|
||
from typing import Any
|
||
|
||
from aiogram import F, types
|
||
from aiogram.types import CallbackQuery
|
||
from py3xui import AsyncApi
|
||
from sqlalchemy import delete, select, update
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from config import (
|
||
ADMIN_PASSWORD,
|
||
ADMIN_USERNAME,
|
||
REMNAWAVE_LOGIN,
|
||
REMNAWAVE_PASSWORD,
|
||
USE_COUNTRY_SELECTION,
|
||
)
|
||
from core.bootstrap import MODES_CONFIG
|
||
from database import get_servers
|
||
from database.models import Key, Server, Tariff, User
|
||
from filters.admin import IsAdminFilter
|
||
from handlers.utils import ALLOWED_GROUP_CODES
|
||
from logger import logger
|
||
from panels.remnawave import RemnawaveAPI
|
||
from services.operations import (
|
||
create_client_on_server,
|
||
create_key_on_cluster,
|
||
delete_key_from_cluster,
|
||
)
|
||
from services.operations.aggregated_links import make_aggregated_link
|
||
from utils.backup import create_backup_and_send_to_admins
|
||
|
||
from ..panel.keyboard import build_admin_back_kb
|
||
from .base import router
|
||
from .keyboard import AdminClusterCallback, build_availability_kb, build_sync_cluster_kb
|
||
|
||
|
||
@router.callback_query(AdminClusterCallback.filter(F.action == "availability"), IsAdminFilter())
|
||
async def handle_cluster_availability(
|
||
callback_query: types.CallbackQuery,
|
||
callback_data: AdminClusterCallback,
|
||
session: Any,
|
||
):
|
||
cluster_name = callback_data.data
|
||
servers = await get_servers(session)
|
||
cluster_servers = servers.get(cluster_name, [])
|
||
|
||
if not cluster_servers:
|
||
await callback_query.message.edit_text(text=f"Кластер '{cluster_name}' не содержит серверов.")
|
||
return
|
||
|
||
await callback_query.message.edit_text(
|
||
text=(
|
||
f"🖥️ Проверка доступности серверов для кластера {cluster_name}.\n\n"
|
||
"Это может занять до 1 минуты, пожалуйста, подождите..."
|
||
)
|
||
)
|
||
|
||
total_online_users = 0
|
||
result_text = f"<b>🖥️ Проверка доступности серверов</b>\n\n⚙️ Кластер: <b>{cluster_name}</b>\n\n"
|
||
|
||
for server in cluster_servers:
|
||
server_name = server["server_name"]
|
||
panel_type = server.get("panel_type", "3x-ui").lower()
|
||
prefix = "[3x]" if panel_type == "3x-ui" else "[Re]"
|
||
|
||
try:
|
||
if panel_type == "3x-ui":
|
||
xui = AsyncApi(
|
||
server["api_url"],
|
||
username=ADMIN_USERNAME,
|
||
password=ADMIN_PASSWORD,
|
||
logger=None,
|
||
)
|
||
await xui.login()
|
||
inbound_id = int(server["inbound_id"])
|
||
online_clients = await xui.client.online()
|
||
online_inbound_users = 0
|
||
|
||
for client_email in online_clients:
|
||
client = await xui.client.get_by_email(client_email)
|
||
if client and client.inbound_id == inbound_id:
|
||
online_inbound_users += 1
|
||
|
||
total_online_users += online_inbound_users
|
||
result_text += f"🌍 <b>{prefix} {server_name}</b> - {online_inbound_users} онлайн\n"
|
||
|
||
elif panel_type == "remnawave":
|
||
server_inbound_id = server.get("inbound_id")
|
||
if not server_inbound_id:
|
||
raise Exception("Не указан inbound_id сервера")
|
||
|
||
remna = RemnawaveAPI(server["api_url"])
|
||
nodes_data = await remna.get_all_nodes_with_online(
|
||
username=REMNAWAVE_LOGIN,
|
||
password=REMNAWAVE_PASSWORD,
|
||
inbound_id=server_inbound_id,
|
||
)
|
||
|
||
if nodes_data.get("error"):
|
||
raise Exception(nodes_data["error"])
|
||
|
||
online_remna_users = nodes_data["total_online"]
|
||
total_online_users += online_remna_users
|
||
|
||
nodes_info = nodes_data["nodes"]
|
||
result_text += f"🌍 <b>{prefix} {server_name}</b> - {online_remna_users} онлайн\n"
|
||
seen = set()
|
||
for node_info in nodes_info:
|
||
node_name = node_info.get("name", "Unknown")
|
||
if node_name in seen:
|
||
continue
|
||
seen.add(node_name)
|
||
|
||
country_code = node_info.get("country_code", "Unknown")
|
||
online_users = node_info.get("online_users", 0)
|
||
|
||
flag = (
|
||
"".join(chr(ord(c) + 127397) for c in country_code.upper())
|
||
if country_code != "Unknown" and len(country_code) == 2
|
||
else country_code
|
||
)
|
||
result_text += f" ↳ {flag} ({node_name}): {online_users} онлайн\n"
|
||
|
||
except Exception as e:
|
||
error_text = str(e) or "Сервер недоступен"
|
||
result_text += f"❌ <b>{prefix} {server_name}</b> - ошибка: {error_text}\n"
|
||
|
||
result_text += f"\n👥 Всего пользователей онлайн: {total_online_users}"
|
||
await callback_query.message.edit_text(
|
||
text=result_text,
|
||
reply_markup=build_availability_kb(cluster_name),
|
||
)
|
||
|
||
|
||
@router.callback_query(AdminClusterCallback.filter(F.action == "backup"), IsAdminFilter())
|
||
async def handle_clusters_backup(
|
||
callback_query: types.CallbackQuery,
|
||
callback_data: AdminClusterCallback,
|
||
session: Any,
|
||
):
|
||
cluster_name = callback_data.data
|
||
|
||
servers = await get_servers(session)
|
||
cluster_servers = servers.get(cluster_name, [])
|
||
|
||
for server in cluster_servers:
|
||
if server.get("panel_type") == "remnawave":
|
||
continue
|
||
|
||
xui = AsyncApi(
|
||
server["api_url"],
|
||
username=ADMIN_USERNAME,
|
||
password=ADMIN_PASSWORD,
|
||
logger=logger,
|
||
)
|
||
await create_backup_and_send_to_admins(xui)
|
||
|
||
text = (
|
||
f"<b>Бэкап для кластера {cluster_name} был успешно создан и отправлен администраторам!</b>\n\n"
|
||
f"🔔 <i>Бэкапы отправлены в боты панелей (3x-ui).</i>"
|
||
)
|
||
|
||
await callback_query.message.edit_text(
|
||
text=text,
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
|
||
|
||
@router.callback_query(AdminClusterCallback.filter(F.action == "sync"), IsAdminFilter())
|
||
async def handle_sync(
|
||
callback_query: types.CallbackQuery,
|
||
callback_data: AdminClusterCallback,
|
||
session: Any,
|
||
):
|
||
cluster_name = callback_data.data
|
||
|
||
servers = await get_servers(session)
|
||
cluster_servers = servers.get(cluster_name, [])
|
||
|
||
await callback_query.message.edit_text(
|
||
text=f"<b>🔄 Синхронизация кластера {cluster_name}</b>",
|
||
reply_markup=build_sync_cluster_kb(cluster_servers, cluster_name),
|
||
)
|
||
|
||
|
||
@router.callback_query(AdminClusterCallback.filter(F.action == "sync-server"), IsAdminFilter())
|
||
async def handle_sync_server(
|
||
callback_query: types.CallbackQuery,
|
||
callback_data: AdminClusterCallback,
|
||
session: AsyncSession,
|
||
):
|
||
server_name = callback_data.data
|
||
|
||
try:
|
||
server_result = await session.execute(
|
||
select(Server.cluster_name).where(Server.server_name == server_name).limit(1)
|
||
)
|
||
cluster_name = server_result.scalar()
|
||
|
||
if not cluster_name:
|
||
await callback_query.message.edit_text(
|
||
text=f"❌ Сервер {server_name} не найден.",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
return
|
||
|
||
use_country_selection = bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION))
|
||
|
||
if use_country_selection:
|
||
stmt = (
|
||
select(
|
||
Server.api_url,
|
||
Server.inbound_id,
|
||
Server.server_name,
|
||
Server.panel_type,
|
||
Key.user_id,
|
||
User.tg_id.label("owner_tg_id"),
|
||
Key.client_id,
|
||
Key.email,
|
||
Key.expiry_time,
|
||
Key.tariff_id,
|
||
Key.remnawave_link,
|
||
Key.selected_device_limit,
|
||
Key.selected_traffic_limit,
|
||
Key.current_device_limit,
|
||
Key.current_traffic_limit,
|
||
)
|
||
.join(Key, Server.server_name == Key.server_id)
|
||
.join(User, Key.user_id == User.id)
|
||
.where(Server.server_name == server_name)
|
||
)
|
||
else:
|
||
stmt = (
|
||
select(
|
||
Server.api_url,
|
||
Server.inbound_id,
|
||
Server.server_name,
|
||
Server.panel_type,
|
||
Key.user_id,
|
||
User.tg_id.label("owner_tg_id"),
|
||
Key.client_id,
|
||
Key.email,
|
||
Key.expiry_time,
|
||
Key.tariff_id,
|
||
Key.remnawave_link,
|
||
Key.selected_device_limit,
|
||
Key.selected_traffic_limit,
|
||
Key.current_device_limit,
|
||
Key.current_traffic_limit,
|
||
)
|
||
.join(Key, Server.cluster_name == Key.server_id)
|
||
.join(User, Key.user_id == User.id)
|
||
.where(Server.server_name == server_name)
|
||
)
|
||
|
||
result = await session.execute(stmt)
|
||
keys_to_sync = result.mappings().all()
|
||
|
||
if not keys_to_sync:
|
||
await callback_query.message.edit_text(
|
||
text=f"❌ Нет ключей для синхронизации в сервере {server_name}.",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
return
|
||
|
||
await callback_query.message.edit_text(
|
||
text=f"<b>🔄 Синхронизация сервера {server_name}</b>\n\n🔑 Количество ключей: <b>{len(keys_to_sync)}</b>"
|
||
)
|
||
|
||
all_servers = await get_servers(session)
|
||
cluster_servers = all_servers.get(cluster_name, [])
|
||
|
||
server_info = None
|
||
for s in cluster_servers:
|
||
if s.get("server_name") == server_name:
|
||
server_info = s
|
||
break
|
||
|
||
tariff_ids = {key["tariff_id"] for key in keys_to_sync if key["tariff_id"]}
|
||
tariffs_cache = {}
|
||
if tariff_ids:
|
||
tariffs_result = await session.execute(select(Tariff).where(Tariff.id.in_(tariff_ids)))
|
||
tariffs_list = tariffs_result.scalars().all()
|
||
tariffs_cache = {t.id: dict(t.__dict__) for t in tariffs_list}
|
||
|
||
semaphore = asyncio.Semaphore(2)
|
||
for key in keys_to_sync:
|
||
try:
|
||
if key["panel_type"] == "remnawave":
|
||
tariff = tariffs_cache.get(key["tariff_id"]) if key["tariff_id"] else None
|
||
|
||
if tariff and server_info:
|
||
subgroup = tariff.get("subgroup_title")
|
||
tid = key["tariff_id"]
|
||
has_new_binding = tid and tid in (server_info.get("tariff_ids") or [])
|
||
has_old_binding = subgroup and subgroup in (server_info.get("tariff_subgroups") or [])
|
||
has_any_binding = bool(server_info.get("tariff_ids") or server_info.get("tariff_subgroups"))
|
||
|
||
if has_any_binding and subgroup and not has_new_binding and not has_old_binding:
|
||
continue
|
||
|
||
if tariff.get("group_code") and tariff.get("group_code").lower() in ALLOWED_GROUP_CODES:
|
||
if tariff.get("group_code").lower() not in server_info.get("special_groups", []):
|
||
continue
|
||
|
||
expire_iso = (
|
||
datetime.utcfromtimestamp(key["expiry_time"] / 1000).replace(tzinfo=timezone.utc).isoformat()
|
||
)
|
||
|
||
remna = RemnawaveAPI(key["api_url"])
|
||
if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
|
||
logger.error(f"Не удалось авторизоваться в Remnawave для сервера {server_name}")
|
||
continue
|
||
|
||
traffic_limit_bytes = 0
|
||
hwid_limit = 0
|
||
|
||
current_device_limit_from_key = key.get("current_device_limit")
|
||
current_traffic_limit_gb_from_key = key.get("current_traffic_limit")
|
||
selected_device_limit_from_key = key.get("selected_device_limit")
|
||
selected_traffic_limit_gb_from_key = key.get("selected_traffic_limit")
|
||
|
||
if tariff:
|
||
if current_traffic_limit_gb_from_key is not None:
|
||
traffic_limit_bytes = int(current_traffic_limit_gb_from_key * 1024**3)
|
||
elif selected_traffic_limit_gb_from_key is not None:
|
||
traffic_limit_bytes = int(selected_traffic_limit_gb_from_key * 1024**3)
|
||
elif tariff.get("traffic_limit") is not None:
|
||
traffic_limit_bytes = int(tariff.get("traffic_limit") * 1024**3)
|
||
|
||
if current_device_limit_from_key is not None:
|
||
hwid_limit = int(current_device_limit_from_key)
|
||
elif selected_device_limit_from_key is not None:
|
||
hwid_limit = int(selected_device_limit_from_key)
|
||
else:
|
||
hwid_limit = tariff.get("device_limit")
|
||
|
||
success = await remna.update_user(
|
||
uuid=key["client_id"],
|
||
expire_at=expire_iso,
|
||
telegram_id=int(key.get("owner_tg_id") or 0),
|
||
email=f"{key['email']}@fake.local",
|
||
active_user_inbounds=[key["inbound_id"]],
|
||
traffic_limit_bytes=traffic_limit_bytes,
|
||
hwid_device_limit=hwid_limit,
|
||
)
|
||
|
||
if success:
|
||
try:
|
||
sub = await remna.get_subscription_by_username(key["email"])
|
||
if sub:
|
||
new_remnawave_link = sub.get("subscriptionUrl")
|
||
|
||
if new_remnawave_link:
|
||
key_value = await make_aggregated_link(
|
||
session=session,
|
||
cluster_all=cluster_servers,
|
||
cluster_id=cluster_name,
|
||
email=key["email"],
|
||
client_id=key["client_id"],
|
||
tg_id=key["user_id"],
|
||
remna_link_override=None,
|
||
plan=tariff,
|
||
)
|
||
|
||
await session.execute(
|
||
update(Key)
|
||
.where(Key.user_id == key["user_id"], Key.client_id == key["client_id"])
|
||
.values(remnawave_link=new_remnawave_link, key=key_value)
|
||
)
|
||
await session.commit()
|
||
logger.info(f"[Sync] Обновлена ссылка для {key['email']}: {new_remnawave_link}")
|
||
except Exception as e:
|
||
logger.warning(f"[Sync] Не удалось получить ссылку для {key['email']}: {e}")
|
||
|
||
if not success:
|
||
logger.warning("[Sync] ошибка обновления, пробуем пересоздать")
|
||
|
||
await delete_key_from_cluster(server_name, key["email"], key["client_id"], session)
|
||
|
||
await create_key_on_cluster(
|
||
cluster_id=server_name,
|
||
tg_id=key["user_id"],
|
||
client_id=key["client_id"],
|
||
email=key["email"],
|
||
expiry_timestamp=key["expiry_time"],
|
||
plan=key["tariff_id"],
|
||
session=session,
|
||
remnawave_link=key["remnawave_link"],
|
||
hwid_limit=hwid_limit,
|
||
traffic_limit_bytes=traffic_limit_bytes,
|
||
selected_device_limit=key.get("selected_device_limit"),
|
||
selected_traffic_limit_gb=key.get("selected_traffic_limit"),
|
||
current_device_limit=key.get("current_device_limit"),
|
||
current_traffic_limit_gb=key.get("current_traffic_limit"),
|
||
selected_price_rub=key.get("selected_price_rub"),
|
||
)
|
||
else:
|
||
await create_client_on_server(
|
||
{
|
||
"api_url": key["api_url"],
|
||
"inbound_id": key["inbound_id"],
|
||
"server_name": key["server_name"],
|
||
},
|
||
int(key.get("owner_tg_id") or 0) or key["user_id"],
|
||
key["client_id"],
|
||
key["email"],
|
||
key["expiry_time"],
|
||
semaphore,
|
||
plan=key["tariff_id"],
|
||
session=session,
|
||
)
|
||
await asyncio.sleep(0.6)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка при синхронизации ключа {key['client_id']} в сервер {server_name}: {e}")
|
||
|
||
await callback_query.message.edit_text(
|
||
text=f"✅ Ключи успешно синхронизированы для сервера {server_name}",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка синхронизации ключей для сервера {server_name}: {e}")
|
||
await callback_query.message.edit_text(
|
||
text=f"❌ Произошла ошибка при синхронизации: {e}",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
|
||
|
||
@router.callback_query(AdminClusterCallback.filter(F.action == "sync-cluster"), IsAdminFilter())
|
||
async def handle_sync_cluster(
|
||
callback_query: CallbackQuery,
|
||
callback_data: AdminClusterCallback,
|
||
session: AsyncSession,
|
||
):
|
||
cluster_name = callback_data.data
|
||
|
||
try:
|
||
servers = await get_servers(session)
|
||
cluster_servers = servers.get(cluster_name, [])
|
||
|
||
use_country_selection = bool(MODES_CONFIG.get("COUNTRY_SELECTION_ENABLED", USE_COUNTRY_SELECTION))
|
||
|
||
if use_country_selection:
|
||
server_names = [s.get("server_name") for s in cluster_servers if s.get("server_name")]
|
||
if not server_names:
|
||
await callback_query.message.edit_text(
|
||
text=f"❌ В кластере {cluster_name} нет серверов.",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
return
|
||
result = await session.execute(
|
||
select(
|
||
Key.user_id,
|
||
User.tg_id.label("owner_tg_id"),
|
||
Key.client_id,
|
||
Key.email,
|
||
Key.expiry_time,
|
||
Key.remnawave_link,
|
||
Key.tariff_id,
|
||
Key.server_id,
|
||
Key.selected_device_limit,
|
||
Key.selected_traffic_limit,
|
||
Key.current_device_limit,
|
||
Key.current_traffic_limit,
|
||
)
|
||
.join(User, Key.user_id == User.id)
|
||
.where(Key.server_id.in_(server_names), Key.is_frozen.is_(False))
|
||
)
|
||
else:
|
||
result = await session.execute(
|
||
select(
|
||
Key.user_id,
|
||
User.tg_id.label("owner_tg_id"),
|
||
Key.client_id,
|
||
Key.email,
|
||
Key.expiry_time,
|
||
Key.remnawave_link,
|
||
Key.tariff_id,
|
||
Key.server_id,
|
||
Key.selected_device_limit,
|
||
Key.selected_traffic_limit,
|
||
Key.current_device_limit,
|
||
Key.current_traffic_limit,
|
||
)
|
||
.join(User, Key.user_id == User.id)
|
||
.where(Key.server_id == cluster_name, Key.is_frozen.is_(False))
|
||
)
|
||
|
||
keys_to_sync = result.mappings().all()
|
||
|
||
if not keys_to_sync:
|
||
await callback_query.message.edit_text(
|
||
text=f"❌ Нет ключей для синхронизации в кластере {cluster_name}.",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
return
|
||
only_remnawave = all(s.get("panel_type") == "remnawave" for s in cluster_servers)
|
||
|
||
await callback_query.message.edit_text(
|
||
text=f"<b>🔄 Синхронизация кластера {cluster_name}</b>\n\n🔑 Количество ключей: <b>{len(keys_to_sync)}</b>"
|
||
)
|
||
|
||
tariff_ids = {key["tariff_id"] for key in keys_to_sync if key["tariff_id"]}
|
||
tariffs_cache = {}
|
||
if tariff_ids:
|
||
tariffs_result = await session.execute(select(Tariff).where(Tariff.id.in_(tariff_ids)))
|
||
tariffs_list = tariffs_result.scalars().all()
|
||
tariffs_cache = {t.id: dict(t.__dict__) for t in tariffs_list}
|
||
|
||
if only_remnawave:
|
||
batch_size = 250
|
||
total_keys = len(keys_to_sync)
|
||
processed_count = 0
|
||
|
||
for batch_start in range(0, total_keys, batch_size):
|
||
batch = keys_to_sync[batch_start : batch_start + batch_size]
|
||
batch_end = batch_start + len(batch)
|
||
logger.info(f"[Sync] Обработка батча {batch_start}-{batch_end} из {total_keys}")
|
||
|
||
async def update_remnawave_api(key):
|
||
try:
|
||
traffic_limit_bytes = 0
|
||
hwid_limit = 0
|
||
subgroup_title = None
|
||
tariff = tariffs_cache.get(key["tariff_id"]) if key["tariff_id"] else None
|
||
|
||
current_device_limit_from_key = key.get("current_device_limit")
|
||
current_traffic_limit_gb_from_key = key.get("current_traffic_limit")
|
||
selected_device_limit_from_key = key.get("selected_device_limit")
|
||
selected_traffic_limit_gb_from_key = key.get("selected_traffic_limit")
|
||
|
||
if tariff:
|
||
if current_traffic_limit_gb_from_key is not None:
|
||
traffic_limit_bytes = int(current_traffic_limit_gb_from_key * 1024**3)
|
||
elif selected_traffic_limit_gb_from_key is not None:
|
||
traffic_limit_bytes = int(selected_traffic_limit_gb_from_key * 1024**3)
|
||
elif tariff.get("traffic_limit") is not None:
|
||
traffic_limit_bytes = int(tariff.get("traffic_limit") * 1024**3)
|
||
else:
|
||
traffic_limit_bytes = 0
|
||
|
||
if current_device_limit_from_key is not None:
|
||
hwid_limit = int(current_device_limit_from_key)
|
||
elif selected_device_limit_from_key is not None:
|
||
hwid_limit = int(selected_device_limit_from_key)
|
||
else:
|
||
hwid_limit = tariff.get("device_limit")
|
||
|
||
subgroup_title = tariff.get("subgroup_title")
|
||
|
||
expire_iso = (
|
||
datetime.utcfromtimestamp(key["expiry_time"] / 1000)
|
||
.replace(tzinfo=timezone.utc)
|
||
.isoformat()
|
||
)
|
||
|
||
if use_country_selection:
|
||
user_server = None
|
||
for s in cluster_servers:
|
||
if s.get("server_name") == key["server_id"]:
|
||
user_server = s
|
||
break
|
||
|
||
if not user_server:
|
||
return {"key": key, "success": False, "error": "Server not found"}
|
||
|
||
remna = RemnawaveAPI(user_server["api_url"])
|
||
inbound_ids = [user_server["inbound_id"]] if user_server.get("inbound_id") else []
|
||
else:
|
||
remna = RemnawaveAPI(cluster_servers[0]["api_url"])
|
||
|
||
filtered_servers = cluster_servers
|
||
if subgroup_title or (tariff and tariff.get("id")):
|
||
tid = tariff.get("id") if tariff else None
|
||
filtered_servers = [
|
||
s
|
||
for s in cluster_servers
|
||
if (tid and tid in (s.get("tariff_ids") or []))
|
||
or (subgroup_title and subgroup_title in (s.get("tariff_subgroups") or []))
|
||
]
|
||
if not filtered_servers:
|
||
filtered_servers = cluster_servers
|
||
|
||
if tariff and tariff.get("group_code"):
|
||
group_code = tariff.get("group_code").lower()
|
||
if group_code in ALLOWED_GROUP_CODES:
|
||
special_filtered = [
|
||
s for s in filtered_servers if group_code in (s.get("special_groups") or [])
|
||
]
|
||
if special_filtered:
|
||
filtered_servers = special_filtered
|
||
|
||
inbound_ids = [s["inbound_id"] for s in filtered_servers if s.get("inbound_id")]
|
||
|
||
if not await remna.login(REMNAWAVE_LOGIN, REMNAWAVE_PASSWORD):
|
||
return {"key": key, "success": False, "error": "Login failed"}
|
||
|
||
success = await remna.update_user(
|
||
uuid=key["client_id"],
|
||
expire_at=expire_iso,
|
||
telegram_id=int(key.get("owner_tg_id") or 0),
|
||
email=f"{key['email']}@fake.local",
|
||
active_user_inbounds=inbound_ids,
|
||
traffic_limit_bytes=traffic_limit_bytes,
|
||
hwid_device_limit=hwid_limit,
|
||
)
|
||
|
||
if success:
|
||
sub = await remna.get_subscription_by_username(key["email"])
|
||
new_link = sub.get("subscriptionUrl") if sub else None
|
||
return {
|
||
"key": key,
|
||
"success": True,
|
||
"new_link": new_link,
|
||
"tariff": tariff,
|
||
"traffic_limit_bytes": traffic_limit_bytes,
|
||
"hwid_limit": hwid_limit,
|
||
}
|
||
else:
|
||
return {
|
||
"key": key,
|
||
"success": False,
|
||
"needs_recreate": True,
|
||
"tariff": tariff,
|
||
"traffic_limit_bytes": traffic_limit_bytes,
|
||
"hwid_limit": hwid_limit,
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Sync] Ошибка API для {key.get('email')}: {e}")
|
||
return {"key": key, "success": False, "error": str(e)}
|
||
|
||
tasks = [update_remnawave_api(key) for key in batch]
|
||
results = await asyncio.gather(*tasks, return_exceptions=True)
|
||
|
||
bulk_updates = []
|
||
recreate_tasks = []
|
||
|
||
for result in results:
|
||
if isinstance(result, Exception):
|
||
logger.error(f"[Sync] Exception в батче: {result}")
|
||
continue
|
||
|
||
if not isinstance(result, dict):
|
||
continue
|
||
|
||
key = result.get("key")
|
||
if not key:
|
||
continue
|
||
|
||
try:
|
||
if result.get("success") and result.get("new_link"):
|
||
new_link = result["new_link"]
|
||
tariff = result.get("tariff")
|
||
|
||
key_value = await make_aggregated_link(
|
||
session=session,
|
||
cluster_all=cluster_servers,
|
||
cluster_id=cluster_name,
|
||
email=key["email"],
|
||
client_id=key["client_id"],
|
||
tg_id=key["user_id"],
|
||
remna_link_override=None,
|
||
plan=tariff,
|
||
)
|
||
|
||
bulk_updates.append({
|
||
"client_id": key["client_id"],
|
||
"remnawave_link": new_link,
|
||
"key": key_value,
|
||
})
|
||
|
||
elif result.get("needs_recreate"):
|
||
recreate_tasks.append((key, result))
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Sync] Ошибка подготовки для {key.get('email')}: {e}")
|
||
|
||
if bulk_updates:
|
||
try:
|
||
await session.run_sync(
|
||
lambda sync_session: sync_session.bulk_update_mappings(Key, bulk_updates)
|
||
)
|
||
await session.commit()
|
||
logger.info(f"[Sync] Bulk: обновлено {len(bulk_updates)} ключей")
|
||
except Exception as bulk_error:
|
||
logger.warning(f"[Sync] Bulk упал, fallback: {bulk_error}")
|
||
await session.rollback()
|
||
|
||
for upd in bulk_updates:
|
||
try:
|
||
await session.execute(
|
||
update(Key)
|
||
.where(Key.client_id == upd["client_id"])
|
||
.values(remnawave_link=upd["remnawave_link"], key=upd["key"])
|
||
)
|
||
await session.commit()
|
||
except Exception as e:
|
||
logger.error(f"[Sync] Fallback ошибка {upd['client_id']}: {e}")
|
||
await session.rollback()
|
||
|
||
for key, result in recreate_tasks:
|
||
try:
|
||
logger.warning(f"[Sync] Пересоздание {key['email']}")
|
||
await delete_key_from_cluster(cluster_name, key["email"], key["client_id"], session)
|
||
await session.execute(
|
||
delete(Key).where(Key.user_id == key["user_id"], Key.client_id == key["client_id"])
|
||
)
|
||
await session.commit()
|
||
|
||
cluster_id_for_recreate = key["server_id"] if use_country_selection else cluster_name
|
||
await create_key_on_cluster(
|
||
cluster_id_for_recreate,
|
||
key["user_id"],
|
||
key["client_id"],
|
||
key["email"],
|
||
key["expiry_time"],
|
||
plan=key["tariff_id"],
|
||
session=session,
|
||
remnawave_link=key["remnawave_link"],
|
||
hwid_limit=result.get("hwid_limit"),
|
||
traffic_limit_bytes=result.get("traffic_limit_bytes"),
|
||
selected_device_limit=key.get("selected_device_limit"),
|
||
selected_traffic_limit_gb=key.get("selected_traffic_limit"),
|
||
current_device_limit=key.get("current_device_limit"),
|
||
current_traffic_limit_gb=key.get("current_traffic_limit"),
|
||
selected_price_rub=key.get("selected_price_rub"),
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"[Sync] Пересоздание ошибка {key.get('email')}: {e}")
|
||
|
||
processed_count = batch_end
|
||
progress_percent = int((processed_count / total_keys) * 100)
|
||
progress_bar = "█" * (progress_percent // 5) + "░" * (20 - progress_percent // 5)
|
||
|
||
try:
|
||
await callback_query.message.edit_text(
|
||
text=(
|
||
f"<b>🔄 Синхронизация кластера {cluster_name}</b>\n\n"
|
||
f"🔑 Количество ключей: <b>{total_keys}</b>\n\n"
|
||
f"Обработано: <b>{processed_count}/{total_keys}</b>\n"
|
||
f"<code>{progress_bar}</code>"
|
||
)
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
else:
|
||
for key in keys_to_sync:
|
||
try:
|
||
traffic_limit_bytes = 0
|
||
hwid_limit = 0
|
||
tariff = tariffs_cache.get(key["tariff_id"]) if key["tariff_id"] else None
|
||
|
||
current_device_limit_from_key = key.get("current_device_limit")
|
||
current_traffic_limit_gb_from_key = key.get("current_traffic_limit")
|
||
selected_device_limit_from_key = key.get("selected_device_limit")
|
||
selected_traffic_limit_gb_from_key = key.get("selected_traffic_limit")
|
||
|
||
if tariff:
|
||
if current_traffic_limit_gb_from_key is not None:
|
||
traffic_limit_bytes = int(current_traffic_limit_gb_from_key * 1024**3)
|
||
elif selected_traffic_limit_gb_from_key is not None:
|
||
traffic_limit_bytes = int(selected_traffic_limit_gb_from_key * 1024**3)
|
||
elif tariff.get("traffic_limit") is not None:
|
||
traffic_limit_bytes = int(tariff.get("traffic_limit") * 1024**3)
|
||
else:
|
||
traffic_limit_bytes = 0
|
||
|
||
if current_device_limit_from_key is not None:
|
||
hwid_limit = int(current_device_limit_from_key)
|
||
elif selected_device_limit_from_key is not None:
|
||
hwid_limit = int(selected_device_limit_from_key)
|
||
else:
|
||
hwid_limit = tariff.get("device_limit")
|
||
|
||
tariff.get("subgroup_title")
|
||
elif key["tariff_id"]:
|
||
logger.warning(
|
||
f"[Sync] Ключ {key['client_id']} с несуществующим тарифом ID={key['tariff_id']} — "
|
||
f"обновим без лимитов"
|
||
)
|
||
|
||
await delete_key_from_cluster(cluster_name, key["email"], key["client_id"], session)
|
||
|
||
await session.execute(
|
||
delete(Key).where(Key.user_id == key["user_id"], Key.client_id == key["client_id"])
|
||
)
|
||
|
||
cluster_id_for_recreate = key["server_id"] if use_country_selection else cluster_name
|
||
await create_key_on_cluster(
|
||
cluster_id_for_recreate,
|
||
key["user_id"],
|
||
key["client_id"],
|
||
key["email"],
|
||
key["expiry_time"],
|
||
plan=key["tariff_id"],
|
||
session=session,
|
||
remnawave_link=key["remnawave_link"],
|
||
hwid_limit=hwid_limit,
|
||
traffic_limit_bytes=traffic_limit_bytes,
|
||
selected_device_limit=key.get("selected_device_limit"),
|
||
selected_traffic_limit_gb=key.get("selected_traffic_limit"),
|
||
current_device_limit=key.get("current_device_limit"),
|
||
current_traffic_limit_gb=key.get("current_traffic_limit"),
|
||
selected_price_rub=key.get("selected_price_rub"),
|
||
)
|
||
|
||
await asyncio.sleep(0.5)
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Sync] Ошибка при обработке ключа {key['client_id']} в {cluster_name}: {e}")
|
||
|
||
await callback_query.message.edit_text(
|
||
text=(
|
||
f"✅ <b>Синхронизация завершена</b>\n\n"
|
||
f"📊 Кластер: <b>{cluster_name}</b>\n"
|
||
f"🔑 Обработано ключей: <b>{len(keys_to_sync)}</b>"
|
||
),
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|
||
|
||
except Exception as e:
|
||
logger.error(f"[Sync] Ошибка синхронизации кластера {cluster_name}: {e}")
|
||
await callback_query.message.edit_text(
|
||
text=f"❌ Произошла ошибка при синхронизации: {e}",
|
||
reply_markup=build_admin_back_kb("clusters"),
|
||
)
|