ADUANASOFT/PANEL_BASES_ANEXO24
13
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feature/cras-update-in-place (#22)

Browse Source 
Reviewed-on: #22
Co-authored-by: hreyes <hreyes@aduanasoft.com.mx>
Co-committed-by: hreyes <hreyes@aduanasoft.com.mx>
This commit is contained in:
hreyes
2026-07-31 13:28:45 +00:00
committed by acazares
parent 84a4c5e7e0
commit c4de2f1438
16 changed files with 835 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

200
src/lib/server/cras-install.ts
View File

@@ -504,21 +504,37 @@ async function installLinux(
// antes de transferir 270 MB, porque fallar después es desperdicio y deja basura en /tmp.
const autostartMode = request.autostart ?? 'service';
const privileged = await probeLinuxElevation(sftp);
if (autostartMode !== 'user-service' && !privileged.prefix && privileged.elevation !== 'root') {
throw new InstallError(
409,
`El usuario '${target.ssh_username}' no puede elevar privilegios en este servidor: ` +
`${privileged.detail} Para instalar en ${installPath} y registrar el servicio de ` +
'sistema hacen falta. Alternativas: usar una cuenta root, dar NOPASSWD a ese ' +
'usuario, o elegir el arranque "Servicio de usuario", que instala en el home y no ' +
'necesita privilegios.'
);
const canElevate = privileged.elevation === 'root' || privileged.elevation === 'sudo-sin-password';
// Sin elevación quedan dos vías antes de rendirse, y ambas evitan pedirle la contraseña a
// sudo. `user-service` instala en el home; la actualización en sitio deja el unit como está
// y solo reemplaza el binario, que es lo único que una actualización necesita de verdad.
let inPlaceUpdate = false;
if (!canElevate && autostartMode !== 'user-service') {
if (request.mode !== 'update') {
throw new InstallError(
409,
`El usuario '${target.ssh_username}' no puede elevar privilegios: ` +
`${privileged.detail} Una instalación NUEVA en ${installPath} necesita ` +
'privilegios para registrar el servicio de sistema. Usa el arranque ' +
'"Servicio de usuario", que instala en el home y no los necesita.'
);
}
const inPlace = await probeInPlaceUpdate(sftp, installPath, target.ssh_username);
if (!inPlace.ok) {
throw new InstallError(
409,
`No se puede actualizar ${target.name} sin privilegios: ${inPlace.reason}`
);
}
inPlaceUpdate = true;
}
await appendInstallStep(
runId,
'precondiciones',
true,
`${systemEvidence}, privilegios=${privileged.label}`
`${systemEvidence}, privilegios=${privileged.label}` +
(inPlaceUpdate ? ', vía=actualización en sitio sin privilegios' : '')
);
// Antes de transferir: si es una actualización, confirmar que ahí VIVE una instalación.
@@ -591,7 +607,13 @@ async function installLinux(
}
const autostart = request.autostart ?? 'service';
const installerFlags = autostart === 'none' ? '' : ` --${autostart}`;
// En la vía sin privilegios se usa --update-in-place, que no toca /etc ni systemctl:
// solo reemplaza el binario y señaliza al proceso para que Restart=always lo relevante.
const installerFlags = inPlaceUpdate
? ' --update-in-place'
: autostart === 'none'
? ''
: ` --${autostart}`;
// PREFIX es variable de entorno en install.sh, no un flag. La ruta no es secreta, así
// que pasarla por la línea de comandos está bien; el token sí va por archivo.
const installCmd =
@@ -601,6 +623,17 @@ async function installLinux(
await appendInstallStep(runId, 'ejecutar-instalador', true, `install.sh${installerFlags}`);
const install = await execRemote(sftp, installCmd, INSTALL_EXEC_TIMEOUT_MS);
// 75 = EX_TEMPFAIL, que install.sh reserva para "hay una restauración en curso". Es un
// conflicto de estado, no un fallo: hay que reintentar, no investigar. Con el 502 genérico
// parecía que la instalación se había roto, y el operador iría a buscar la causa equivocada.
if (install.code === 75) {
throw new InstallError(
409,
`${target.name} está restaurando un respaldo ahora mismo, así que no se actualizó ` +
'para no interrumpirlo —eso dejaría ese respaldo vetado y la base en ' +
'SINGLE_USER—. Reintenta cuando termine.'
);
}
if (install.code !== 0) {
throw new InstallError(
502,
@@ -609,7 +642,9 @@ async function installLinux(
}
// --- Verificación del despliegue -------------------------------------
await verifyLinuxDeployment(sftp, runId, release, privileged, autostart, installPath);
await verifyLinuxDeployment(
sftp, runId, release, privileged, autostart, installPath, inPlaceUpdate
);
} finally {
// Limpieza siempre: el panel.env trae el token en claro. Si falla NO se silencia —
// significa que el token se quedó en el servidor y alguien tiene que ir a borrarlo.
@@ -696,6 +731,107 @@ export async function probeLinuxElevation(sftp: SftpClient): Promise<LinuxPrivil
};
}
/**
* Propiedades de un unit de systemd, leídas con `systemctl show`, que NO requiere privilegios
* (a diferencia de start/stop).
*
* Vive aquí y se comparte con la sonda de verificación porque ya hubo una divergencia por copiar
* esta lógica: la resolución de elevación existía duplicada en cras-verify y en cras-install, y
* las dos pantallas acabaron diciendo cosas distintas del mismo servidor.
*
* `User=` vacío significa root: es lo que systemd asume cuando el unit no lo declara. Tratarlo
* como cadena vacía haría creer que el servicio corre como un usuario sin nombre.
*/
export async function readUnitProps(
sftp: SftpClient,
unitName: string,
props: string[]
): Promise<Map<string, string>> {
const flags = props.map((name) => `-p ${name}`).join(' ');
const out = await execRemote(sftp, `systemctl show ${flags} ${unitName} 2>/dev/null`);
const parsed = new Map<string, string>();
for (const line of out.stdout.split('\n')) {
const at = line.indexOf('=');
if (at <= 0) continue;
parsed.set(line.slice(0, at).trim(), line.slice(at + 1).trim());
}
return parsed;
}
/** Usuario efectivo de un unit: `User=` vacío es root, igual que lo interpreta systemd. */
export function unitUserOrRoot(props: Map<string, string>): string {
return props.get('User') || 'root';
}
/**
* ¿Se puede ACTUALIZAR en su sitio sin privilegios? Devuelve el motivo si no.
*
* Existe porque hay entornos donde no se usa root en absoluto. Una actualización con el unit ya
* registrado no necesita privilegios si se cumplen tres cosas, y las tres se comprueban por SSH
* antes de subir 270 MB:
*
* 1. `install` puede reemplazar el binario. Y no exige permiso sobre el ARCHIVO: a diferencia de
* `cp`, desvincula el destino antes de crearlo (por eso `make install` funciona sobre binarios
* en ejecución), así que lo que hace falta es escritura en el DIRECTORIO.
* 2. El unit corre con el mismo usuario de la sesión SSH, para poder señalizar al proceso. Si
* quedó con `User=root` —porque alguien instaló desde un `sudo -i`— esta vía no aplica.
* 3. El unit trae `Restart=always`, que es quien vuelve a levantarlo con el binario nuevo. Sin
* eso, señalizarlo lo dejaría muerto.
*/
export async function probeInPlaceUpdate(
sftp: SftpClient,
installPath: string,
sshUsername: string
): Promise<{ ok: boolean; reason: string }> {
const writable = await execRemote(
sftp,
`test -w ${shQuote(installPath)} && echo si || echo no`
);
if (writable.stdout.trim() !== 'si') {
const owner = await execRemote(sftp, `stat -c '%U' ${shQuote(installPath)} 2>/dev/null`);
return {
ok: false,
reason:
`'${sshUsername}' no puede escribir en ${installPath} (dueño: ` +
`${owner.stdout.trim() || 'desconocido'}), así que no puede reemplazar el binario.`
};
}
const props = await readUnitProps(sftp, 'cloudrestoreas', ['User', 'Restart']);
const unitUser = unitUserOrRoot(props);
if (unitUser !== sshUsername) {
return {
ok: false,
reason:
`el servicio corre como '${unitUser}' y la sesión es de '${sshUsername}', así que ` +
'esta cuenta no puede reiniciarlo sin privilegios.'
};
}
if (props.get('Restart') !== 'always') {
return {
ok: false,
reason:
`el unit tiene Restart=${props.get('Restart') || 'desconocido'}; sin Restart=always ` +
'nadie volvería a levantar el agente tras actualizarlo.'
};
}
// Se mira aquí además de en install.sh para no subir 270 MB en balde.
const busy = await execRemote(
sftp,
`test -d ${shQuote(`${installPath}/Temp`)} && ls -A ${shQuote(`${installPath}/Temp`)} 2>/dev/null | head -1`
);
if (busy.stdout.trim()) {
return {
ok: false,
reason:
'hay una restauración en curso. Interrumpirla dejaría ese respaldo vetado para ' +
'siempre y la base en SINGLE_USER, así que se prefiere esperar. Reintenta luego.'
};
}
return { ok: true, reason: '' };
}
async function verifyLinuxDeployment(
sftp: SftpClient,
runId: number,
@@ -705,19 +841,36 @@ async function verifyLinuxDeployment(
// Se llama installPath y no `prefix` a propósito: en el cuerpo convive con
// `privileged.prefix`, que es el prefijo de ELEVACIÓN. Dos cosas distintas con el mismo
// nombre en el mismo alcance es exactamente donde se cuela un bug silencioso.
installPath: string
installPath: string,
inPlaceUpdate = false
): Promise<void> {
// El sello config/.version lo escribe el bootstrap del binario; es más confiable que
// stdout de --version, sobre todo por paridad con Windows (console=False).
const stamp = await execRemote(
sftp,
`cat ${shQuote(`${installPath}/config/.version`)} 2>/dev/null`
);
const deployed = stamp.stdout.trim();
//
// En la vía en sitio se OMITE el bootstrap y el sello lo escribe el proceso al reiniciarse,
// así que durante unos segundos sigue teniendo la versión ANTERIOR. Leerlo una sola vez
// convertía una actualización correcta en un fallo "reporta 1.0.0, se esperaba 1.1.1", con el
// agente ya actualizado y corriendo. Se sondea hasta que coincida, o hasta agotar el margen.
let deployed = '';
const stampAttempts = inPlaceUpdate ? 15 : 1;
for (let attempt = 0; attempt < stampAttempts; attempt += 1) {
if (attempt > 0) await new Promise((resolve) => setTimeout(resolve, 2000));
const stamp = await execRemote(
sftp,
`cat ${shQuote(`${installPath}/config/.version`)} 2>/dev/null`
);
deployed = stamp.stdout.trim();
// Vacío = todavía no lo escribió, y eso ya se toleraba antes.
if (!deployed || deployed === release.version) break;
}
if (deployed && deployed !== release.version) {
throw new InstallError(
502,
`El binario desplegado reporta la versión ${deployed}, se esperaba ${release.version}`
`El binario desplegado reporta la versión ${deployed}, se esperaba ${release.version}. ` +
(inPlaceUpdate
? 'El sello no cambió tras reiniciar el agente, así que el proceso puede seguir ' +
'ejecutando el binario anterior.'
: '')
);
}
await appendInstallStep(
@@ -733,6 +886,9 @@ async function verifyLinuxDeployment(
// usuario, y preguntarlo como root apuntaría al bus equivocado y respondería 'inactive'
// sobre un servicio que sí está corriendo. XDG_RUNTIME_DIR va explícito porque un `exec` de
// SSH no es una sesión de login y no siempre lo trae.
// En la vía en sitio el agente acaba de reiniciarse: `is-active` puede devolver 'activating'
// durante unos segundos, y eso no es un fallo. install.sh ya confirmó que el proceso volvió,
// así que el proceso vivo es la evidencia que manda.
const userMode = autostart === 'user-service';
const active = await execRemote(
sftp,
@@ -745,7 +901,7 @@ async function verifyLinuxDeployment(
// En modo usuario el arranque puede haber quedado por cron (@reboot) en vez de systemd,
// cuando el destino no permite lingering. Ahí no hay unit que consultar y el proceso se
// comprueba directamente, que es lo que de verdad importa.
if (userMode) {
if (userMode || inPlaceUpdate) {
// El ancla ^ es obligatoria: sin ella el `sh -c` que corre este mismo pgrep lleva la
// ruta en su propia línea de comandos y haría match consigo mismo, reportando vivo un
// agente que no arrancó.
@@ -758,7 +914,9 @@ async function verifyLinuxDeployment(
runId,
'verificar-servicio',
true,
'proceso vivo (arranque por cron; systemd de usuario no disponible)'
inPlaceUpdate
? `proceso vivo con el binario nuevo (unit intacto, estado: ${state})`
: 'proceso vivo (arranque por cron; systemd de usuario no disponible)'
);
return;
}