fix/windows-actualizacion-silenciosa #27
@@ -31,6 +31,7 @@ import {
|
||||
alignWindowsTask,
|
||||
checkWindowsArtifactUpdateSupport,
|
||||
normalizeWindowsPath,
|
||||
probeInstallerUpdateSupport,
|
||||
probeWindowsAgentProcess,
|
||||
probeWindowsElevation,
|
||||
probeWindowsTask,
|
||||
@@ -481,9 +482,13 @@ describe('comparación de rutas de Windows', () => {
|
||||
* agente viejo y sin agente nuevo.
|
||||
*/
|
||||
describe('checkWindowsArtifactUpdateSupport', () => {
|
||||
const SI = { answer: 'si', detail: '' } as const;
|
||||
const NO = { answer: 'no', detail: '' } as const;
|
||||
const NOSE = { answer: 'desconocido', detail: 'Get-Content: acceso denegado' } as const;
|
||||
|
||||
it('ACTUALIZAR con un instalador antiguo se rechaza en vez de romper el servidor', () => {
|
||||
try {
|
||||
checkWindowsArtifactUpdateSupport('update', false, '1.1.3', 'Principal');
|
||||
checkWindowsArtifactUpdateSupport('update', NO, '1.1.3', 'Principal');
|
||||
throw new Error('se esperaba que lanzara');
|
||||
} catch (e) {
|
||||
const err = e as InstallError;
|
||||
@@ -500,14 +505,89 @@ describe('checkWindowsArtifactUpdateSupport', () => {
|
||||
|
||||
it('INSTALAR limpio con el mismo artefacto solo avisa', () => {
|
||||
// Ahí no hay agente en marcha que perder, así que negarse solo estorbaría.
|
||||
const aviso = checkWindowsArtifactUpdateSupport('install', false, '1.1.3', 'Principal');
|
||||
const aviso = checkWindowsArtifactUpdateSupport('install', NO, '1.1.3', 'Principal');
|
||||
expect(aviso).toContain('1.1.3');
|
||||
expect(aviso).toMatch(/Se instala igual/);
|
||||
});
|
||||
|
||||
it('un artefacto con los arreglos no dice nada, en ninguno de los dos modos', () => {
|
||||
expect(checkWindowsArtifactUpdateSupport('update', true, '1.1.4', 'Principal')).toBe('');
|
||||
expect(checkWindowsArtifactUpdateSupport('install', true, '1.1.4', 'Principal')).toBe('');
|
||||
expect(checkWindowsArtifactUpdateSupport('update', SI, '1.1.4', 'Principal')).toBe('');
|
||||
expect(checkWindowsArtifactUpdateSupport('install', SI, '1.1.4', 'Principal')).toBe('');
|
||||
});
|
||||
|
||||
it('NO SABER no bloquea: es la prueba que faltaba y la que dejó 1.1.4 sin poder instalarse', () => {
|
||||
// La sonda anterior colapsaba cualquier fallo en "no lo soporta", y sobre esa lectura se
|
||||
// decidía un 409. Con un artefacto correcto, eso era un candado permanente.
|
||||
const aviso = checkWindowsArtifactUpdateSupport('update', NOSE, '1.1.4', 'Principal');
|
||||
expect(aviso).toMatch(/No se pudo determinar/);
|
||||
// Y dice POR QUÉ no se pudo, que es lo que evita adivinar la próxima vez.
|
||||
expect(aviso).toContain('acceso denegado');
|
||||
});
|
||||
|
||||
it('tampoco bloquea al instalar cuando no se pudo determinar', () => {
|
||||
expect(checkWindowsArtifactUpdateSupport('install', NOSE, '1.1.4', 'Principal')).toMatch(
|
||||
/No se pudo determinar/
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
/**
|
||||
* La sonda que lee el instalador del artefacto.
|
||||
*
|
||||
* Lo que se protege aquí es la distinción entre "no lo declara" y "no pude leerlo". La versión
|
||||
* anterior preguntaba por `(Get-Command …).Parameters`, funcionaba en una máquina de desarrollo y
|
||||
* fallaba en el servidor real; como cualquier fallo se leía como "no", el panel acabó rechazando un
|
||||
* artefacto correcto.
|
||||
*/
|
||||
describe('probeInstallerUpdateSupport', () => {
|
||||
const RUTA = 'C:\\Temp\\cras\\CloudRestoreAS\\install.ps1';
|
||||
|
||||
it('lee el texto del script en vez de compilarlo', async () => {
|
||||
const { sftp, commands } = fakeSftp(() => ({ code: 0, stdout: 'si' }));
|
||||
const r = await probeInstallerUpdateSupport(sftp as never, RUTA);
|
||||
expect(r.answer).toBe('si');
|
||||
|
||||
const script = Buffer.from(
|
||||
commands[0].split('-EncodedCommand ')[1] ?? '',
|
||||
'base64'
|
||||
).toString('utf16le');
|
||||
// Nada de reflexión: en Constrained Language Mode el acceso a .Parameters puede fallar
|
||||
// mientras `& install.ps1` sigue funcionando, que es lo que se observó en el servidor.
|
||||
expect(script).not.toContain('Get-Command');
|
||||
expect(script).not.toContain('.Parameters');
|
||||
expect(script).toContain('Get-Content');
|
||||
// Anclado a la DECLARACIÓN, para que un comentario que nombre el parámetro no cuente.
|
||||
expect(script).toContain('switch');
|
||||
});
|
||||
|
||||
it('un "no" limpio sigue siendo un no', async () => {
|
||||
const { sftp } = fakeSftp(() => ({ code: 0, stdout: 'no' }));
|
||||
expect((await probeInstallerUpdateSupport(sftp as never, RUTA)).answer).toBe('no');
|
||||
});
|
||||
|
||||
it('código de salida distinto de cero es DESCONOCIDO, nunca "no"', async () => {
|
||||
const { sftp } = fakeSftp(() => ({ code: 1, stdout: '', stderr: 'AmsiScanBuffer bloqueó' }));
|
||||
const r = await probeInstallerUpdateSupport(sftp as never, RUTA);
|
||||
expect(r.answer).toBe('desconocido');
|
||||
expect(r.detail).toContain('AmsiScanBuffer');
|
||||
});
|
||||
|
||||
it('stdout vacío con código 0 también es DESCONOCIDO', async () => {
|
||||
// Es la forma exacta en que fallaba la sonda vieja: sin salida, y leído como respuesta.
|
||||
const { sftp } = fakeSftp(() => ({ code: 0, stdout: ' ' }));
|
||||
expect((await probeInstallerUpdateSupport(sftp as never, RUTA)).answer).toBe('desconocido');
|
||||
});
|
||||
|
||||
it('el archivo que no existe se distingue de un instalador antiguo', async () => {
|
||||
const { sftp } = fakeSftp(() => ({ code: 0, stdout: 'desconocido|no existe el archivo' }));
|
||||
const r = await probeInstallerUpdateSupport(sftp as never, RUTA);
|
||||
expect(r.answer).toBe('desconocido');
|
||||
expect(r.detail).toBe('no existe el archivo');
|
||||
});
|
||||
|
||||
it('una salida inesperada no se interpreta como respuesta', async () => {
|
||||
const { sftp } = fakeSftp(() => ({ code: 0, stdout: 'WARNING: algo raro' }));
|
||||
expect((await probeInstallerUpdateSupport(sftp as never, RUTA)).answer).toBe('desconocido');
|
||||
});
|
||||
});
|
||||
|
||||
@@ -539,12 +619,22 @@ describe('sondas de ruta en Windows', () => {
|
||||
it('probeWindowsTask saca la ruta y la cuenta de la tarea', async () => {
|
||||
const { sftp } = psFake('si|C:\\Otra\\CloudRestoreAS.exe|SYSTEM');
|
||||
expect(await probeWindowsTask(sftp as never)).toEqual({
|
||||
answered: true,
|
||||
exists: true,
|
||||
execute: 'C:\\Otra\\CloudRestoreAS.exe',
|
||||
principal: 'SYSTEM'
|
||||
});
|
||||
});
|
||||
|
||||
it('una sonda que no responde no significa "no hay tarea"', async () => {
|
||||
// Con `answered: false` el llamador sabe que no se sabe. Antes, un comando fallido se leía
|
||||
// como "no hay tarea registrada" y de ahí salían decisiones sobre elevación y realineación.
|
||||
const { sftp } = fakeSftp(() => ({ code: 1, stdout: '' }));
|
||||
const r = await probeWindowsTask(sftp as never);
|
||||
expect(r.answered).toBe(false);
|
||||
expect(r.exists).toBe(false);
|
||||
});
|
||||
|
||||
it('probeWindowsTask sin tarea registrada', async () => {
|
||||
const { sftp } = psFake('no||');
|
||||
const r = await probeWindowsTask(sftp as never);
|
||||
|
||||
@@ -1041,7 +1041,7 @@ async function verifyLinuxDeployment(
|
||||
// Windows
|
||||
// ============================================================================
|
||||
|
||||
export type WindowsElevation = 'admin' | 'token-filtrado' | 'limitado';
|
||||
export type WindowsElevation = 'admin' | 'token-filtrado' | 'limitado' | 'desconocido';
|
||||
|
||||
export interface WindowsPrivilege {
|
||||
elevation: WindowsElevation;
|
||||
@@ -1075,7 +1075,22 @@ export async function probeWindowsElevation(sftp: SftpClient): Promise<WindowsPr
|
||||
)
|
||||
);
|
||||
|
||||
switch (probe.stdout.trim()) {
|
||||
const salida = probe.stdout.trim();
|
||||
// Sin respuesta no se afirma que la cuenta sea limitada: ese veredicto gobierna un 409, y
|
||||
// deducirlo de un comando que no contestó rechazaría instalaciones perfectamente válidas.
|
||||
if (probe.code !== 0 || !salida) {
|
||||
return {
|
||||
elevation: 'desconocido',
|
||||
label: 'privilegios no determinados',
|
||||
detail:
|
||||
`la sonda de privilegios no respondió (código ${probe.code})` +
|
||||
(probe.stderr ? `: ${truncate(probe.stderr)}` : '') +
|
||||
'. Se continúa: el propio instalador fallará con un mensaje claro si de verdad ' +
|
||||
'faltan permisos.'
|
||||
};
|
||||
}
|
||||
|
||||
switch (salida) {
|
||||
case 'admin':
|
||||
return { elevation: 'admin', label: 'administrador', detail: '' };
|
||||
case 'token-filtrado':
|
||||
@@ -1140,6 +1155,12 @@ export function windowsAgentExe(prefix: string): string {
|
||||
}
|
||||
|
||||
export interface WindowsProcessProbe {
|
||||
/**
|
||||
* La sonda obtuvo una respuesta del destino. En false NO se sabe si hay agente corriendo, y
|
||||
* quien decida un fallo duro debe exigir una respuesta afirmativa en vez de asumirla por
|
||||
* ausencia: leer "el comando no respondió" como "no hay proceso" tumba actualizaciones buenas.
|
||||
*/
|
||||
answered: boolean;
|
||||
running: boolean;
|
||||
/** Rutas de los ejecutables vivos. Vacío si corren pero no se pudo leer su ruta. */
|
||||
paths: string[];
|
||||
@@ -1173,13 +1194,19 @@ export async function probeWindowsAgentProcess(
|
||||
);
|
||||
|
||||
const out = probe.stdout.trim();
|
||||
// Sin respuesta no se sabe nada. Antes esto se leía como "detenido", que es una afirmación que
|
||||
// la sonda nunca hizo.
|
||||
if (probe.code !== 0 || !out) {
|
||||
return { answered: false, running: false, paths: [], fromPrefix: false };
|
||||
}
|
||||
if (!out.startsWith('corriendo')) {
|
||||
return { running: false, paths: [], fromPrefix: false };
|
||||
return { answered: true, running: false, paths: [], fromPrefix: false };
|
||||
}
|
||||
const joined = out.split('|')[1] ?? '';
|
||||
const paths = joined.split(';').map((p) => p.trim()).filter(Boolean);
|
||||
const wanted = windowsAgentExe(prefix);
|
||||
return {
|
||||
answered: true,
|
||||
running: true,
|
||||
paths,
|
||||
fromPrefix: paths.some((p) => sameWindowsPath(p, wanted))
|
||||
@@ -1187,6 +1214,8 @@ export async function probeWindowsAgentProcess(
|
||||
}
|
||||
|
||||
export interface WindowsTaskProbe {
|
||||
/** La sonda respondió. En false, `exists: false` significa "no sé", no "no hay tarea". */
|
||||
answered: boolean;
|
||||
exists: boolean;
|
||||
/** Ruta del ejecutable en la acción de la tarea. Es DÓNDE arranca el agente de verdad. */
|
||||
execute: string;
|
||||
@@ -1221,14 +1250,84 @@ export async function probeWindowsTask(sftp: SftpClient): Promise<WindowsTaskPro
|
||||
)
|
||||
);
|
||||
|
||||
const [flag, execute, principal] = probe.stdout.trim().split('|');
|
||||
const salida = probe.stdout.trim();
|
||||
if (probe.code !== 0 || !salida) {
|
||||
return { answered: false, exists: false, execute: '', principal: '' };
|
||||
}
|
||||
const [flag, execute, principal] = salida.split('|');
|
||||
return {
|
||||
answered: true,
|
||||
exists: flag === 'si',
|
||||
execute: (execute ?? '').trim(),
|
||||
principal: (principal ?? '').trim()
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Respuesta de una sonda que puede no saber.
|
||||
*
|
||||
* `desconocido` NO es `no`. Confundirlos es lo que dejó bloqueadas las actualizaciones con un
|
||||
* artefacto perfectamente bueno: la sonda anterior colapsaba cualquier fallo —una excepción, un
|
||||
* código de salida distinto de cero, stdout vacío— en "el instalador no lo soporta", y sobre esa
|
||||
* lectura se decidía un 409. Mientras solo elegía entre dos banderas el falso negativo degradaba;
|
||||
* en cuanto gobernó un rechazo, se volvió un candado.
|
||||
*/
|
||||
export interface ProbeAnswer {
|
||||
answer: 'si' | 'no' | 'desconocido';
|
||||
/** Por qué no se pudo determinar. Vacío cuando hay respuesta. */
|
||||
detail: string;
|
||||
}
|
||||
|
||||
/**
|
||||
* ¿El `install.ps1` del artefacto declara `-UpdateInPlace`?
|
||||
*
|
||||
* Se pregunta leyendo el TEXTO del script, no pidiéndole a PowerShell que lo compile y exponga sus
|
||||
* parámetros. `(Get-Command …).Parameters` funcionaba en una máquina de desarrollo y fallaba en el
|
||||
* servidor real; el candidato más probable es Constrained Language Mode (AppLocker/WDAC son
|
||||
* habituales en servidores endurecidos), que restringe el acceso a propiedades de objetos .NET
|
||||
* mientras `& install.ps1` sigue funcionando — justo lo que se observaba. Un `-match` sobre el
|
||||
* contenido no compila nada, no toca reflexión y ninguna política lo bloquea.
|
||||
*
|
||||
* Se ancla a la DECLARACIÓN (`[switch]$UpdateInPlace`) y no a una mención suelta, para que un
|
||||
* comentario que nombre el parámetro no dé un falso positivo.
|
||||
*/
|
||||
export async function probeInstallerUpdateSupport(
|
||||
sftp: SftpClient,
|
||||
installerPath: string
|
||||
): Promise<ProbeAnswer> {
|
||||
const probe = await execRemote(
|
||||
sftp,
|
||||
psEncoded(
|
||||
`$p = '${installerPath}'; ` +
|
||||
"if (-not (Test-Path -LiteralPath $p)) { Write-Output 'desconocido|no existe el archivo'; exit 0 }; " +
|
||||
'try { ' +
|
||||
'$t = Get-Content -LiteralPath $p -Raw -ErrorAction Stop; ' +
|
||||
// El [regex]::IsMatch evita depender de $matches y del operador -match, que en
|
||||
// modo restringido puede comportarse distinto.
|
||||
'if ([regex]::IsMatch($t, \'\\[switch\\]\\s*\\$UpdateInPlace\')) ' +
|
||||
"{ Write-Output 'si' } else { Write-Output 'no' } } " +
|
||||
"catch { Write-Output ('desconocido|' + $_.Exception.Message) }"
|
||||
)
|
||||
);
|
||||
|
||||
const salida = probe.stdout.trim();
|
||||
// El código de salida y stderr cuentan: un execRemote que falla deja stdout vacío, y leer eso
|
||||
// como una respuesta es precisamente el error que se está corrigiendo.
|
||||
if (probe.code !== 0 || !salida) {
|
||||
return {
|
||||
answer: 'desconocido',
|
||||
detail:
|
||||
`la sonda no respondió (código ${probe.code})` +
|
||||
(probe.stderr ? `: ${truncate(probe.stderr)}` : '')
|
||||
};
|
||||
}
|
||||
if (salida === 'si' || salida === 'no') return { answer: salida, detail: '' };
|
||||
return {
|
||||
answer: 'desconocido',
|
||||
detail: salida.startsWith('desconocido|') ? salida.slice(12) : truncate(salida)
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* ¿Se puede desplegar este artefacto en Windows sin romper el servidor?
|
||||
*
|
||||
@@ -1250,11 +1349,22 @@ export async function probeWindowsTask(sftp: SftpClient): Promise<WindowsTaskPro
|
||||
*/
|
||||
export function checkWindowsArtifactUpdateSupport(
|
||||
mode: InstallMode,
|
||||
supportsInPlace: boolean,
|
||||
soporte: ProbeAnswer,
|
||||
version: string,
|
||||
targetName: string
|
||||
): string {
|
||||
if (supportsInPlace) return '';
|
||||
if (soporte.answer === 'si') return '';
|
||||
|
||||
// No saber NO es motivo para bloquear. Un fallo de diagnóstico no puede impedir el trabajo: se
|
||||
// sigue con el comportamiento anterior y se deja dicho por qué no se pudo determinar, que es el
|
||||
// dato que convierte la próxima sorpresa en un diagnóstico de diez segundos.
|
||||
if (soporte.answer === 'desconocido') {
|
||||
return (
|
||||
`No se pudo determinar si el install.ps1 de ${version} soporta -UpdateInPlace ` +
|
||||
`(${soporte.detail || 'sin detalle'}). Se instala con el modo de arranque normal en vez ` +
|
||||
'de bloquear: no saberlo no es lo mismo que saber que no.'
|
||||
);
|
||||
}
|
||||
|
||||
const aviso =
|
||||
`El artefacto ${version} trae un install.ps1 anterior a los arreglos de actualización ` +
|
||||
@@ -1602,21 +1712,13 @@ async function installWindows(
|
||||
//
|
||||
// Pero solo si el instalador DEL ARTEFACTO lo declara: el parámetro existe desde 1.1.3, e
|
||||
// install.ps1 usa [CmdletBinding()], así que pasárselo a uno anterior falla con
|
||||
// NamedParameterNotFound SIN ejecutar una sola línea. Se le pregunta a PowerShell por el
|
||||
// `param()` del propio script en vez de mantener una tabla de versiones aquí.
|
||||
// NamedParameterNotFound SIN ejecutar una sola línea.
|
||||
const installerPs1 = `${remoteDir}\\CloudRestoreAS\\install.ps1`;
|
||||
const supportsProbe = await execRemote(
|
||||
sftp,
|
||||
psEncoded(
|
||||
`if ((Get-Command '${installerPs1}').Parameters.ContainsKey('UpdateInPlace')) ` +
|
||||
"{'si'} else {'no'}"
|
||||
)
|
||||
);
|
||||
const supportsInPlace = supportsProbe.stdout.trim() === 'si';
|
||||
const soporte = await probeInstallerUpdateSupport(sftp, installerPs1);
|
||||
|
||||
const avisoArtefacto = checkWindowsArtifactUpdateSupport(
|
||||
request.mode,
|
||||
supportsInPlace,
|
||||
soporte,
|
||||
release.version,
|
||||
target.name
|
||||
);
|
||||
@@ -1624,7 +1726,7 @@ async function installWindows(
|
||||
await appendInstallStep(runId, 'instalador-antiguo', true, avisoArtefacto);
|
||||
}
|
||||
|
||||
const inPlaceUpdate = request.mode === 'update' && supportsInPlace;
|
||||
const inPlaceUpdate = request.mode === 'update' && soporte.answer === 'si';
|
||||
const flag = inPlaceUpdate
|
||||
? ' -UpdateInPlace'
|
||||
: autostart === 'none'
|
||||
|
||||
Reference in New Issue
Block a user