Stop reporting supported Linux hosts as an unsupported remote platform (#12209)
Co-authored-by: Orca <help@stably.ai>
This commit is contained in:
Neil
GitHub
parent
3d68212f7b
commit
1dbf55e4df
|
|
@ -1,4 +1,4 @@
|
|||
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
import type { SshConnection } from './ssh-connection'
|
||||
|
||||
const execCommandMock = vi.hoisted(() => vi.fn())
|
||||
|
|
@ -16,9 +16,19 @@ function decodePowerShellCommand(command: string): string {
|
|||
return match ? Buffer.from(match[1], 'base64').toString('utf16le') : ''
|
||||
}
|
||||
|
||||
/** OpenSSH refuses session channels past MaxSessions with reason 2 + "open failed". */
|
||||
function maxSessionsError(): Error {
|
||||
return Object.assign(new Error('(SSH) Channel open failure: open failed'), { reason: 2 })
|
||||
}
|
||||
|
||||
describe('detectRemoteHostPlatform', () => {
|
||||
beforeEach(() => {
|
||||
execCommandMock.mockReset()
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
|
||||
it('detects POSIX hosts from uname output', async () => {
|
||||
|
|
@ -109,3 +119,120 @@ describe('detectRemoteHostPlatform', () => {
|
|||
expect(usedWhitespaceFieldSplit).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('detectRemoteHostPlatform failure reporting', () => {
|
||||
beforeEach(() => {
|
||||
execCommandMock.mockReset()
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
|
||||
it('does not misreport a refused exec channel as an unsupported platform', async () => {
|
||||
execCommandMock.mockRejectedValue(maxSessionsError())
|
||||
|
||||
// The host is linux-x64 and fully supported; the probe never ran.
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/open failed/iu)
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toMatchObject({
|
||||
cause: expect.objectContaining({ reason: 2 })
|
||||
})
|
||||
// Both probes run: the second gets a fresh session-channel retry budget.
|
||||
expect(execCommandMock).toHaveBeenCalledTimes(4)
|
||||
})
|
||||
|
||||
it('still detects Windows when the uname probe hits the session limit', async () => {
|
||||
execCommandMock
|
||||
.mockRejectedValueOnce(maxSessionsError())
|
||||
.mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ Windows AMD64\r\n')
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).resolves.toMatchObject({
|
||||
relayPlatform: 'win32-x64'
|
||||
})
|
||||
})
|
||||
|
||||
it('skips the second probe when the first channel never confirmed close', async () => {
|
||||
const error = Object.assign(new Error('boom'), { sshChannelCloseConfirmed: false })
|
||||
execCommandMock.mockRejectedValueOnce(error)
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toBe(error)
|
||||
expect(execCommandMock).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('skips the second probe when the first was cancelled', async () => {
|
||||
const error = Object.assign(new Error('SSH operation was cancelled'), { name: 'AbortError' })
|
||||
execCommandMock.mockRejectedValueOnce(error)
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toBe(error)
|
||||
expect(execCommandMock).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('prefers a refused channel over the other probe non-zero exit', async () => {
|
||||
execCommandMock
|
||||
.mockRejectedValueOnce(new Error('Command "sh -c ..." failed (exit 127): sh: not found'))
|
||||
.mockRejectedValueOnce(maxSessionsError())
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/open failed/u)
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.not.toThrow(/exit 127/u)
|
||||
})
|
||||
|
||||
it('prefers unrecognized uname output over a failed PowerShell probe', async () => {
|
||||
execCommandMock
|
||||
.mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ Linux')
|
||||
.mockRejectedValueOnce(new Error('powershell.exe: not found'))
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/__ORCA_REMOTE_PLATFORM__ Linux/u)
|
||||
})
|
||||
|
||||
it('reports the raw probe output when a POSIX host yields no marker line', async () => {
|
||||
// Restricted shell / ForceCommand: the probe command is swallowed, banner only.
|
||||
execCommandMock.mockResolvedValue('Welcome to pc-server05\n')
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).rejects.toThrow(/pc-server05/u)
|
||||
})
|
||||
|
||||
it('truncates a long banner in the thrown message but logs a longer tail', async () => {
|
||||
execCommandMock.mockResolvedValue(`${'banner line\n'.repeat(500)}goodbye\n`)
|
||||
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
|
||||
|
||||
const error = await detectRemoteHostPlatform(conn).catch((err: Error) => err)
|
||||
|
||||
expect(error).toBeInstanceOf(Error)
|
||||
expect((error as Error).message).not.toContain('\n')
|
||||
expect((error as Error).message.length).toBeLessThanOrEqual(300)
|
||||
expect(String(warnSpy.mock.calls[0]?.[0]).length).toBeGreaterThan(600)
|
||||
})
|
||||
|
||||
it('returns null when a parsed uname is genuinely unsupported', async () => {
|
||||
execCommandMock
|
||||
.mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ FreeBSD x86_64\n')
|
||||
.mockRejectedValueOnce(new Error('powershell.exe: not found'))
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).resolves.toBeNull()
|
||||
})
|
||||
|
||||
it('does not call an unmappable uname unsupported when PowerShell was refused', async () => {
|
||||
// Cygwin sh on a win32-x64 host: only PowerShell can settle it, and it never ran.
|
||||
execCommandMock
|
||||
.mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ CYGWIN_NT-10.0 x86_64\n')
|
||||
.mockRejectedValueOnce(maxSessionsError())
|
||||
|
||||
const error = await detectRemoteHostPlatform(conn).catch((err: unknown) => err)
|
||||
|
||||
expect(error).toBeInstanceOf(Error)
|
||||
expect((error as Error).message).toMatch(/open failed/iu)
|
||||
expect((error as Error).message).not.toMatch(/unsupported/iu)
|
||||
expect((error as Error).cause).toMatchObject({ reason: 2 })
|
||||
})
|
||||
|
||||
it('falls through to PowerShell for a Cygwin uname it cannot map', async () => {
|
||||
execCommandMock
|
||||
.mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ CYGWIN_NT-10.0 x86_64\n')
|
||||
.mockResolvedValueOnce('__ORCA_REMOTE_PLATFORM__ Windows AMD64\r\n')
|
||||
|
||||
await expect(detectRemoteHostPlatform(conn)).resolves.toMatchObject({
|
||||
relayPlatform: 'win32-x64'
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
|
|||
|
|
@ -5,27 +5,128 @@ import {
|
|||
} from '../../shared/process-output-field-scanner'
|
||||
import { parseUnameToRelayPlatform, type RelayPlatform } from './relay-protocol'
|
||||
import { execCommand } from './ssh-relay-deploy-helpers'
|
||||
import { isUnconfirmedSshCommandTermination } from './ssh-relay-exec-command'
|
||||
import { isSshSessionLimitError } from './ssh-session-limit-error'
|
||||
import { getRemoteHostPlatform, type RemoteHostPlatform } from './ssh-remote-platform'
|
||||
import { powerShellCommand } from './ssh-remote-powershell'
|
||||
|
||||
const PLATFORM_PROBE_MARKER = '__ORCA_REMOTE_PLATFORM__'
|
||||
const MAX_UNAME_FIELD_CHARS = 64
|
||||
const MAX_THROWN_OUTPUT_CHARS = 200
|
||||
const MAX_LOGGED_OUTPUT_CHARS = 1000
|
||||
const EXEC_TIMEOUT_MESSAGE = /timed out after \d+s$/u
|
||||
|
||||
type PlatformProbeOutcome =
|
||||
| { kind: 'detected'; platform: RelayPlatform }
|
||||
| { kind: 'unsupported'; uname: string }
|
||||
| { kind: 'unparsed'; output: string }
|
||||
| { kind: 'failed'; error: unknown }
|
||||
|
||||
export async function detectRemoteHostPlatform(
|
||||
conn: SshConnection,
|
||||
options?: { signal?: AbortSignal }
|
||||
): Promise<RemoteHostPlatform | null> {
|
||||
const unamePlatform = await detectUnamePlatform(conn, options?.signal)
|
||||
if (unamePlatform) {
|
||||
return getRemoteHostPlatform(unamePlatform)
|
||||
const uname = await detectUnamePlatform(conn, options?.signal)
|
||||
if (uname.kind === 'detected') {
|
||||
return getRemoteHostPlatform(uname.platform)
|
||||
}
|
||||
const windowsPlatform = await detectWindowsPlatform(conn, options?.signal)
|
||||
return windowsPlatform ? getRemoteHostPlatform(windowsPlatform) : null
|
||||
if (uname.kind === 'failed' && shouldAbandonAfterUnameProbe(uname.error)) {
|
||||
throw uname.error
|
||||
}
|
||||
const windows = await detectWindowsPlatform(conn, options?.signal)
|
||||
if (windows.kind === 'detected') {
|
||||
return getRemoteHostPlatform(windows.platform)
|
||||
}
|
||||
// Why: only the PowerShell probe can settle a uname the parser cannot map
|
||||
// (Cygwin, say), so a refused or timed-out channel leaves it unsettled.
|
||||
const windowsProbeNeverRan = windows.kind === 'failed' && isTransportShapedError(windows.error)
|
||||
if ((uname.kind === 'unsupported' && !windowsProbeNeverRan) || windows.kind === 'unsupported') {
|
||||
const reported = uname.kind === 'unsupported' ? uname.uname : probeUname(windows)
|
||||
console.warn(`[ssh-relay] Remote reported an unsupported platform: ${reported}`)
|
||||
return null
|
||||
}
|
||||
console.warn(
|
||||
`[ssh-relay] Remote platform detection failed (uname probe: ${uname.kind}, PowerShell probe: ${windows.kind}). ` +
|
||||
`Remote output: "${summarizeProbeOutput(probeEvidence(uname) || probeEvidence(windows), MAX_LOGGED_OUTPUT_CHARS)}"`
|
||||
)
|
||||
throw undetectedPlatformError(uname, windows)
|
||||
}
|
||||
|
||||
// Why: an unconfirmed close still holds the sshd session slot, so a second
|
||||
// probe only burns another exec timeout before being refused too.
|
||||
function shouldAbandonAfterUnameProbe(error: unknown): boolean {
|
||||
return (
|
||||
(error instanceof Error && error.name === 'AbortError') ||
|
||||
isUnconfirmedSshCommandTermination(error)
|
||||
)
|
||||
}
|
||||
|
||||
/** Precedence: transport failure from either probe, then uname, then PowerShell. */
|
||||
function undetectedPlatformError(
|
||||
uname: PlatformProbeOutcome,
|
||||
windows: PlatformProbeOutcome
|
||||
): Error {
|
||||
for (const outcome of [uname, windows]) {
|
||||
if (outcome.kind === 'failed' && isTransportShapedError(outcome.error)) {
|
||||
return wrapProbeError(outcome.error)
|
||||
}
|
||||
}
|
||||
if (uname.kind === 'failed') {
|
||||
return wrapProbeError(uname.error)
|
||||
}
|
||||
if (uname.kind === 'unparsed') {
|
||||
return unrecognizedOutputError(uname.output)
|
||||
}
|
||||
if (windows.kind === 'failed') {
|
||||
return wrapProbeError(windows.error)
|
||||
}
|
||||
return unrecognizedOutputError(probeOutput(windows))
|
||||
}
|
||||
|
||||
// Why: a refused or timed-out channel explains the failure better than the
|
||||
// other probe's mundane non-zero exit (e.g. "sh: not found" on Windows).
|
||||
function isTransportShapedError(error: unknown): boolean {
|
||||
return (
|
||||
isSshSessionLimitError(error) ||
|
||||
isUnconfirmedSshCommandTermination(error) ||
|
||||
(error instanceof Error && EXEC_TIMEOUT_MESSAGE.test(error.message))
|
||||
)
|
||||
}
|
||||
|
||||
function wrapProbeError(error: unknown): Error {
|
||||
const message = error instanceof Error ? error.message : String(error)
|
||||
return new Error(`Could not detect the remote platform: ${message}`, { cause: error })
|
||||
}
|
||||
|
||||
function unrecognizedOutputError(output: string): Error {
|
||||
return new Error(
|
||||
`Remote platform probe returned no recognizable output. Remote output: "${summarizeProbeOutput(output, MAX_THROWN_OUTPUT_CHARS)}"`
|
||||
)
|
||||
}
|
||||
|
||||
function probeOutput(outcome: PlatformProbeOutcome): string {
|
||||
return outcome.kind === 'unparsed' ? outcome.output : ''
|
||||
}
|
||||
|
||||
function probeUname(outcome: PlatformProbeOutcome): string {
|
||||
return outcome.kind === 'unsupported' ? outcome.uname : ''
|
||||
}
|
||||
|
||||
function probeEvidence(outcome: PlatformProbeOutcome): string {
|
||||
return probeOutput(outcome) || probeUname(outcome)
|
||||
}
|
||||
|
||||
// Why: the marker is printed last, so the tail holds the evidence; collapsing
|
||||
// CR/LF keeps a Windows banner from becoming a multi-line renderer message.
|
||||
function summarizeProbeOutput(output: string, maxChars: number): string {
|
||||
const collapsed = output.replace(/\s+/gu, ' ').trim()
|
||||
return collapsed.length > maxChars ? `…${collapsed.slice(-maxChars)}` : collapsed
|
||||
}
|
||||
|
||||
async function detectUnamePlatform(
|
||||
conn: SshConnection,
|
||||
signal?: AbortSignal
|
||||
): Promise<RelayPlatform | null> {
|
||||
): Promise<PlatformProbeOutcome> {
|
||||
try {
|
||||
// Why: Remote startup output may omit its trailing newline and must not absorb the marker.
|
||||
const command = `printf '\\n%s ' '${PLATFORM_PROBE_MARKER}'; uname -sm`
|
||||
|
|
@ -33,16 +134,16 @@ async function detectUnamePlatform(
|
|||
? await execCommand(conn, command, { signal })
|
||||
: await execCommand(conn, command)
|
||||
return parseRemotePlatformOutput(output)
|
||||
} catch {
|
||||
} catch (error) {
|
||||
signal?.throwIfAborted()
|
||||
return null
|
||||
return { kind: 'failed', error }
|
||||
}
|
||||
}
|
||||
|
||||
async function detectWindowsPlatform(
|
||||
conn: SshConnection,
|
||||
signal?: AbortSignal
|
||||
): Promise<RelayPlatform | null> {
|
||||
): Promise<PlatformProbeOutcome> {
|
||||
try {
|
||||
const script = [
|
||||
'$arch = $env:PROCESSOR_ARCHITECTURE',
|
||||
|
|
@ -56,13 +157,14 @@ async function detectWindowsPlatform(
|
|||
...(signal ? { signal } : {})
|
||||
})
|
||||
return parseRemotePlatformOutput(output)
|
||||
} catch {
|
||||
} catch (error) {
|
||||
signal?.throwIfAborted()
|
||||
return null
|
||||
return { kind: 'failed', error }
|
||||
}
|
||||
}
|
||||
|
||||
function parseRemotePlatformOutput(output: string): RelayPlatform | null {
|
||||
function parseRemotePlatformOutput(output: string): PlatformProbeOutcome {
|
||||
let unsupportedUname = ''
|
||||
// Why: SSH startup noise can resemble valid probe output and select the wrong relay.
|
||||
for (const line of iterateProcessOutputLines(output)) {
|
||||
const parts = getProcessOutputFields(line, 3)
|
||||
|
|
@ -71,8 +173,16 @@ function parseRemotePlatformOutput(output: string): RelayPlatform | null {
|
|||
}
|
||||
const platform = parseUnameToRelayPlatform(parts[1], parts[2])
|
||||
if (platform) {
|
||||
return platform
|
||||
return { kind: 'detected', platform }
|
||||
}
|
||||
unsupportedUname = `${clampUnameField(parts[1])} ${clampUnameField(parts[2])}`
|
||||
}
|
||||
return null
|
||||
return unsupportedUname
|
||||
? { kind: 'unsupported', uname: unsupportedUname }
|
||||
: { kind: 'unparsed', output }
|
||||
}
|
||||
|
||||
// Why: a single field can be kilobytes — the scanner reads up to 4096 chars.
|
||||
function clampUnameField(field: string): string {
|
||||
return field.length > MAX_UNAME_FIELD_CHARS ? `${field.slice(0, MAX_UNAME_FIELD_CHARS)}…` : field
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue