445 lines
16 KiB
Python
445 lines
16 KiB
Python
"""
|
|
Cliente HTTP para PANEL_BASES_ANEXO24.
|
|
|
|
Cada base de datos está asignada en el PANEL a un servidor de restauración
|
|
(registrado en restore_targets). CloudRestoreAS, tras resolver el db_name del archivo, pregunta
|
|
al PANEL (polling) qué servidor corresponde a ESA base y restaura ahí; al terminar,
|
|
reporta el resultado del job.
|
|
|
|
Política ante fallo (G8/G9): si el PANEL no responde o la base no tiene servidor
|
|
asignado, get_target_for_database devuelve None y el worker deja el job en cola para
|
|
reintentar; nunca se restaura con datos inciertos.
|
|
"""
|
|
|
|
import os
|
|
from typing import Optional
|
|
from urllib.parse import urlparse, quote
|
|
|
|
import requests
|
|
|
|
from ..utils.logger import app_logger
|
|
|
|
# Timeout (connect, read) en segundos para las llamadas al PANEL.
|
|
DEFAULT_TIMEOUT = (5, 10)
|
|
|
|
|
|
def _http_verify(verify_ssl: Optional[bool] = None) -> bool:
|
|
"""Verificación TLS para requests. Por defecto False (panel dev con cert propio)."""
|
|
if verify_ssl is not None:
|
|
return verify_ssl
|
|
env = os.getenv("CLOUDRESTORE_PANEL_VERIFY_SSL", "").strip().lower()
|
|
if env in ("1", "true", "yes"):
|
|
return True
|
|
if env in ("0", "false", "no"):
|
|
return False
|
|
return False
|
|
|
|
# Campos obligatorios del servidor devuelto por el endpoint (modo hub central + SFTP).
|
|
REQUIRED_TARGET_FIELDS = (
|
|
"server",
|
|
"username",
|
|
"password",
|
|
"data_folder",
|
|
"ssh_host",
|
|
"ssh_username",
|
|
"ssh_password",
|
|
"remote_inbox_path",
|
|
)
|
|
|
|
# Modo colocado (CRA en el mismo servidor): solo credenciales SQL locales.
|
|
REQUIRED_COLOCATED_TARGET_FIELDS = (
|
|
"name",
|
|
"server",
|
|
"username",
|
|
"password",
|
|
"data_folder",
|
|
)
|
|
|
|
# Reenvío de ZIP por SFTP al input_folder del destino.
|
|
REQUIRED_FORWARD_TARGET_FIELDS = (
|
|
"name",
|
|
"ssh_host",
|
|
"ssh_username",
|
|
"ssh_password",
|
|
"input_folder",
|
|
)
|
|
|
|
|
|
def _normalize_base_url(api_url: str) -> Optional[str]:
|
|
"""Valida y normaliza la URL base del PANEL. Devuelve None si es inválida."""
|
|
if not api_url or not api_url.strip():
|
|
return None
|
|
base = api_url.strip().rstrip("/")
|
|
parsed = urlparse(base)
|
|
# Solo http/https; evita esquemas peligrosos (file://, etc.)
|
|
if parsed.scheme not in ("http", "https") or not parsed.netloc:
|
|
app_logger.error(f"URL de PANEL inválida (esquema/host): {api_url}")
|
|
return None
|
|
return base
|
|
|
|
|
|
def _validate_target(data: dict, *, colocated: bool = False) -> bool:
|
|
"""Verifica que el servidor devuelto tenga todos los campos requeridos no vacíos."""
|
|
fields = REQUIRED_COLOCATED_TARGET_FIELDS if colocated else REQUIRED_TARGET_FIELDS
|
|
for field in fields:
|
|
value = data.get(field)
|
|
if value is None or (isinstance(value, str) and not value.strip()):
|
|
app_logger.error(f"Servidor del PANEL sin campo requerido: '{field}'")
|
|
return False
|
|
return True
|
|
|
|
|
|
def get_target_for_database(
|
|
api_url: str,
|
|
api_token: str,
|
|
db_name: str,
|
|
instance_key: Optional[str] = None,
|
|
) -> Optional[dict]:
|
|
"""
|
|
Consulta GET /api/restore/target-for?database=<db_name>: el servidor de
|
|
restauración asignado a esa base de datos.
|
|
|
|
Returns:
|
|
dict con id, name, server, username, password, data_folder, ssh_host,
|
|
ssh_port, ssh_username, ssh_password, remote_inbox_path si la base tiene
|
|
servidor asignado; None si no tiene asignación, el PANEL no responde o la
|
|
config es inválida.
|
|
"""
|
|
base = _normalize_base_url(api_url)
|
|
if base is None:
|
|
return None
|
|
if not api_token or not api_token.strip():
|
|
app_logger.error("Token de PANEL no configurado; no se puede consultar el servidor de la base")
|
|
return None
|
|
if not db_name or not db_name.strip():
|
|
app_logger.error("db_name vacío; no se puede consultar el servidor de la base")
|
|
return None
|
|
|
|
colocated = bool(instance_key and instance_key.strip())
|
|
url = f"{base}/api/restore/target-for?database={quote(db_name.strip())}"
|
|
if colocated:
|
|
url += f"&instance={quote(instance_key.strip())}"
|
|
headers = {"Authorization": f"Bearer {api_token.strip()}"}
|
|
|
|
try:
|
|
resp = requests.get(
|
|
url, headers=headers, timeout=DEFAULT_TIMEOUT, verify=_http_verify()
|
|
)
|
|
except requests.exceptions.RequestException as e:
|
|
app_logger.error(f"PANEL no accesible al consultar servidor de la base '{db_name}': {e}")
|
|
return None
|
|
|
|
if resp.status_code == 404:
|
|
app_logger.warning(f"La base '{db_name}' no tiene servidor de restauración asignado en el PANEL")
|
|
return None
|
|
if resp.status_code == 401:
|
|
app_logger.error("PANEL rechazó el token de CloudRestoreAS (401)")
|
|
return None
|
|
if resp.status_code != 200:
|
|
app_logger.error(f"PANEL respondió {resp.status_code} al consultar servidor de la base")
|
|
return None
|
|
|
|
try:
|
|
data = resp.json()
|
|
except ValueError:
|
|
app_logger.error("Respuesta del PANEL no es JSON válido")
|
|
return None
|
|
|
|
if not _validate_target(data, colocated=colocated):
|
|
return None
|
|
|
|
name = data.get("name") or data.get("server")
|
|
app_logger.info(f"Servidor para la base '{db_name}': {name} ({data.get('server')})")
|
|
return data
|
|
|
|
|
|
def list_restore_target_names(api_url: str, api_token: str) -> list[str]:
|
|
"""
|
|
Consulta GET /api/restore/target-catalog: nombres de servidores de restauración
|
|
registrados en el panel (para llenar el selector de instancia).
|
|
|
|
Returns:
|
|
Lista de nombres; lista vacía si falla la conexión, el token es inválido o la
|
|
respuesta no es válida.
|
|
"""
|
|
base = _normalize_base_url(api_url)
|
|
if base is None:
|
|
return []
|
|
if not api_token or not api_token.strip():
|
|
app_logger.error("Token de PANEL no configurado; no se puede consultar el catálogo")
|
|
return []
|
|
|
|
url = f"{base}/api/restore/target-catalog"
|
|
headers = {"Authorization": f"Bearer {api_token.strip()}"}
|
|
|
|
try:
|
|
resp = requests.get(
|
|
url, headers=headers, timeout=DEFAULT_TIMEOUT, verify=_http_verify()
|
|
)
|
|
except requests.exceptions.RequestException as e:
|
|
app_logger.error(f"PANEL no accesible al consultar catálogo de servidores: {e}")
|
|
return []
|
|
|
|
if resp.status_code == 401:
|
|
app_logger.error("PANEL rechazó el token de CloudRestoreAS (401) al consultar catálogo")
|
|
return []
|
|
if resp.status_code != 200:
|
|
app_logger.error(f"PANEL respondió {resp.status_code} al consultar catálogo de servidores")
|
|
return []
|
|
|
|
try:
|
|
data = resp.json()
|
|
except ValueError:
|
|
app_logger.error("Respuesta del PANEL (target-catalog) no es JSON válido")
|
|
return []
|
|
|
|
targets = data.get("targets")
|
|
if not isinstance(targets, list):
|
|
app_logger.error("Respuesta del PANEL (target-catalog) sin lista 'targets'")
|
|
return []
|
|
|
|
names: list[str] = []
|
|
for item in targets:
|
|
if isinstance(item, dict):
|
|
name = item.get("name")
|
|
if isinstance(name, str) and name.strip():
|
|
names.append(name.strip())
|
|
return names
|
|
|
|
|
|
def resolve_route(
|
|
api_url: str,
|
|
api_token: str,
|
|
filename: str,
|
|
instance_key: Optional[str] = None,
|
|
) -> Optional[dict]:
|
|
"""
|
|
Consulta GET /api/restore/resolve-route: resuelve nodo/destino desde el nombre
|
|
del archivo y devuelve action (restore_local | forward) más target completo.
|
|
|
|
Returns:
|
|
dict con action, db_name, node_key, target; None si el panel no responde,
|
|
token inválido o la respuesta no cumple el contrato.
|
|
"""
|
|
base = _normalize_base_url(api_url)
|
|
if base is None:
|
|
return None
|
|
if not api_token or not api_token.strip():
|
|
app_logger.error("Token de PANEL no configurado; no se puede resolver ruta")
|
|
return None
|
|
if not filename or not filename.strip():
|
|
app_logger.error("filename vacío; no se puede resolver ruta")
|
|
return None
|
|
|
|
url = f"{base}/api/restore/resolve-route?filename={quote(filename.strip())}"
|
|
key = (instance_key or "").strip()
|
|
if key:
|
|
url += f"&instance={quote(key)}"
|
|
headers = {"Authorization": f"Bearer {api_token.strip()}"}
|
|
|
|
try:
|
|
resp = requests.get(
|
|
url, headers=headers, timeout=DEFAULT_TIMEOUT, verify=_http_verify()
|
|
)
|
|
except requests.exceptions.RequestException as e:
|
|
app_logger.error(f"PANEL no accesible al resolver ruta para '{filename}': {e}")
|
|
return None
|
|
|
|
if resp.status_code == 404:
|
|
app_logger.warning(f"El archivo '{filename}' no tiene nodo/base asignado en el PANEL")
|
|
return None
|
|
if resp.status_code == 503:
|
|
app_logger.warning(
|
|
f"Destino aún sin carpeta de entrada reportada para '{filename}'"
|
|
)
|
|
return None
|
|
if resp.status_code == 401:
|
|
app_logger.error("PANEL rechazó el token de CloudRestoreAS (401) al resolver ruta")
|
|
return None
|
|
if resp.status_code != 200:
|
|
app_logger.error(f"PANEL respondió {resp.status_code} al resolver ruta")
|
|
return None
|
|
|
|
try:
|
|
data = resp.json()
|
|
except ValueError:
|
|
app_logger.error("Respuesta del PANEL (resolve-route) no es JSON válido")
|
|
return None
|
|
|
|
action = data.get("action")
|
|
target = data.get("target")
|
|
db_name = data.get("db_name")
|
|
if action not in ("restore_local", "forward") or not isinstance(target, dict):
|
|
app_logger.error("Respuesta del PANEL (resolve-route) con action o target inválidos")
|
|
return None
|
|
if not isinstance(db_name, str) or not db_name.strip():
|
|
app_logger.error("Respuesta del PANEL (resolve-route) sin db_name válido")
|
|
return None
|
|
|
|
if action == "restore_local":
|
|
if not _validate_target(target, colocated=True):
|
|
return None
|
|
elif not _validate_target_fields(target, REQUIRED_FORWARD_TARGET_FIELDS):
|
|
return None
|
|
|
|
app_logger.info(
|
|
f"Ruta para '{filename}': action={action}, destino={target.get('name')}, db={db_name}"
|
|
)
|
|
return data
|
|
|
|
|
|
def _validate_target_fields(data: dict, fields: tuple) -> bool:
|
|
"""Verifica campos requeridos no vacíos (lista explícita)."""
|
|
for field in fields:
|
|
value = data.get(field)
|
|
if value is None or (isinstance(value, str) and not value.strip()):
|
|
app_logger.error(f"Servidor del PANEL sin campo requerido para forward: '{field}'")
|
|
return False
|
|
return True
|
|
|
|
|
|
def report_instance_config(
|
|
api_url: str,
|
|
api_token: str,
|
|
input_folder: str,
|
|
host_name: Optional[str] = None,
|
|
app_version: Optional[str] = None,
|
|
instance_key: Optional[str] = None,
|
|
processed_folder: Optional[str] = None,
|
|
platform_name: Optional[str] = None,
|
|
arch: Optional[str] = None,
|
|
install_path: Optional[str] = None,
|
|
) -> bool:
|
|
"""
|
|
Reporta la carpeta de entrada vigente a POST /api/restore/instance-config (best-effort).
|
|
El panel solo la muestra; CloudRestoreAS es la única fuente de escritura.
|
|
|
|
platform_name y arch identifican el build de ESTA instalación ("windows"/"linux",
|
|
"x86_64"/"arm64"). El PANEL los usa para saber qué artefacto le toca a este servidor
|
|
cuando instala o actualiza; sin ellos cae al texto libre de restore_targets.os.
|
|
|
|
install_path es la carpeta donde vive el ejecutable (APP_DIR). Es un espacio de rutas
|
|
DISTINTO de input_folder: ahí abajo está config/.env con las rutas de trabajo que el
|
|
operador haya personalizado. El PANEL la necesita para actualizar en el lugar correcto
|
|
en vez de crear una segunda instalación con la configuración por omisión.
|
|
|
|
Returns:
|
|
True si el PANEL aceptó el reporte (200), False en cualquier otro caso.
|
|
"""
|
|
base = _normalize_base_url(api_url)
|
|
if base is None or not api_token or not api_token.strip():
|
|
return False
|
|
if not input_folder or not input_folder.strip():
|
|
app_logger.warning("input_folder vacío; no se reporta al PANEL")
|
|
return False
|
|
|
|
url = f"{base}/api/restore/instance-config"
|
|
headers = {"Authorization": f"Bearer {api_token.strip()}"}
|
|
key = (instance_key or "").strip() or None
|
|
payload = {
|
|
"input_folder": input_folder.strip(),
|
|
"processed_folder": (processed_folder or "").strip() or None,
|
|
"host_name": (host_name or "").strip() or None,
|
|
"app_version": (app_version or "").strip() or None,
|
|
"platform": (platform_name or "").strip() or None,
|
|
"arch": (arch or "").strip() or None,
|
|
"install_path": (install_path or "").strip() or None,
|
|
}
|
|
if key:
|
|
payload["instance_key"] = key
|
|
|
|
try:
|
|
resp = requests.post(
|
|
url, json=payload, headers=headers, timeout=DEFAULT_TIMEOUT, verify=_http_verify()
|
|
)
|
|
except requests.exceptions.RequestException as e:
|
|
app_logger.error(f"No se pudo reportar la carpeta de entrada al PANEL: {e}")
|
|
return False
|
|
|
|
if resp.status_code == 200:
|
|
app_logger.info(f"Carpeta de entrada reportada al PANEL: {input_folder.strip()}")
|
|
return True
|
|
app_logger.error(
|
|
f"PANEL respondió {resp.status_code} al reportar la carpeta de entrada"
|
|
)
|
|
return False
|
|
|
|
|
|
def report_job_result(
|
|
api_url: str,
|
|
api_token: str,
|
|
filename: str,
|
|
status: str,
|
|
restore_target_id: Optional[int] = None,
|
|
db_name: Optional[str] = None,
|
|
duration_ms: Optional[int] = None,
|
|
error_message: Optional[str] = None,
|
|
) -> bool:
|
|
"""
|
|
Reporta el resultado de un job a POST /api/restore/job-result (best-effort).
|
|
No lanza excepciones: un fallo aquí no debe romper el flujo de restauración.
|
|
|
|
Returns:
|
|
True si el PANEL aceptó el reporte (201), False en cualquier otro caso.
|
|
"""
|
|
base = _normalize_base_url(api_url)
|
|
if base is None or not api_token or not api_token.strip():
|
|
return False
|
|
|
|
url = f"{base}/api/restore/job-result"
|
|
headers = {"Authorization": f"Bearer {api_token.strip()}"}
|
|
payload = {
|
|
"filename": filename,
|
|
"restore_target_id": restore_target_id,
|
|
"db_name": db_name,
|
|
"status": status,
|
|
"duration_ms": duration_ms,
|
|
"error_message": error_message,
|
|
}
|
|
|
|
try:
|
|
resp = requests.post(
|
|
url, json=payload, headers=headers, timeout=DEFAULT_TIMEOUT, verify=_http_verify()
|
|
)
|
|
except requests.exceptions.RequestException as e:
|
|
app_logger.error(f"No se pudo reportar el resultado del job al PANEL: {e}")
|
|
return False
|
|
|
|
if resp.status_code == 201:
|
|
return True
|
|
app_logger.error(f"PANEL respondió {resp.status_code} al reportar el resultado del job")
|
|
return False
|
|
|
|
|
|
def test_connection(api_url: str, api_token: str) -> tuple[bool, Optional[str]]:
|
|
"""
|
|
Prueba conectividad y autenticación contra el PANEL para la UI de configuración.
|
|
Consulta /target-for con un nombre de base inexistente: un 404 confirma que el
|
|
PANEL responde y el token es válido (la base simplemente no existe).
|
|
|
|
Returns:
|
|
(True, mensaje) si el PANEL responde y el token es aceptado;
|
|
(False, "mensaje de error") si no se pudo conectar o el token fue rechazado.
|
|
"""
|
|
base = _normalize_base_url(api_url)
|
|
if base is None:
|
|
return False, "URL de PANEL inválida (debe iniciar con http:// o https://)"
|
|
if not api_token or not api_token.strip():
|
|
return False, "Falta el token de API del PANEL"
|
|
|
|
url = f"{base}/api/restore/target-for?database={quote('__cloudrestore_ping__')}"
|
|
headers = {"Authorization": f"Bearer {api_token.strip()}"}
|
|
try:
|
|
resp = requests.get(
|
|
url, headers=headers, timeout=DEFAULT_TIMEOUT, verify=_http_verify()
|
|
)
|
|
except requests.exceptions.RequestException as e:
|
|
return False, f"No se pudo conectar al PANEL: {e}"
|
|
|
|
# 200 (base de ping existiera) o 404 (no existe) → conexión y token OK.
|
|
if resp.status_code in (200, 404):
|
|
return True, "Conexión y token correctos"
|
|
if resp.status_code == 401:
|
|
return False, "Token rechazado por el PANEL (401)"
|
|
return False, f"El PANEL respondió con código {resp.status_code}"
|