From 0c14f1166baddfa4a8ca542d6753b193772ca6f7 Mon Sep 17 00:00:00 2001 From: hreyes Date: Wed, 1 Jul 2026 10:33:05 -0600 Subject: [PATCH] feature/generador-instaladores-linux-windows --- BUILD.md | 191 +++++++++++++++++++++ README.md | 44 +++-- app/config/bootstrap.py | 30 +++- app/config/odbc_setup.py | 21 ++- app/sql/sql_manager.py | 30 +++- app/ui/config_tab.py | 43 +++-- app/ui/logs_tab.py | 10 +- build-all.sh | 131 ++++++++++++++ install.sh | 103 +++++++++++ packaging/CloudRestoreAS.spec | 11 ++ packaging/LEEME.txt | 24 ++- packaging/linux/cloudrestoreas.service | 19 ++ packaging/scripts/build-all.sh | 34 +--- packaging/scripts/docker-build-linux.sh | 15 +- packaging/scripts/download-bundled-deps.sh | 116 ++++++++++++- packaging/scripts/package-release.sh | 36 +++- runner.py | 34 +++- 17 files changed, 802 insertions(+), 90 deletions(-) create mode 100644 BUILD.md create mode 100755 build-all.sh create mode 100755 install.sh create mode 100644 packaging/linux/cloudrestoreas.service mode change 100644 => 100755 packaging/scripts/build-all.sh mode change 100644 => 100755 packaging/scripts/package-release.sh diff --git a/BUILD.md b/BUILD.md new file mode 100644 index 0000000..d3d543c --- /dev/null +++ b/BUILD.md @@ -0,0 +1,191 @@ +# BUILD.md — Compilación, empaquetado y despliegue + +Referencia de **todos** los comandos, ejecutables y scripts para generar, empaquetar, +instalar y verificar CloudRestoreAS en Windows y Linux. + +El ejecutable es **autocontenido**: no requiere Python, 7-Zip, driver ODBC ni librerías +Qt instaladas en el equipo destino. Todo se embebe dentro del binario en tiempo de build. + +--- + +## 1. Todo en una tarea (recomendado) — `build-all.sh` + +Orquestador único. **Se ejecuta desde WSL** (bash). Genera Windows + Linux + los paquetes. + +```bash +./build-all.sh # Windows + Linux + dist/release/*.tar.gz y *.zip +./build-all.sh --linux-only # solo Linux (Docker) +./build-all.sh --windows-only # solo Windows (PowerShell + build.ps1) +./build-all.sh --no-package # compila sin generar .tar.gz/.zip +./build-all.sh --clean # rebuild desde cero (borra venvs, bundled, dist) +./build-all.sh --help +``` + +**Requisitos:** +- Linux: **Docker** (usa `docker-build-linux.sh` en ubuntu:22.04). +- Windows: **`powershell.exe`** accesible desde WSL + **Python 3.11+** instalado en Windows + (`build.ps1` lo auto-detecta en `%LOCALAPPDATA%\Programs\Python\Python31X`). +- Es *fail-soft*: si no hay `powershell.exe`, compila solo Linux y avisa. + +> El build de Windows se hace sobre la ruta `\\wsl.localhost\...`, por eso tarda +> (~15-18 min: pip install de PySide6 + PyInstaller). El de Linux (Docker, con deps +> cacheadas) es rápido. + +`packaging/scripts/build-all.sh` es un wrapper que delega en este mismo script. + +--- + +## 2. Builds individuales + +| Objetivo | Comando | Salida | Notas | +|---|---|---|---| +| **Linux (Docker, recomendado)** | `bash packaging/scripts/docker-build-linux.sh` | `dist/CloudRestoreAS` | ubuntu:22.04 con todas las deps + `patchelf`; garantiza autocontención | +| **Linux (host)** | `./build.sh` | `dist/CloudRestoreAS` | Requiere que el host tenga las libs Qt/ODBC; usar solo si no hay Docker | +| **Windows** | `.\build.ps1` (en Windows/PowerShell) | `dist\CloudRestoreAS.exe` | Auto-detecta Python 3.11+; crea `venv-windows` | + +Ambos usan el mismo spec: [packaging/CloudRestoreAS.spec](packaging/CloudRestoreAS.spec) (PyInstaller **onefile**, `console=False`). + +--- + +## 3. Dependencias embebidas (build-time) + +Se descargan e integran al binario. No se instalan en el destino. + +| Script | Qué embebe | +|---|---| +| `packaging/scripts/download-bundled-deps.sh` (Linux) | `7zz` (7-Zip Linux), driver **MS ODBC 18** + unixODBC + Kerberos/GSSAPI + libltdl + OpenSSL, y cluster **Qt xcb/X11 + EGL**. Aplica `patchelf --set-rpath '$ORIGIN'` a las `.so` del cluster ODBC para que resuelvan entre sí. | +| `packaging/scripts/download-bundled-deps.ps1` (Windows) | `7z.exe` y `msodbcsql18.dll`. | + +Versiones/URLs en [packaging/bundled-versions.json](packaging/bundled-versions.json). +Los binarios quedan en `packaging/bundled/{linux,windows}/` (git-ignored, se generan en el build). + +**Ubicación en runtime** (creada por el bootstrap en la primera ejecución): +- `config/7zip/7zz` — extractor. +- `config/odbc/lib/` — driver ODBC + toda su cadena (resuelven por `$ORIGIN`). +- Cluster Qt xcb/EGL — dentro del onefile, en `PySide6/Qt/lib`. + +--- + +## 4. Empaquetado — `package-release.sh` + +```bash +bash packaging/scripts/package-release.sh +``` + +Genera en `dist/release/`: + +| Archivo | Contenido | +|---|---| +| `CloudRestoreAS-linux.tar.gz` | `CloudRestoreAS/` → binario + `install.sh` + `packaging/linux/cloudrestoreas.service` + `LEEME.txt` | +| `CloudRestoreAS-win.zip` | `CloudRestoreAS/` → `CloudRestoreAS.exe` + `install.ps1` + `LEEME.txt` | + +--- + +## 5. Instalación / despliegue + +### Linux — `install.sh` (no instala nada del sistema) + +```bash +tar xzf CloudRestoreAS-linux.tar.gz && cd CloudRestoreAS + +sudo ./install.sh --service # servicio systemd 24/7 headless (recomendado en servidor) + ./install.sh --desktop # autostart .desktop (requiere sesión gráfica) + ./install.sh # solo instala + bootstrap; lo corres a mano + ./install.sh --help +``` +Variables: `PREFIX=/opt/cloudrestoreas` (destino), `SERVICE_USER=` (usuario del servicio). + +Servicio systemd: +```bash +systemctl status cloudrestoreas +journalctl -u cloudrestoreas -f +sudo systemctl restart cloudrestoreas # tras editar config/.env +``` + +### Windows + +Copiar `CloudRestoreAS.exe` a una carpeta y ejecutarlo (o usar `install.ps1`). Al iniciar +crea `config/` y un icono en la bandeja. Ver [packaging/LEEME.txt](packaging/LEEME.txt). + +--- + +## 6. Ejecución manual y flags del binario + +```bash +# Linux servidor sin pantalla (headless): motor de restauración sin GUI +QT_QPA_PLATFORM=offscreen ./CloudRestoreAS --start-engine --headless + +# Linux con escritorio o Windows: abre la GUI normal +./CloudRestoreAS +``` + +| Flag / variable | Efecto | +|---|---| +| `--start-engine` | Inicia el motor de restauración al arrancar | +| `--headless` | Fuerza modo sin interfaz (Qt `offscreen`), para servidores sin display | +| `--minimized` | Inicia minimizado en la bandeja | +| `QT_QPA_PLATFORM=offscreen` | Plataforma Qt sin display (el binario ya cae a esto automáticamente si no hay `DISPLAY`/`WAYLAND_DISPLAY` en Linux) | + +En Linux sin `DISPLAY`, el binario selecciona `offscreen` **solo**; con display usa `xcb`. + +--- + +## 7. Configuración (primera ejecución) + +El binario crea automáticamente: `config/`, `config/.env`, `Entrada/`, `Procesados/`, +`Fallados/`, `Temp/`. Editar `config/.env`: + +``` +CLOUDRESTORE_AUTO_START=true # el motor arranca solo +CLOUDRESTORE_PANEL_API_URL=... # servicio PANEL_BASES_ANEXO24 (enrutamiento) +CLOUDRESTORE_PANEL_API_TOKEN=... +CLOUDRESTORE_PANEL_INSTANCE_KEY=... +``` +El PANEL entrega el servidor SQL destino y su `data_folder`. Con SQL Server sobre Linux +serán rutas POSIX (p. ej. `/var/opt/mssql/data`); el `RESTORE ... MOVE` adapta el separador +automáticamente según el formato del `data_folder`. + +--- + +## 8. Verificación de autocontención (contenedor pelado) + +Confirma que el binario Linux corre sin instalar NADA del sistema: + +```bash +docker run --rm -v "$PWD/dist:/dist:ro" debian:12-slim bash -c ' + cp /dist/CloudRestoreAS /root/app && cd /root + QT_QPA_PLATFORM=offscreen timeout 12 ./app --headless --start-engine 2>&1 | \ + grep -iE "offscreen|Ventana principal|Traceback|platform plugin" + # ODBC: driver + cadena resuelven por $ORIGIN (debe dar 0) + ldd /root/config/odbc/lib/libmsodbcsql-18*.so* 2>&1 | grep -c "not found" + # 7-Zip embebido + /root/config/7zip/7zz | head -1 +' +``` +Esperado: arranca en `offscreen` sin errores Qt, `0` deps ODBC faltantes, `7zz` ejecuta. + +--- + +## 9. Artefactos y ubicaciones + +| Ruta | Qué es | +|---|---| +| `dist/CloudRestoreAS` | Binario Linux onefile | +| `dist/CloudRestoreAS.exe` | Ejecutable Windows onefile | +| `dist/release/*.tar.gz` / `*.zip` | Paquetes de despliegue (binario + instalador + docs) | +| `packaging/bundled/{linux,windows}/` | Deps embebidas (generadas en build; git-ignored) | +| `venv-linux/`, `venv-windows/` | Entornos virtuales de build (git-ignored) | + +--- + +## 10. Scripts de referencia rápida + +| Script | Propósito | +|---|---| +| `build-all.sh` | **Todo en uno** (Windows + Linux + paquetes) desde WSL | +| `build.sh` / `build.ps1` | Build individual Linux / Windows | +| `packaging/scripts/docker-build-linux.sh` | Build Linux en contenedor controlado | +| `packaging/scripts/download-bundled-deps.sh` / `.ps1` | Descarga+embebe deps | +| `packaging/scripts/package-release.sh` | Genera `.tar.gz` / `.zip` | +| `install.sh` / `install.ps1` | Instalador Linux / Windows | +| `packaging/linux/cloudrestoreas.service` | Unit systemd (24/7 headless) | diff --git a/README.md b/README.md index 9c9bf1b..b3d1ca9 100644 --- a/README.md +++ b/README.md @@ -24,6 +24,9 @@ CloudRestoreAS es una aplicación Windows de escritorio desarrollada en Python 3 ### Sistema Operativo - Windows 10/11 - Windows Server 2019/2022 o superior +- Linux x86-64 (servidor o escritorio). En servidor **headless** (sin pantalla) corre + automáticamente en modo Qt `offscreen`. El binario Linux es **autocontenido**: no + requiere instalar Python, 7-Zip, driver ODBC ni librerías Qt en el destino. ### Software Requerido @@ -75,25 +78,46 @@ CloudRestoreAS es una aplicación Windows de escritorio desarrollada en Python 3 ### Opción 2: Ejecutable portable (recomendado para producción) -**Windows** — generar: -```powershell -.\build.ps1 -``` -Salida: `dist\CloudRestoreAS.exe` - -**Linux** — generar: +**Todo de una vez (desde WSL)** — genera Windows + Linux + los paquetes de release: ```bash -./build.sh +./build-all.sh # ambos + dist/release/*.tar.gz y *.zip +./build-all.sh --linux-only # solo Linux (Docker) +./build-all.sh --windows-only # solo Windows (PowerShell + build.ps1) +./build-all.sh --clean # rebuild desde cero ``` -Salida: `dist/CloudRestoreAS` +Requiere Docker (para Linux) y, para Windows, `powershell.exe` accesible desde WSL con Python 3.11+ instalado en Windows. -**Desplegar en cada equipo** (sin Python, sin instalador): +**Solo Windows** — generar: `.\build.ps1` → `dist\CloudRestoreAS.exe` +**Solo Linux** — generar: `./build.sh` (o `packaging/scripts/docker-build-linux.sh` para el entorno controlado) → `dist/CloudRestoreAS` + +> 📦 Referencia completa de compilación, empaquetado, instalación (`install.sh`/systemd), +> flags del binario y verificación: **[BUILD.md](BUILD.md)**. + +> El build de Linux embebe dentro del binario, además de la app: las libs de sistema +> de Qt (cluster xcb/X11 + EGL), el driver **ODBC 18** con sus dependencias +> (unixODBC, Kerberos/GSSAPI, OpenSSL) y el **7-Zip** (`7zz`). Por eso el destino no +> necesita `apt install` de nada. (El build se hace en un entorno con esas libs; ver +> `packaging/scripts/download-bundled-deps.sh` y `docker-build-linux.sh`.) + +**Desplegar en cada equipo** (sin Python, sin instalador, sin dependencias de sistema): 1. Copiar **solo** el ejecutable a una carpeta. 2. Ejecutarlo (doble clic o `./CloudRestoreAS`). 3. Se crean automáticamente: `config/`, `Entrada/`, `Procesados/`, `Fallados/`, `Temp/`. 4. Editar `config/.env` (URL, token e instancia del panel). 5. Reiniciar la aplicación. +**Despliegue en servidor Linux (headless / SQL Server sobre Linux):** +```bash +sudo ./install.sh --service # servicio systemd 24/7 (offscreen, motor auto-inicio) +# o manual: +QT_QPA_PLATFORM=offscreen ./CloudRestoreAS --start-engine --headless +``` +`install.sh` **no instala ni descarga nada** del sistema: solo coloca el binario, hace +el bootstrap de `config/` y registra el arranque (systemd headless o autostart de +escritorio con `--desktop`). El `data_folder` del destino viene del PANEL; con SQL +Server sobre Linux serán rutas POSIX (p. ej. `/var/opt/mssql/data`) y el `RESTORE` +las adapta automáticamente. + Ver `packaging/LEEME.txt` para instrucciones resumidas. ## ⚙️ Configuración Inicial diff --git a/app/config/bootstrap.py b/app/config/bootstrap.py index c2e9e1d..fd8da26 100644 --- a/app/config/bootstrap.py +++ b/app/config/bootstrap.py @@ -16,6 +16,7 @@ from ..constants import ( DIR_PROCESADOS, DIR_TEMP, ENV_PATH, + IS_WINDOWS, LOGS_DIR, ODBC_DIR, SEVEN_ZIP_DIR, @@ -25,10 +26,32 @@ from .env_loader import render_env_template def _copy_tree_if_missing(src: Path, dest: Path) -> None: - if not src.is_dir() or dest.exists(): + if not src.is_dir(): return - dest.parent.mkdir(parents=True, exist_ok=True) - shutil.copytree(src, dest) + # dest puede existir pero VACÍO: ensure_runtime_layout crea ODBC_DIR/SEVEN_ZIP_DIR + # antes de llamar aquí. Solo saltar si ya tiene contenido (evita re-copiar en cada + # arranque). Antes se saltaba por dest.exists(), dejando 7-Zip/ODBC sin desplegar. + if dest.exists() and any(dest.iterdir()): + return + dest.mkdir(parents=True, exist_ok=True) + shutil.copytree(src, dest, dirs_exist_ok=True) + + +def _ensure_seven_zip_executable() -> None: + """ + Asegura el bit de ejecución del 7-Zip embebido en Linux/macOS. shutil.copytree + suele preservar los permisos, pero esto es una salvaguarda barata: si el binario + quedó sin 'x', la extracción fallaría con PermissionError. + """ + if IS_WINDOWS: + return + for exe_name in ("7zz", "7za", "7z"): + exe_path = SEVEN_ZIP_DIR / exe_name + if exe_path.is_file(): + try: + exe_path.chmod(0o755) + except OSError: + pass def _write_env_if_missing() -> None: @@ -71,6 +94,7 @@ def ensure_runtime_layout() -> None: _copy_tree_if_missing(BUNDLED_SOURCE_7ZIP, SEVEN_ZIP_DIR) _copy_tree_if_missing(BUNDLED_SOURCE_ODBC, ODBC_DIR) + _ensure_seven_zip_executable() from ..constants import DB_PATH diff --git a/app/config/odbc_setup.py b/app/config/odbc_setup.py index 55b702e..f29c326 100644 --- a/app/config/odbc_setup.py +++ b/app/config/odbc_setup.py @@ -27,11 +27,24 @@ Driver={driver_line} UsageCount=1 """ else: + # Los .so embebidos viven en config/odbc/lib (no en la raíz). Buscar ahí + # primero y usar SIEMPRE la ruta absoluta del archivo versionado real + # (p. ej. libmsodbcsql-18.5.so.1.1); un nombre suelto como + # "libmsodbcsql-18.so" no resuelve porque ese symlink apunta a /opt. + lib_dir = odbc_dir / "lib" + search_dirs = [d for d in (lib_dir, odbc_dir) if d.is_dir()] so_path = None - for pattern in ("libmsodbcsql-18*.so*", "msodbcsql-18*.so*"): - matches = list(odbc_dir.glob(pattern)) - if matches: - so_path = matches[0] + for base in search_dirs: + # Preferir el archivo real versionado sobre symlinks (que pueden estar rotos). + candidates = sorted( + (p for p in base.glob("libmsodbcsql-18*.so*") if p.is_file() and not p.is_symlink()), + key=lambda p: len(p.name), + reverse=True, + ) + if not candidates: + candidates = [p for p in base.glob("libmsodbcsql-18*.so*") if p.exists()] + if candidates: + so_path = candidates[0] break driver_line = str(so_path.resolve()) if so_path else "libmsodbcsql-18.so" content = f"""[ODBC Driver 18 for SQL Server] diff --git a/app/sql/sql_manager.py b/app/sql/sql_manager.py index 5d4bb5d..0c247b0 100644 --- a/app/sql/sql_manager.py +++ b/app/sql/sql_manager.py @@ -378,6 +378,24 @@ class SQLServerManager: except Exception: app_logger.warning("No se pudo cerrar la conexión SQL tras el RESTORE") + @staticmethod + def _sql_path_sep(data_folder: str) -> str: + """ + Separador de rutas que espera el SQL Server destino, deducido del formato + de data_folder. Windows (C:\\..., o contiene '\\') usa '\\'; SQL Server + sobre Linux (rutas POSIX '/var/opt/mssql/...') usa '/'. Las rutas del MOVE + son del filesystem del SERVIDOR, no de donde corre la app. + """ + if "\\" in data_folder: + return "\\" + # Ruta POSIX explícita ("/...") o sin separador Windows → '/'. + if data_folder.startswith("/"): + return "/" + # Heurística: "C:" u otra letra de unidad ⇒ Windows. + if len(data_folder) >= 2 and data_folder[1] == ":": + return "\\" + return "/" + @staticmethod def _build_move_clauses(db_name, data_folder, logical_files) -> list: """ @@ -386,7 +404,13 @@ class SQLServerManager: - 1er data → {db}.mdf, siguientes → {db}_N.ndf - 1er log → {db}_log.ldf, siguientes → {db}_log_N.ldf - otros tipos (FILESTREAM/full-text) → {db}_{nombre_lógico_saneado} + + El separador se adapta al SO del SQL Server destino (deducido de + data_folder), de modo que funciona tanto con SQL Server en Windows + (C:\\...\\db.mdf) como en Linux (/var/opt/mssql/data/db.mdf). """ + sep = SQLServerManager._sql_path_sep(data_folder) + base = data_folder.rstrip("\\/") clauses = [] data_idx = 0 log_idx = 0 @@ -394,16 +418,16 @@ class SQLServerManager: if lf.type == 'D': suffix = "" if data_idx == 0 else f"_{data_idx}" ext = "mdf" if data_idx == 0 else "ndf" - new_path = f"{data_folder}\\{db_name}{suffix}.{ext}" + new_path = f"{base}{sep}{db_name}{suffix}.{ext}" data_idx += 1 elif lf.type == 'L': suffix = "" if log_idx == 0 else f"_{log_idx}" - new_path = f"{data_folder}\\{db_name}_log{suffix}.ldf" + new_path = f"{base}{sep}{db_name}_log{suffix}.ldf" log_idx += 1 else: # No descartar otros tipos: moverlos preservando el nombre lógico. safe = "".join(c if c.isalnum() else "_" for c in lf.logical_name) - new_path = f"{data_folder}\\{db_name}_{safe}" + new_path = f"{base}{sep}{db_name}_{safe}" clauses.append(f"MOVE N'{lf.logical_name}' TO N'{new_path}'") return clauses diff --git a/app/ui/config_tab.py b/app/ui/config_tab.py index b44c8e8..da0659f 100644 --- a/app/ui/config_tab.py +++ b/app/ui/config_tab.py @@ -104,24 +104,29 @@ class ConfigTab(QWidget): self.sql_windows_auth_checkbox = QCheckBox() self.sql_windows_auth_checkbox.setChecked(True) - self.sql_windows_auth_checkbox.toggled.connect(self._on_auth_changed) sql_layout.addRow("Usar Windows Auth:", self.sql_windows_auth_checkbox) + + self.sql_username_input = QLineEdit() + self.sql_username_input.setEnabled(False) + sql_layout.addRow("Usuario SQL:", self.sql_username_input) + + self.sql_password_input = QLineEdit() + self.sql_password_input.setEchoMode(QLineEdit.EchoMode.Password) + self.sql_password_input.setEnabled(False) + sql_layout.addRow("Contraseña SQL:", self.sql_password_input) + + # Conectar el handler DESPUÉS de crear usuario/contraseña: en Linux se + # desmarca el checkbox (abajo), lo que dispararía _on_auth_changed antes de + # que existan esos campos si se conectara arriba. + self.sql_windows_auth_checkbox.toggled.connect(self._on_auth_changed) if sys.platform != "win32": + # Windows Auth no aplica en Linux: forzar SQL Auth y habilitar campos. self.sql_windows_auth_checkbox.setChecked(False) self.sql_windows_auth_checkbox.setEnabled(False) self.sql_windows_auth_checkbox.setToolTip( "Windows Auth no está disponible en Linux; use SQL Auth." ) - self.sql_username_input = QLineEdit() - self.sql_username_input.setEnabled(False) - sql_layout.addRow("Usuario SQL:", self.sql_username_input) - - self.sql_password_input = QLineEdit() - self.sql_password_input.setEchoMode(QLineEdit.EchoMode.Password) - self.sql_password_input.setEnabled(False) - sql_layout.addRow("Contraseña SQL:", self.sql_password_input) - test_sql_btn = QPushButton("🔌 Probar Conexión") test_sql_btn.clicked.connect(self._test_sql_connection) sql_layout.addRow("", test_sql_btn) @@ -431,12 +436,17 @@ class ConfigTab(QWidget): line_edit.setText(folder) def _browse_seven_zip(self): - """Abre el diálogo para seleccionar 7z.exe.""" + """Abre el diálogo para seleccionar el ejecutable de 7-Zip.""" + if sys.platform == "win32": + title = "Seleccionar 7z.exe" + default_dir = "C:\\Program Files\\7-Zip" + file_filter = "Ejecutables (*.exe)" + else: + title = "Seleccionar 7z / 7zz" + default_dir = "" + file_filter = "Ejecutables (*)" file_path, _ = QFileDialog.getOpenFileName( - self, - "Seleccionar 7z.exe", - "C:\\Program Files\\7-Zip", - "Ejecutables (*.exe)" + self, title, default_dir, file_filter ) if file_path: self.seven_zip_input.setText(file_path) @@ -475,6 +485,9 @@ class ConfigTab(QWidget): def _on_auth_changed(self, checked: bool): """Maneja el cambio en el tipo de autenticación.""" + # Guard: la señal puede dispararse durante la construcción de la UI. + if not hasattr(self, "sql_username_input"): + return self.sql_username_input.setEnabled(not checked) self.sql_password_input.setEnabled(not checked) diff --git a/app/ui/logs_tab.py b/app/ui/logs_tab.py index 29579de..a17d52e 100644 --- a/app/ui/logs_tab.py +++ b/app/ui/logs_tab.py @@ -1,6 +1,7 @@ """Tab de logs y soporte.""" import subprocess +import sys from pathlib import Path from PySide6.QtWidgets import ( @@ -91,10 +92,15 @@ class LogsTab(QWidget): self.logs_text.setPlainText("\n".join(log_lines)) def _open_logs_folder(self): - """Abre la carpeta de logs en el explorador.""" + """Abre la carpeta de logs en el explorador de archivos del sistema.""" try: if LOGS_DIR.exists(): - subprocess.run(["explorer", str(LOGS_DIR)]) + if sys.platform == "win32": + subprocess.run(["explorer", str(LOGS_DIR)]) + elif sys.platform == "darwin": + subprocess.run(["open", str(LOGS_DIR)]) + else: + subprocess.run(["xdg-open", str(LOGS_DIR)]) else: QMessageBox.warning( self, diff --git a/build-all.sh b/build-all.sh new file mode 100755 index 0000000..3fdf4d6 --- /dev/null +++ b/build-all.sh @@ -0,0 +1,131 @@ +#!/usr/bin/env bash +# ============================================================================= +# CloudRestoreAS — build de TODO en una sola tarea (ejecutar desde WSL). +# +# Linux : build en Docker (ubuntu:22.04) -> dist/CloudRestoreAS (autocontenido) +# Windows: build vía powershell.exe -> build.ps1 -> dist/CloudRestoreAS.exe +# Paquete: dist/release/CloudRestoreAS-linux.tar.gz y CloudRestoreAS-win.zip +# +# Uso: +# ./build-all.sh # ambos + empaquetado +# ./build-all.sh --linux-only # solo Linux +# ./build-all.sh --windows-only # solo Windows +# ./build-all.sh --no-package # sin generar .tar.gz/.zip +# ./build-all.sh --clean # rebuild desde cero (borra venvs/bundled/dist) +# ============================================================================= +set -uo pipefail + +ROOT="$(cd "$(dirname "$0")" && pwd)" +cd "$ROOT" + +DO_LINUX=1 +DO_WINDOWS=1 +DO_PACKAGE=1 +DO_CLEAN=0 + +for arg in "$@"; do + case "$arg" in + --linux-only) DO_WINDOWS=0 ;; + --windows-only) DO_LINUX=0 ;; + --no-package) DO_PACKAGE=0 ;; + --clean) DO_CLEAN=1 ;; + -h|--help) + grep '^#' "$0" | grep -v '^#!' | sed 's/^# \{0,1\}//'; exit 0 ;; + *) echo "Opción desconocida: $arg" >&2; exit 2 ;; + esac +done + +# --- helpers ----------------------------------------------------------------- +BLUE='\033[36m'; GREEN='\033[32m'; YELLOW='\033[33m'; RED='\033[31m'; NC='\033[0m' +say() { echo -e "${BLUE}==>${NC} $*"; } +ok() { echo -e "${GREEN}OK:${NC} $*"; } +warn() { echo -e "${YELLOW}AVISO:${NC} $*" >&2; } +err() { echo -e "${RED}ERROR:${NC} $*" >&2; } + +# SECONDS es incremental de bash; lo usamos para medir cada etapa. +stage_start() { STAGE_T0=$SECONDS; } +stage_end() { echo -e " (${1} en $((SECONDS - STAGE_T0))s)"; } + +WIN_OK=0 +LIN_OK=0 + +# --- limpieza opcional ------------------------------------------------------- +if [[ "$DO_CLEAN" -eq 1 ]]; then + say "Limpieza (--clean): borrando venvs, bundled y dist" + # bundled/ y venv-linux los crea Docker como root; borrar vía contenedor. + if command -v docker >/dev/null 2>&1; then + docker run --rm -v "$ROOT:/app" ubuntu:22.04 bash -c \ + 'rm -rf /app/packaging/bundled/linux /app/venv-linux /app/dist/CloudRestoreAS /app/dist/release' \ + >/dev/null 2>&1 || true + fi + rm -rf "$ROOT/venv-windows" "$ROOT/packaging/bundled/windows" \ + "$ROOT/dist/CloudRestoreAS.exe" 2>/dev/null || true + ok "limpieza completada" +fi + +# --- Build Linux (Docker) ---------------------------------------------------- +if [[ "$DO_LINUX" -eq 1 ]]; then + say "Build Linux (Docker, autocontenido)" + stage_start + if ! command -v docker >/dev/null 2>&1; then + err "docker no disponible; no se puede construir Linux" + [[ "$DO_WINDOWS" -eq 0 ]] && exit 1 + elif bash "$ROOT/packaging/scripts/docker-build-linux.sh"; then + if [[ -f "$ROOT/dist/CloudRestoreAS" ]]; then + LIN_OK=1; ok "dist/CloudRestoreAS" + else + err "el build Linux terminó sin binario" + fi + else + err "falló el build Linux" + fi + stage_end "Linux" +fi + +# --- Build Windows (PowerShell -> build.ps1) --------------------------------- +if [[ "$DO_WINDOWS" -eq 1 ]]; then + say "Build Windows (PowerShell + build.ps1)" + stage_start + WIN_PATH="$(wslpath -w "$ROOT" 2>/dev/null || true)" + if command -v powershell.exe >/dev/null 2>&1 && [[ -n "$WIN_PATH" ]]; then + # build.ps1 auto-detecta el Python de Windows (Python313/312/311) y arma venv-windows. + powershell.exe -NoProfile -ExecutionPolicy Bypass -Command \ + "Set-Location -LiteralPath '$WIN_PATH'; & .\\build.ps1" + PS_RC=$? + if [[ "$PS_RC" -eq 0 && -f "$ROOT/dist/CloudRestoreAS.exe" ]]; then + WIN_OK=1; ok "dist/CloudRestoreAS.exe" + else + err "falló el build Windows (código $PS_RC)" + [[ "$DO_LINUX" -eq 0 ]] && { stage_end "Windows"; exit 1; } + fi + else + warn "powershell.exe no disponible desde WSL; se omite el build Windows." + warn "Ejecuta build.ps1 en Windows para generar el .exe." + [[ "$DO_LINUX" -eq 0 ]] && exit 1 + fi + stage_end "Windows" +fi + +# --- Empaquetado ------------------------------------------------------------- +if [[ "$DO_PACKAGE" -eq 1 ]]; then + say "Empaquetado (.tar.gz Linux / .zip Windows)" + stage_start + bash "$ROOT/packaging/scripts/package-release.sh" || warn "empaquetado con incidencias" + stage_end "Empaquetado" +fi + +# --- Resumen ----------------------------------------------------------------- +echo +say "Resumen" +[[ "$DO_LINUX" -eq 1 ]] && { [[ "$LIN_OK" -eq 1 ]] && ok "Linux regenerado" || err "Linux NO generado"; } +[[ "$DO_WINDOWS" -eq 1 ]] && { [[ "$WIN_OK" -eq 1 ]] && ok "Windows regenerado" || warn "Windows NO generado"; } +if [[ -d "$ROOT/dist/release" ]]; then + echo "Artefactos en dist/release/:" + ls -lh "$ROOT/dist/release" | awk 'NR>1 {print " " $9 " " $5}' +fi + +# Éxito si todo lo solicitado se generó. +FAIL=0 +[[ "$DO_LINUX" -eq 1 && "$LIN_OK" -ne 1 ]] && FAIL=1 +[[ "$DO_WINDOWS" -eq 1 && "$WIN_OK" -ne 1 ]] && FAIL=1 +exit $FAIL diff --git a/install.sh b/install.sh new file mode 100755 index 0000000..e8d320b --- /dev/null +++ b/install.sh @@ -0,0 +1,103 @@ +#!/usr/bin/env bash +# Instalador Linux de CloudRestoreAS. +# +# NO instala ni descarga NADA del sistema: el binario es 100% autocontenido +# (Qt/xcb, driver ODBC + Kerberos/OpenSSL, y 7-Zip van embebidos). Este script solo +# coloca el binario, marca permisos, hace el bootstrap de config/, y opcionalmente +# registra el arranque automático (servicio systemd headless o autostart de escritorio). +# +# Uso: +# sudo ./install.sh --service # 24/7 headless vía systemd (recomendado en servidor) +# ./install.sh --desktop # autostart de escritorio (requiere sesión gráfica) +# ./install.sh # solo instala; sin arranque automático +# +# Variables: +# PREFIX=/opt/cloudrestoreas # carpeta destino (default) +# SERVICE_USER= # usuario del servicio systemd (default: quien invoca) +set -euo pipefail + +MODE="none" +for arg in "$@"; do + case "$arg" in + --service) MODE="service" ;; + --desktop) MODE="desktop" ;; + -h|--help) + grep '^#' "$0" | grep -v '^#!' | sed 's/^# \{0,1\}//'; exit 0 ;; + *) echo "Opción desconocida: $arg" >&2; exit 2 ;; + esac +done + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +PREFIX="${PREFIX:-/opt/cloudrestoreas}" +BIN_NAME="CloudRestoreAS" + +# Localizar el binario: dist/CloudRestoreAS, dist/CloudRestoreAS-linux, o junto al script. +SRC="" +for cand in \ + "$SCRIPT_DIR/dist/$BIN_NAME" \ + "$SCRIPT_DIR/dist/${BIN_NAME}-linux" \ + "$SCRIPT_DIR/$BIN_NAME" \ + "$SCRIPT_DIR/${BIN_NAME}-linux"; do + if [[ -f "$cand" ]]; then SRC="$cand"; break; fi +done +if [[ -z "$SRC" ]]; then + echo "ERROR: no se encontró el binario ($BIN_NAME). Ejecuta ./build.sh primero" >&2 + exit 1 +fi + +echo "===============================================" +echo "CloudRestoreAS - Instalación Linux" +echo " Binario : $SRC" +echo " Destino : $PREFIX" +echo " Modo : $MODE" +echo "===============================================" + +mkdir -p "$PREFIX" +install -m 0755 "$SRC" "$PREFIX/$BIN_NAME" +echo "Binario instalado en $PREFIX/$BIN_NAME" + +# Bootstrap de config/: el propio binario crea config/, .env y carpetas de trabajo +# al inicio de su arranque. Se corre una vez en modo offscreen (sin display) y se +# corta con timeout; así el usuario ya puede editar config/.env antes de habilitar +# el servicio. +echo "Inicializando config/ (bootstrap)..." +( cd "$PREFIX" && QT_QPA_PLATFORM=offscreen timeout 20 "$PREFIX/$BIN_NAME" --headless >/dev/null 2>&1 || true ) +if [[ -f "$PREFIX/config/.env" ]]; then + echo "config/.env creado." +else + echo "NOTA: config/.env se creará en la primera ejecución." +fi + +case "$MODE" in + service) + SERVICE_USER="${SERVICE_USER:-${SUDO_USER:-$(id -un)}}" + UNIT_SRC="$SCRIPT_DIR/packaging/linux/cloudrestoreas.service" + UNIT_DST="/etc/systemd/system/cloudrestoreas.service" + if [[ ! -w "$(dirname "$UNIT_DST")" ]]; then + echo "ERROR: se requiere sudo para instalar el servicio systemd" >&2 + exit 1 + fi + sed -e "s|__USER__|$SERVICE_USER|g" \ + -e "s|__WORKDIR__|$PREFIX|g" \ + -e "s|__EXEC__|$PREFIX/$BIN_NAME|g" \ + "$UNIT_SRC" > "$UNIT_DST" + systemctl daemon-reload + systemctl enable --now cloudrestoreas.service + echo "Servicio systemd instalado y arrancado (usuario: $SERVICE_USER)." + echo " Estado : systemctl status cloudrestoreas" + echo " Logs : journalctl -u cloudrestoreas -f" + ;; + desktop) + echo "Modo escritorio: la app registra su autostart .desktop al iniciarse." + echo "Ejecuta '$PREFIX/$BIN_NAME' en tu sesión gráfica." + ;; + none) + echo "Instalación sin arranque automático." + echo "Ejecuta: QT_QPA_PLATFORM=offscreen $PREFIX/$BIN_NAME --start-engine --headless" + ;; +esac + +echo "" +echo "Siguiente paso: edita $PREFIX/config/.env (CLOUDRESTORE_PANEL_*) y reinicia." +[[ "$MODE" == "service" ]] && echo " Tras editar: sudo systemctl restart cloudrestoreas" +echo "Listo." diff --git a/packaging/CloudRestoreAS.spec b/packaging/CloudRestoreAS.spec index 94822d1..244fd80 100644 --- a/packaging/CloudRestoreAS.spec +++ b/packaging/CloudRestoreAS.spec @@ -38,6 +38,17 @@ if odbc_dir.is_dir(): dest = "bundled/odbc" binaries.append((str(item), dest)) +# Libs de sistema Qt (cluster xcb/X11 + EGL) que el plugin xcb carga por dlopen. +# Van JUNTO a las librerías Qt (PySide6/Qt/lib): libQt6XcbQpa.so.6 tiene RPATH +# $ORIGIN, así que resuelve libxcb-cursor.so.0 y el resto en su propio directorio +# sin depender de LD_LIBRARY_PATH. (El stack ODBC va con el driver en bundled/odbc, +# con RPATH=$ORIGIN aplicado por download-bundled-deps.sh.) Solo aplica en Linux. +qt_sys_lib = bundled / "qt" / "lib" +if qt_sys_lib.is_dir(): + for item in qt_sys_lib.iterdir(): + if item.is_file() and not item.is_symlink(): + binaries.append((str(item), "PySide6/Qt/lib")) + hiddenimports = [ "PySide6", "pyodbc", diff --git a/packaging/LEEME.txt b/packaging/LEEME.txt index 557d89b..3241545 100644 --- a/packaging/LEEME.txt +++ b/packaging/LEEME.txt @@ -1,6 +1,9 @@ CloudRestoreAS — despliegue portable ===================================== +El ejecutable es AUTOCONTENIDO: no requiere Python, ni 7-Zip, ni driver ODBC, ni +librerias Qt instaladas en el equipo destino. Todo va embebido dentro del binario. + Windows: copie CloudRestoreAS.exe a la carpeta deseada. Linux: copie CloudRestoreAS y ejecute chmod +x CloudRestoreAS si hace falta. @@ -15,4 +18,23 @@ Cerrar la ventana (X) minimiza a la bandeja; la app sigue en ejecucion. Para salir por completo: clic derecho en el icono de bandeja -> Salir, o menu Archivo -> Salir. -No requiere Python ni instaladores adicionales en el equipo destino. +------------------------------------- +Linux en SERVIDOR SIN ESCRITORIO (headless) +------------------------------------- +En un servidor sin pantalla (sin DISPLAY), la app arranca automaticamente en modo +"offscreen": no muestra ventana pero el motor de restauracion trabaja igual. No hay +que instalar nada del sistema. + +Opcion A - servicio 24/7 (recomendado en servidor SQL): + sudo ./install.sh --service + (instala una unit systemd que corre el binario con --start-engine --headless; + ver estado: systemctl status cloudrestoreas ; logs: journalctl -u cloudrestoreas -f) + +Opcion B - manual: + QT_QPA_PLATFORM=offscreen ./CloudRestoreAS --start-engine --headless + +Opcion C - escritorio Linux (con pantalla): + ./install.sh --desktop (registra autostart .desktop; requiere sesion grafica) + +El servidor SQL destino y su carpeta de datos (data_folder) se toman del PANEL; +con SQL Server sobre Linux use rutas POSIX (p. ej. /var/opt/mssql/data). diff --git a/packaging/linux/cloudrestoreas.service b/packaging/linux/cloudrestoreas.service new file mode 100644 index 0000000..f41ee17 --- /dev/null +++ b/packaging/linux/cloudrestoreas.service @@ -0,0 +1,19 @@ +[Unit] +Description=CloudRestoreAS - Restauración automática SQL Server +After=network-online.target mssql-server.service +Wants=network-online.target + +[Service] +Type=simple +# __USER__ y __EXEC__ los sustituye install.sh al instalar. +User=__USER__ +WorkingDirectory=__WORKDIR__ +# Servidor headless: plataforma Qt offscreen (sin display) y motor auto-inicio. +Environment=QT_QPA_PLATFORM=offscreen +ExecStart=__EXEC__ --start-engine --headless +Restart=always +RestartSec=5 +# El binario es autocontenido (Qt, ODBC, 7-Zip embebidos): no necesita libs del sistema. + +[Install] +WantedBy=multi-user.target diff --git a/packaging/scripts/build-all.sh b/packaging/scripts/build-all.sh old mode 100644 new mode 100755 index 3a0f4bd..0fa3157 --- a/packaging/scripts/build-all.sh +++ b/packaging/scripts/build-all.sh @@ -1,34 +1,6 @@ #!/usr/bin/env bash -# Genera ambos artefactos: Linux (local/Docker) y Windows (PowerShell + Python en Windows). +# Wrapper de compatibilidad: el orquestador canónico vive en la raíz del repo. +# Ejecuta ./build-all.sh (desde WSL) para generar Windows + Linux + paquetes. set -euo pipefail - ROOT="$(cd "$(dirname "$0")/../.." && pwd)" -RELEASE="$ROOT/dist/release" -mkdir -p "$RELEASE" - -echo "=== Build Linux ===" -if [[ -f "$ROOT/build.sh" ]]; then - bash "$ROOT/build.sh" - cp -f "$ROOT/dist/CloudRestoreAS" "$RELEASE/CloudRestoreAS-linux" - chmod +x "$RELEASE/CloudRestoreAS-linux" -fi - -echo "=== Build Windows (via PowerShell) ===" -WSL_PATH=$(wslpath -w "$ROOT" 2>/dev/null || echo "") -if [[ -n "$WSL_PATH" ]] && command -v powershell.exe >/dev/null 2>&1; then - powershell.exe -NoProfile -ExecutionPolicy Bypass -Command " - Set-Location '$WSL_PATH' - & 'C:\Users\Hugo Reyes\AppData\Local\Programs\Python\Python313\python.exe' -m pip install -q -r requirements-windows.txt 2>\$null - & .\build.ps1 - " - if [[ -f "$ROOT/dist/CloudRestoreAS.exe" ]]; then - cp -f "$ROOT/dist/CloudRestoreAS.exe" "$RELEASE/CloudRestoreAS.exe" - fi -else - echo "Omitido: ejecute build.ps1 en Windows manualmente" -fi - -cp -f "$ROOT/packaging/LEEME.txt" "$RELEASE/" -echo "" -echo "Artefactos en: $RELEASE" -ls -la "$RELEASE" +exec bash "$ROOT/build-all.sh" "$@" diff --git a/packaging/scripts/docker-build-linux.sh b/packaging/scripts/docker-build-linux.sh index eea822e..c7c9d9a 100755 --- a/packaging/scripts/docker-build-linux.sh +++ b/packaging/scripts/docker-build-linux.sh @@ -9,10 +9,19 @@ docker run --rm \ set -e export DEBIAN_FRONTEND=noninteractive apt-get update -qq +# Herramientas de build + libs de sistema para que PyInstaller EMBEBA el cierre +# completo de dependencias (plugin Qt xcb y driver MS ODBC). Cinturón y tirantes +# junto con el bundle explícito de download-bundled-deps.sh. apt-get install -y -qq \ - python3 python3-venv python3-pip curl dpkg-dev binutils unixodbc \ - libglib2.0-0 libdbus-1-3 libxkbcommon0 libfontconfig1 libxcb1 libx11-6 \ - libxcb-xkb1 libegl1 libgl1 libxi6 libxrender1 libxext6 \ + python3 python3-venv python3-pip curl dpkg-dev binutils apt-utils patchelf \ + unixodbc libodbcinst2 libltdl7 libkrb5-3 libgssapi-krb5-2 libssl3 \ + libglib2.0-0 libdbus-1-3 libfontconfig1 libfreetype6 \ + libxkbcommon0 libxkbcommon-x11-0 libegl1 libgl1 libglvnd0 \ + libx11-6 libx11-xcb1 libxext6 libxrender1 libxi6 libxfixes3 libxtst6 \ + libxcomposite1 libxdamage1 libxrandr2 libxkbfile1 \ + libxcb1 libxcb-cursor0 libxcb-icccm4 libxcb-util1 libxcb-image0 \ + libxcb-keysyms1 libxcb-render-util0 libxcb-render0 libxcb-shape0 \ + libxcb-xkb1 libxcb-glx0 libxcb-randr0 libxcb-shm0 libxcb-sync1 \ > /dev/null chmod +x build.sh packaging/scripts/download-bundled-deps.sh ./build.sh diff --git a/packaging/scripts/download-bundled-deps.sh b/packaging/scripts/download-bundled-deps.sh index 1202db0..df7624b 100755 --- a/packaging/scripts/download-bundled-deps.sh +++ b/packaging/scripts/download-bundled-deps.sh @@ -1,5 +1,11 @@ #!/usr/bin/env bash -# Descarga 7zz y bibliotecas ODBC para empaquetar en el binario Linux. +# Descarga y EMBEBE (build-time) todo lo que el binario Linux necesita en runtime: +# - 7zz (7-Zip para Linux) +# - Driver MS ODBC 18 + unixODBC +# - Libs de sistema de Qt (cluster xcb/X11 + EGL) y del stack ODBC +# (libltdl, Kerberos/GSSAPI, OpenSSL) que PySide6/pyodbc cargan por dlopen +# y que NO vienen dentro del wheel. +# Objetivo: que el onefile corra en un servidor Linux "pelado" sin instalar nada. set -euo pipefail ROOT="$(cd "$(dirname "$0")/../.." && pwd)" @@ -7,17 +13,55 @@ VERSIONS="$ROOT/packaging/bundled-versions.json" BUNDLED="$ROOT/packaging/bundled/linux" SEVEN="$BUNDLED/7zip" ODBC="$BUNDLED/odbc/lib" +QTLIB="$BUNDLED/qt/lib" # libs de sistema extra a embeder en la raíz de _MEIPASS -mkdir -p "$SEVEN" "$ODBC" +mkdir -p "$SEVEN" "$ODBC" "$QTLIB" read_url() { python3 -c "import json; print(json.load(open('$VERSIONS'))['$1'])" } -LINUX_7Z_URL="$(read_url seven_zip_linux_x64)" -MSODBC_DEB="$(read_url msodbcsql18_deb)" +# Descarga uno o más paquetes .deb (y NO sus dependencias), extrae sus .so y los +# copia al directorio destino con el NOMBRE DE SONAME (lo que busca el loader: +# libfoo.so.N), dereferenciando symlinks para no dejar enlaces colgantes. +# Requiere apt-get/dpkg-deb. +fetch_pkg_libs() { + local destdir="$1"; shift + if ! command -v apt-get >/dev/null 2>&1; then + echo " (apt-get no disponible; se omite descarga de $* — el entorno de build debe proveerlas)" + return 0 + fi + local tmp; tmp=$(mktemp -d) + ( + cd "$tmp" + apt-get download "$@" >/dev/null 2>&1 || { + # Reintento tras refrescar índices (build env con red). + apt-get update -qq >/dev/null 2>&1 || true + apt-get download "$@" >/dev/null 2>&1 || true + } + for deb in *.deb; do + [[ -f "$deb" ]] || continue + dpkg-deb -x "$deb" x + done + [[ -d x ]] || exit 0 + # 1) Symlinks SONAME del propio paquete (libfoo.so.N -> libfoo.so.N.M.P): + # copiar el contenido REAL bajo el nombre del symlink (= SONAME exacto). + while IFS= read -r link; do + cp -Lf "$link" "$destdir/$(basename "$link")" 2>/dev/null || true + done < <(find x -type l -name '*.so.*') + # 2) Archivos reales sin symlink: derivar SONAME por truncación de versión + # (libfoo.so.N.M.P -> libfoo.so.N) para no dejarlos con nombre versionado. + while IFS= read -r f; do + local soname + soname=$(basename "$f" | sed -E 's/(\.so\.[0-9]+)\..*/\1/') + [[ -e "$destdir/$soname" ]] || cp -Lf "$f" "$destdir/$soname" 2>/dev/null || true + done < <(find x -type f -name '*.so.*') + ) + rm -rf "$tmp" +} echo "==> 7-Zip Linux (7zz)" +LINUX_7Z_URL="$(read_url seven_zip_linux_x64)" if [[ ! -f "$SEVEN/7zz" ]]; then TMP=$(mktemp -d) curl -fsSL -o "$TMP/7z.tar.xz" "$LINUX_7Z_URL" @@ -31,6 +75,7 @@ else fi echo "==> ODBC Driver 18 + unixODBC" +MSODBC_DEB="$(read_url msodbcsql18_deb)" if [[ -z "$(ls -A "$ODBC" 2>/dev/null || true)" ]]; then TMP=$(mktemp -d) cd "$TMP" @@ -38,21 +83,74 @@ if [[ -z "$(ls -A "$ODBC" 2>/dev/null || true)" ]]; then if command -v apt-get >/dev/null 2>&1; then export DEBIAN_FRONTEND=noninteractive - apt-get update -qq + apt-get update -qq || true apt-get install -y -qq unixodbc dpkg-dev > /dev/null 2>&1 || true if dpkg -l unixodbc 2>/dev/null | grep -q ^ii; then - find /usr/lib -name 'libodbc*.so*' -exec cp -P {} "$ODBC/" \; 2>/dev/null || true - find /usr/lib -name 'libodbcinst*.so*' -exec cp -P {} "$ODBC/" \; 2>/dev/null || true + # -L: dereferencia symlinks para no dejar enlaces colgantes en el destino. + find /usr/lib -name 'libodbc*.so*' -exec cp -Lf {} "$ODBC/" \; 2>/dev/null || true + find /usr/lib -name 'libodbcinst*.so*' -exec cp -Lf {} "$ODBC/" \; 2>/dev/null || true fi fi dpkg-deb -x msodbcsql18.deb msodbcsql - find msodbcsql -name '*.so*' -exec cp -P {} "$ODBC/" \; + # Copiar SOLO el archivo real versionado del driver (evita el symlink -> /opt). + find msodbcsql -type f -name 'libmsodbcsql-18*.so*' -exec cp -Lf {} "$ODBC/" \; cd "$ROOT" rm -rf "$TMP" - echo " Bibliotecas ODBC en $ODBC" + + # Stack de dependencias del driver MS ODBC 18, JUNTO al driver, para que un + # servidor pelado (sin unixODBC/krb5/openssl) pueda cargarlo. El driver se + # patchelf-ea a RPATH=$ORIGIN (más abajo) para resolverlas en su propio dir. + ODBC_DEP_PKGS=( + libltdl7 libkrb5-3 libgssapi-krb5-2 libk5crypto3 libkrb5support0 + libcom-err2 libkeyutils1 libssl3 libodbc2 libodbcinst2 + ) + fetch_pkg_libs "$ODBC" "${ODBC_DEP_PKGS[@]}" || true + fetch_pkg_libs "$ODBC" unixodbc || true + echo " Bibliotecas ODBC + deps en $ODBC" else echo " ODBC ya existe" fi +# RPATH=$ORIGIN en TODAS las .so del cluster ODBC: así el driver y sus deps +# (libkrb5 -> libk5crypto/libkrb5support/libkeyutils, libgssapi, libltdl, +# libodbcinst, openssl) se resuelven entre sí en su propio directorio una vez +# copiados a config/odbc/lib, sin depender de LD_LIBRARY_PATH. +if command -v patchelf >/dev/null 2>&1; then + for so in "$ODBC"/*.so*; do + [[ -f "$so" && ! -L "$so" ]] || continue + patchelf --set-rpath '$ORIGIN' "$so" 2>/dev/null || true + done + echo " RPATH=\$ORIGIN aplicado a todo el cluster ODBC" +else + echo " ADVERTENCIA: patchelf no disponible; el driver ODBC podría no resolver" >&2 + echo " sus deps en un servidor sin unixODBC/krb5. Instálalo en el entorno de build." >&2 +fi + +echo "==> Libs de sistema Qt (cluster xcb/X11 + EGL) para la GUI con display" +if [[ -z "$(ls -A "$QTLIB" 2>/dev/null || true)" ]]; then + # Plataforma Qt xcb + su cierre X11/xcb + EGL. Van junto a las libs Qt en el + # onefile (PySide6/Qt/lib) para que libQt6XcbQpa las encuentre por $ORIGIN. + QT_XCB_PKGS=( + libxcb-cursor0 libxcb-icccm4 libxcb-util1 libxcb-image0 libxcb-keysyms1 + libxcb-render-util0 libxcb-render0 libxcb-shape0 libxcb-xkb1 + libxkbcommon-x11-0 libxkbcommon0 libxtst6 libxcomposite1 libxdamage1 + libxrandr2 libxkbfile1 libxcb1 libx11-6 libx11-xcb1 libxext6 libxrender1 + libxi6 libxfixes3 libxcb-glx0 libxcb-randr0 libxcb-shm0 libxcb-sync1 + libxcb-present0 libxcb-dri2-0 libxcb-dri3-0 libxcb-xfixes0 libxau6 + libxdmcp6 libbsd0 libsm6 libice6 + ) + QT_GL_PKGS=(libglvnd0 libegl1 libgl1 libopengl0 libglx0 libgles2) + fetch_pkg_libs "$QTLIB" "${QT_XCB_PKGS[@]}" + fetch_pkg_libs "$QTLIB" "${QT_GL_PKGS[@]}" + COUNT=$(find "$QTLIB" -type f -name '*.so*' 2>/dev/null | wc -l) + echo " $COUNT libs Qt embebidas en $QTLIB" + if [[ "$COUNT" -eq 0 ]]; then + echo " ADVERTENCIA: no se embebió ninguna lib Qt. El entorno de build" >&2 + echo " (docker-build-linux.sh) debe traerlas para que PyInstaller las incluya." >&2 + fi +else + echo " Libs Qt ya existen ($(find "$QTLIB" -type f -name '*.so*' | wc -l) archivos)" +fi + echo "Listo: $BUNDLED" diff --git a/packaging/scripts/package-release.sh b/packaging/scripts/package-release.sh old mode 100644 new mode 100755 index a0041f2..4857df6 --- a/packaging/scripts/package-release.sh +++ b/packaging/scripts/package-release.sh @@ -9,18 +9,38 @@ mkdir -p "$RELEASE" [[ -f "$ROOT/dist/CloudRestoreAS" ]] && cp -f "$ROOT/dist/CloudRestoreAS" "$RELEASE/CloudRestoreAS-linux" && chmod +x "$RELEASE/CloudRestoreAS-linux" cp -f "$ROOT/packaging/LEEME.txt" "$RELEASE/" -python3 <<'PY' -import zipfile +# Paquete Windows: carpeta raíz CloudRestoreAS/ con .exe + install.ps1 + LEEME +# (paridad con el .tar.gz de Linux). +if [[ -f "$RELEASE/CloudRestoreAS.exe" ]]; then + ROOT="$ROOT" RELEASE="$RELEASE" python3 <<'PY' +import os, zipfile from pathlib import Path -release = Path("dist/release") -if (release / "CloudRestoreAS.exe").exists(): - with zipfile.ZipFile(release / "CloudRestoreAS-win.zip", "w", zipfile.ZIP_DEFLATED) as z: - z.write(release / "CloudRestoreAS.exe", "CloudRestoreAS.exe") - z.write(release / "LEEME.txt", "LEEME.txt") +root = Path(os.environ["ROOT"]); release = Path(os.environ["RELEASE"]) +items = [(release / "CloudRestoreAS.exe", "CloudRestoreAS/CloudRestoreAS.exe"), + (root / "packaging" / "LEEME.txt", "CloudRestoreAS/LEEME.txt")] +if (root / "install.ps1").exists(): + items.append((root / "install.ps1", "CloudRestoreAS/install.ps1")) +with zipfile.ZipFile(release / "CloudRestoreAS-win.zip", "w", zipfile.ZIP_DEFLATED) as z: + for src, arc in items: + z.write(src, arc) +print(" zip Windows:", release / "CloudRestoreAS-win.zip") PY +fi if [[ -f "$RELEASE/CloudRestoreAS-linux" ]]; then - tar czf "$RELEASE/CloudRestoreAS-linux.tar.gz" -C "$RELEASE" CloudRestoreAS-linux LEEME.txt + # Paquete de despliegue completo: binario + instalador + unit systemd + LEEME, + # bajo una carpeta raíz para que extraiga limpio. install.sh encuentra el binario + # (CloudRestoreAS-linux) y la unit (packaging/linux/) relativos a su ubicación. + STAGE="$RELEASE/CloudRestoreAS-linux" + PKG="$RELEASE/pkg-linux/CloudRestoreAS" + rm -rf "$RELEASE/pkg-linux" + mkdir -p "$PKG/packaging/linux" + cp -f "$STAGE" "$PKG/CloudRestoreAS-linux"; chmod +x "$PKG/CloudRestoreAS-linux" + cp -f "$ROOT/install.sh" "$PKG/install.sh"; chmod +x "$PKG/install.sh" + cp -f "$ROOT/packaging/linux/cloudrestoreas.service" "$PKG/packaging/linux/" + cp -f "$ROOT/packaging/LEEME.txt" "$PKG/LEEME.txt" + tar czf "$RELEASE/CloudRestoreAS-linux.tar.gz" -C "$RELEASE/pkg-linux" CloudRestoreAS + rm -rf "$RELEASE/pkg-linux" fi echo "Release en: $RELEASE" diff --git a/runner.py b/runner.py index 066627a..bed4803 100644 --- a/runner.py +++ b/runner.py @@ -23,9 +23,34 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace: action="store_true", help="Inicia el motor de restauración automáticamente", ) + parser.add_argument( + "--headless", + action="store_true", + help="Fuerza el modo sin interfaz (Qt offscreen) para servidores sin display", + ) return parser.parse_args(argv) +def _ensure_qt_platform(headless: bool = False) -> str: + """ + Selecciona el plugin de plataforma Qt en Linux. En un servidor headless (sin + DISPLAY/WAYLAND_DISPLAY) o con --headless, usa 'offscreen' para que la app + arranque y el motor trabaje sin X; con display usa el default ('xcb'). No toca + nada si el usuario ya fijó QT_QPA_PLATFORM, ni en Windows/macOS. + + Devuelve la plataforma forzada ("offscreen") o "" si se deja el default. + """ + if sys.platform in ("win32", "darwin"): + return "" + if os.environ.get("QT_QPA_PLATFORM"): + return os.environ["QT_QPA_PLATFORM"] + has_display = bool(os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY")) + if headless or not has_display: + os.environ["QT_QPA_PLATFORM"] = "offscreen" + return "offscreen" + return "" + + def _crash_log_targets() -> list[Path]: """Ubicaciones candidatas para el crash log, de más a menos accesible.""" targets: list[Path] = [] @@ -64,6 +89,9 @@ def _show_fatal(exc: BaseException) -> None: except Exception: pass try: + # Sin display, forzar offscreen para que crear la QApplication no falle + # también aquí (el diálogo no se verá, pero el crash log ya quedó escrito). + _ensure_qt_platform() from PySide6.QtWidgets import QApplication, QMessageBox app = QApplication.instance() or QApplication(sys.argv) @@ -100,6 +128,7 @@ def _run() -> int: from app.utils.logger import app_logger args = parse_args() + qt_platform = _ensure_qt_platform(headless=args.headless) launch = get_launch_options() initialize_env() @@ -109,7 +138,10 @@ def _run() -> int: app_logger.info("=" * 80) app_logger.info("CloudRestoreAS - Iniciando aplicación") app_logger.info(f"Directorio app: {ROOT_DIR}") - app_logger.info("Modo: ventana siempre visible; cerrar minimiza a bandeja") + if qt_platform == "offscreen": + app_logger.info("Modo: sin display → plataforma Qt 'offscreen' (motor headless)") + else: + app_logger.info("Modo: ventana siempre visible; cerrar minimiza a bandeja") if start_engine: app_logger.info("Modo: motor auto-inicio") if not panel_ok: