390 lines
16 KiB
TypeScript
390 lines
16 KiB
TypeScript
// tests/main/services/runtime-provisioner-redteam-r1-8.test.ts
|
||
// RuntimeProvisioner 분리(인덱스 검증 / 부품 다운로드 / 스테이징 설치)와 회귀 테스트.
|
||
//
|
||
// 회귀 대상:
|
||
// 1) tar 항목 쓰기 오류가 경고로 삼켜져 반쯤 풀린 엔진에 버전 마커가 붙던 문제
|
||
// 2) 부품 전체 전송에 120초 제한이 걸려 느린 링크에서 영영 설치할 수 없던 문제
|
||
// 3) "다시 설치" 가 설치된 런타임에서 아무 일도 하지 않던 문제
|
||
// 4) 최소 버전 미만 인덱스를 받아들여 매번 다시 받는 루프
|
||
|
||
import { describe, it, expect, beforeEach, afterEach } from 'vitest'
|
||
import { createHash } from 'node:crypto'
|
||
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
|
||
import { tmpdir } from 'node:os'
|
||
import { join } from 'node:path'
|
||
import * as tar from 'tar'
|
||
import {
|
||
isRuntimeVersionSatisfied,
|
||
parseRuntimeIndex,
|
||
type RuntimePart,
|
||
} from '../../../src/main/services/runtime/runtime-index'
|
||
import {
|
||
downloadPart,
|
||
type RuntimeFetch,
|
||
type RuntimeFetchResponse,
|
||
} from '../../../src/main/services/runtime/download-part'
|
||
import { installArchive } from '../../../src/main/services/runtime/install-archive'
|
||
import { RuntimeProvisioner } from '../../../src/main/services/RuntimeProvisioner'
|
||
|
||
// ── 헬퍼 ────────────────────────────────────────────────────────────
|
||
|
||
const sha = (data: Buffer): string => createHash('sha256').update(data).digest('hex')
|
||
|
||
type TarEntry = { path: string; body?: string; type?: 'File' | 'Directory' }
|
||
|
||
/** 손으로 만든 tar (파일 다음에 같은 이름의 하위 항목을 넣어 항목 오류를 재현할 수 있다) */
|
||
function buildTar(entries: TarEntry[]): Buffer {
|
||
const blocks: Buffer[] = []
|
||
for (const entry of entries) {
|
||
const type = entry.type ?? 'File'
|
||
const body = Buffer.from(entry.body ?? '')
|
||
const header = new tar.Header({
|
||
path: entry.path,
|
||
mode: type === 'File' ? 0o644 : 0o755,
|
||
size: type === 'File' ? body.length : 0,
|
||
type,
|
||
mtime: new Date(0),
|
||
uid: 0,
|
||
gid: 0,
|
||
})
|
||
const headerBlock = Buffer.alloc(512)
|
||
header.encode(headerBlock, 0)
|
||
blocks.push(headerBlock)
|
||
if (type === 'File') {
|
||
blocks.push(body, Buffer.alloc((512 - (body.length % 512)) % 512))
|
||
}
|
||
}
|
||
blocks.push(Buffer.alloc(1024))
|
||
return Buffer.concat(blocks)
|
||
}
|
||
|
||
const SIDECAR_BIN = process.platform === 'win32' ? 'sidecar.exe' : 'sidecar'
|
||
|
||
function sidecarTar(version: string): Buffer {
|
||
return buildTar([
|
||
{ path: SIDECAR_BIN, body: `engine ${version}` },
|
||
{ path: '_internal', type: 'Directory' },
|
||
{ path: '_internal/core.dll', body: 'dll' },
|
||
])
|
||
}
|
||
|
||
/** 항목 하나가 반드시 실패하는 tar: 파일 `_internal/x` 뒤에 `_internal/x/y` */
|
||
function brokenSidecarTar(): Buffer {
|
||
return buildTar([
|
||
{ path: SIDECAR_BIN, body: 'engine' },
|
||
{ path: '_internal', type: 'Directory' },
|
||
{ path: '_internal/x', body: 'file in the way' },
|
||
{ path: '_internal/x/y.dll', body: 'never written' },
|
||
])
|
||
}
|
||
|
||
function response(
|
||
body: BodyInit | null,
|
||
init: { status?: number; headers?: Record<string, string> } = {},
|
||
): RuntimeFetchResponse {
|
||
return new Response(body, { status: init.status ?? 200, headers: init.headers }) as RuntimeFetchResponse
|
||
}
|
||
|
||
const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms))
|
||
|
||
/** chunkCount 개의 청크를 intervalMs 간격으로 보내는 스트림 */
|
||
function slowStream(data: Buffer, chunkCount: number, intervalMs: number): ReadableStream<Uint8Array> {
|
||
const chunkSize = Math.ceil(data.length / chunkCount)
|
||
let offset = 0
|
||
return new ReadableStream<Uint8Array>({
|
||
async pull(controller) {
|
||
if (offset >= data.length) {
|
||
controller.close()
|
||
return
|
||
}
|
||
await delay(intervalMs)
|
||
controller.enqueue(new Uint8Array(data.subarray(offset, offset + chunkSize)))
|
||
offset += chunkSize
|
||
},
|
||
})
|
||
}
|
||
|
||
/** 앞부분 bytes 만 보내고 영원히 멈추는 스트림 */
|
||
function stallingStream(data: Buffer, bytes: number): ReadableStream<Uint8Array> {
|
||
let sent = false
|
||
return new ReadableStream<Uint8Array>({
|
||
pull(controller) {
|
||
if (!sent) {
|
||
sent = true
|
||
controller.enqueue(new Uint8Array(data.subarray(0, bytes)))
|
||
return
|
||
}
|
||
return new Promise<void>(() => undefined)
|
||
},
|
||
})
|
||
}
|
||
|
||
let workDir: string
|
||
|
||
beforeEach(() => {
|
||
workDir = mkdtempSync(join(tmpdir(), 'd3ro-runtime-r1-8-'))
|
||
})
|
||
|
||
afterEach(() => {
|
||
rmSync(workDir, { recursive: true, force: true })
|
||
})
|
||
|
||
// ── parseRuntimeIndex ───────────────────────────────────────────────
|
||
|
||
function validIndex(version = '1.9.0'): Record<string, unknown> {
|
||
const part = Buffer.from('abc')
|
||
return {
|
||
schemaVersion: 1,
|
||
version,
|
||
components: {
|
||
sidecar: {
|
||
archive: 'd3ro-runtime-sidecar.tar.gz',
|
||
sha256: sha(part),
|
||
totalSize: part.length,
|
||
parts: [{ name: 'd3ro-runtime-sidecar.tar.gz.001', size: part.length, sha256: sha(part), url: 'https://feed/x.001' }],
|
||
},
|
||
},
|
||
}
|
||
}
|
||
|
||
describe('parseRuntimeIndex', () => {
|
||
it('정상 인덱스에서 구성 요소 항목과 버전을 돌려준다', () => {
|
||
const resolved = parseRuntimeIndex(validIndex(), 'sidecar', '1.7.0')
|
||
expect(resolved.version).toBe('1.9.0')
|
||
expect(resolved.entry.parts).toHaveLength(1)
|
||
})
|
||
|
||
it('최소 버전보다 낮은 인덱스는 거부한다 (재다운로드 루프 방지)', () => {
|
||
expect(() => parseRuntimeIndex(validIndex('1.6.9'), 'sidecar', '1.7.0')).toThrow(/최소 요구 버전/)
|
||
})
|
||
|
||
it('semver 가 아닌 version 은 거부한다', () => {
|
||
expect(() => parseRuntimeIndex(validIndex('latest'), 'sidecar', '1.7.0')).toThrow(/semver/)
|
||
})
|
||
|
||
it('경로 구분자나 .. 가 든 부품 이름은 거부한다', () => {
|
||
const index = validIndex()
|
||
const components = index.components as Record<string, { parts: RuntimePart[] }>
|
||
components.sidecar.parts[0].name = '..\\..\\evil.dll'
|
||
expect(() => parseRuntimeIndex(index, 'sidecar', '1.7.0')).toThrow(/안전한 파일 이름/)
|
||
})
|
||
|
||
it('해시가 SHA-256 형식이 아니면 거부한다', () => {
|
||
const index = validIndex()
|
||
const components = index.components as Record<string, { sha256: string }>
|
||
components.sidecar.sha256 = 'nope'
|
||
expect(() => parseRuntimeIndex(index, 'sidecar', '1.7.0')).toThrow(/SHA-256/)
|
||
})
|
||
|
||
it('구성 요소가 없으면 그 이름으로 알린다', () => {
|
||
expect(() => parseRuntimeIndex(validIndex(), 'ffmpeg', null)).toThrow(/ffmpeg 구성 요소가 없습니다/)
|
||
})
|
||
|
||
it('isRuntimeVersionSatisfied 는 최소 버전 null 이면 항상 참, 읽을 수 없으면 거짓', () => {
|
||
expect(isRuntimeVersionSatisfied(undefined, null)).toBe(true)
|
||
expect(isRuntimeVersionSatisfied('1.7.0\n', '1.7.0')).toBe(true)
|
||
expect(isRuntimeVersionSatisfied('1.6.0', '1.7.0')).toBe(false)
|
||
expect(isRuntimeVersionSatisfied('garbage', '1.7.0')).toBe(false)
|
||
})
|
||
})
|
||
|
||
// ── downloadPart ────────────────────────────────────────────────────
|
||
|
||
describe('downloadPart', () => {
|
||
const data = Buffer.alloc(64 * 1024, 7)
|
||
const part: RuntimePart = { name: 'p.001', size: data.length, sha256: sha(data), url: 'https://feed/p.001' }
|
||
|
||
it('전체 전송이 정체 타임아웃보다 길어도 데이터가 계속 오면 끝까지 받는다', async () => {
|
||
// 10청크 × 40ms ≈ 400ms > stallTimeout 150ms — 예전(전송 전체 타임아웃)에는 끊겼다
|
||
const fetchImpl: RuntimeFetch = async () => response(slowStream(data, 10, 40))
|
||
const dest = join(workDir, part.name)
|
||
const size = await downloadPart(part, dest, { fetchImpl, stallTimeoutMs: 150, attempts: 1 })
|
||
expect(size).toBe(data.length)
|
||
expect(sha(readFileSync(dest))).toBe(part.sha256)
|
||
})
|
||
|
||
it('데이터가 멈추면 끊고, 재시도에서 Range 로 이어 받는다', async () => {
|
||
const requests: Array<Record<string, string> | undefined> = []
|
||
const fetchImpl: RuntimeFetch = async (_url, init) => {
|
||
requests.push(init.headers)
|
||
if (requests.length === 1) return response(stallingStream(data, 1000))
|
||
const range = init.headers?.Range ?? ''
|
||
const start = Number(/bytes=(\d+)-/.exec(range)?.[1] ?? 0)
|
||
return response(new Uint8Array(data.subarray(start)), {
|
||
status: 206,
|
||
headers: { 'content-range': `bytes ${start}-${data.length - 1}/${data.length}` },
|
||
})
|
||
}
|
||
const dest = join(workDir, part.name)
|
||
const size = await downloadPart(part, dest, { fetchImpl, stallTimeoutMs: 80, attempts: 2 })
|
||
expect(size).toBe(data.length)
|
||
expect(requests[0]).toBeUndefined()
|
||
expect(requests[1]).toEqual({ Range: 'bytes=1000-' })
|
||
expect(sha(readFileSync(dest))).toBe(part.sha256)
|
||
})
|
||
|
||
it('모든 시도가 정체되면 정체 오류로 실패하고 부분 파일을 남기지 않는다', async () => {
|
||
const fetchImpl: RuntimeFetch = async () => response(stallingStream(data, 10))
|
||
const dest = join(workDir, part.name)
|
||
await expect(downloadPart(part, dest, { fetchImpl, stallTimeoutMs: 50, attempts: 2 })).rejects.toThrow(/멈췄습니다/)
|
||
expect(existsSync(dest)).toBe(false)
|
||
})
|
||
|
||
it('해시가 틀리면 부분 파일을 버리고 처음부터 다시 받는다', async () => {
|
||
let calls = 0
|
||
const fetchImpl: RuntimeFetch = async (_url, init) => {
|
||
calls += 1
|
||
expect(init.headers).toBeUndefined()
|
||
return response(new Uint8Array(calls === 1 ? Buffer.alloc(data.length, 1) : data))
|
||
}
|
||
const dest = join(workDir, part.name)
|
||
await downloadPart(part, dest, { fetchImpl, stallTimeoutMs: 1000, attempts: 2 })
|
||
expect(calls).toBe(2)
|
||
})
|
||
})
|
||
|
||
// ── installArchive ──────────────────────────────────────────────────
|
||
|
||
describe('installArchive', () => {
|
||
const verify = (dir: string): boolean =>
|
||
existsSync(join(dir, SIDECAR_BIN)) && existsSync(join(dir, '_internal'))
|
||
|
||
function seedPrevious(targetDir: string): void {
|
||
mkdirSync(join(targetDir, '_internal'), { recursive: true })
|
||
writeFileSync(join(targetDir, SIDECAR_BIN), 'old engine')
|
||
writeFileSync(join(targetDir, '.runtime-version'), '1.7.0')
|
||
}
|
||
|
||
it('항목 쓰기 오류가 나면 실패하고 기존 설치와 마커를 그대로 둔다', async () => {
|
||
const archivePath = join(workDir, 'broken.tar')
|
||
writeFileSync(archivePath, brokenSidecarTar())
|
||
const targetDir = join(workDir, 'sidecar')
|
||
seedPrevious(targetDir)
|
||
|
||
await expect(
|
||
installArchive({ archivePath, targetDir, verify, marker: { fileName: '.runtime-version', content: '1.9.0' } }),
|
||
).rejects.toThrow()
|
||
|
||
expect(readFileSync(join(targetDir, SIDECAR_BIN), 'utf8')).toBe('old engine')
|
||
expect(readFileSync(join(targetDir, '.runtime-version'), 'utf8')).toBe('1.7.0')
|
||
expect(existsSync(`${targetDir}.staging`)).toBe(false)
|
||
})
|
||
|
||
it('성공하면 새 트리로 교체하고 마커를 새 버전으로 쓴다', async () => {
|
||
const archivePath = join(workDir, 'ok.tar')
|
||
writeFileSync(archivePath, sidecarTar('1.9.0'))
|
||
const targetDir = join(workDir, 'sidecar')
|
||
seedPrevious(targetDir)
|
||
|
||
await installArchive({ archivePath, targetDir, verify, marker: { fileName: '.runtime-version', content: '1.9.0' } })
|
||
|
||
expect(readFileSync(join(targetDir, SIDECAR_BIN), 'utf8')).toBe('engine 1.9.0')
|
||
expect(readFileSync(join(targetDir, '.runtime-version'), 'utf8')).toBe('1.9.0')
|
||
expect(existsSync(join(targetDir, '_internal', 'core.dll'))).toBe(true)
|
||
expect(existsSync(`${targetDir}.old`)).toBe(false)
|
||
})
|
||
|
||
it('필수 파일이 없으면 교체하지 않는다', async () => {
|
||
const archivePath = join(workDir, 'noexe.tar')
|
||
writeFileSync(archivePath, buildTar([{ path: 'readme.txt', body: 'x' }]))
|
||
const targetDir = join(workDir, 'sidecar')
|
||
seedPrevious(targetDir)
|
||
|
||
await expect(installArchive({ archivePath, targetDir, verify })).rejects.toThrow(/필수 파일/)
|
||
expect(readFileSync(join(targetDir, SIDECAR_BIN), 'utf8')).toBe('old engine')
|
||
})
|
||
})
|
||
|
||
// ── RuntimeProvisioner (주입된 IO로 전체 흐름) ─────────────────────────
|
||
|
||
describe('RuntimeProvisioner', () => {
|
||
const FEED = 'https://feed.test/runtime-latest'
|
||
|
||
function feedFor(archive: Buffer, version: string): { fetchImpl: RuntimeFetch; calls: string[] } {
|
||
const calls: string[] = []
|
||
const partName = 'd3ro-runtime-sidecar.tar.gz.001'
|
||
const index = {
|
||
schemaVersion: 1,
|
||
version,
|
||
components: {
|
||
sidecar: {
|
||
archive: 'd3ro-runtime-sidecar.tar.gz',
|
||
sha256: sha(archive),
|
||
totalSize: archive.length,
|
||
parts: [{ name: partName, size: archive.length, sha256: sha(archive), url: `${FEED}/${partName}` }],
|
||
},
|
||
},
|
||
}
|
||
const fetchImpl: RuntimeFetch = async (url) => {
|
||
calls.push(url)
|
||
if (url === `${FEED}/runtime.json`) return response(JSON.stringify(index))
|
||
if (url === `${FEED}/${partName}`) return response(new Uint8Array(archive))
|
||
return response(null, { status: 404 })
|
||
}
|
||
return { fetchImpl, calls }
|
||
}
|
||
|
||
function provisioner(fetchImpl: RuntimeFetch): RuntimeProvisioner {
|
||
return new RuntimeProvisioner({
|
||
userDataDir: () => workDir,
|
||
fetchImpl,
|
||
feedUrl: FEED,
|
||
platform: process.platform,
|
||
stallTimeoutMs: 1000,
|
||
partAttempts: 1,
|
||
})
|
||
}
|
||
|
||
const markerPath = (): string => join(workDir, 'runtime', 'sidecar', '.runtime-version')
|
||
|
||
it('설치 후 마커를 쓰고, 다음 ensure 는 내려받지 않는다', async () => {
|
||
const feed = feedFor(sidecarTar('1.9.0'), '1.9.0')
|
||
const p = provisioner(feed.fetchImpl)
|
||
|
||
const path = await p.ensure('sidecar')
|
||
expect(path).toBe(p.binaryPath('sidecar'))
|
||
expect(readFileSync(markerPath(), 'utf8')).toBe('1.9.0')
|
||
|
||
feed.calls.length = 0
|
||
await p.ensure('sidecar')
|
||
expect(feed.calls).toEqual([])
|
||
})
|
||
|
||
it('force 면 설치돼 있어도 다시 받아 손상된 트리를 복구한다', async () => {
|
||
const feed = feedFor(sidecarTar('1.9.0'), '1.9.0')
|
||
const p = provisioner(feed.fetchImpl)
|
||
await p.ensure('sidecar')
|
||
|
||
// 백신이 DLL 을 격리한 상황
|
||
rmSync(join(workDir, 'runtime', 'sidecar', '_internal', 'core.dll'))
|
||
feed.calls.length = 0
|
||
|
||
await p.ensure('sidecar', { force: true })
|
||
expect(feed.calls.length).toBeGreaterThan(0)
|
||
expect(existsSync(join(workDir, 'runtime', 'sidecar', '_internal', 'core.dll'))).toBe(true)
|
||
})
|
||
|
||
it('추출 중 항목 오류가 나면 실패하고 버전 마커를 남기지 않는다', async () => {
|
||
const feed = feedFor(brokenSidecarTar(), '1.9.0')
|
||
const p = provisioner(feed.fetchImpl)
|
||
|
||
await expect(p.ensure('sidecar')).rejects.toThrow()
|
||
expect(existsSync(markerPath())).toBe(false)
|
||
expect(p.isInstalled('sidecar')).toBe(false)
|
||
})
|
||
|
||
it('최소 버전 미만 인덱스는 부품을 받기 전에 거부한다', async () => {
|
||
const feed = feedFor(sidecarTar('1.6.0'), '1.6.0')
|
||
const p = provisioner(feed.fetchImpl)
|
||
|
||
await expect(p.ensure('sidecar')).rejects.toThrow(/최소 요구 버전/)
|
||
expect(feed.calls).toEqual([`${FEED}/runtime.json`])
|
||
})
|
||
|
||
it('다운로드가 끝나면 임시 폴더를 남기지 않는다', async () => {
|
||
const feed = feedFor(sidecarTar('1.9.0'), '1.9.0')
|
||
await provisioner(feed.fetchImpl).ensure('sidecar')
|
||
expect(existsSync(join(workDir, 'runtime', '.download-sidecar'))).toBe(false)
|
||
expect(existsSync(join(workDir, 'runtime', 'sidecar.staging'))).toBe(false)
|
||
})
|
||
})
|