Support resumable game folder uploads and remove DLC declarations
This commit is contained in:
@@ -10,10 +10,10 @@ export interface HostLibraryCache {
|
||||
}
|
||||
export interface GameLibraryVersion {
|
||||
id: string; libraryId: string; game: GameLibraryGame; version: string;
|
||||
description: string; dlc: string[]; state: GameLibraryState; sizeBytes: number;
|
||||
description: string; state: GameLibraryState; sizeBytes: number;
|
||||
fileCount: number; manifestSha256: string | null; files: GameFileEntry[];
|
||||
createdAt: string; publishedAt: string | null; storageLocation: string;
|
||||
sourceHostId: string; sourceVolume: string; error: string | null; operationId: string | null;
|
||||
sourceHostId: string | null; sourceVolume: string | null; error: string | null; operationId: string | null;
|
||||
caches: HostLibraryCache[];
|
||||
}
|
||||
export interface GameLibrary {
|
||||
|
||||
@@ -7,7 +7,8 @@ import { assertRegularPath, parseByteRange } from './storage.js';
|
||||
|
||||
export function gameFileError(cause: unknown): Response {
|
||||
const status = typeof cause === 'object' && cause !== null && 'status' in cause && typeof cause.status === 'number' ? cause.status : 400;
|
||||
return json({ error: cause instanceof Error ? cause.message : 'Game file request failed.' }, { status });
|
||||
const receivedBytes = typeof cause === 'object' && cause !== null && 'receivedBytes' in cause && Number.isSafeInteger(cause.receivedBytes) ? cause.receivedBytes : undefined;
|
||||
return json({ error: cause instanceof Error ? cause.message : 'Game file request failed.', ...(receivedBytes === undefined ? {} : { receivedBytes }) }, { status });
|
||||
}
|
||||
export async function readGameJson(request: Request, maxBytes = 64 * 1024): Promise<Record<string, unknown>> {
|
||||
if (!request.body) throw new Error('A JSON request body is required.');
|
||||
|
||||
@@ -6,6 +6,7 @@ import { config } from '../config.js';
|
||||
import { getHost, getHostOperation, listHosts, queueHostOperation } from '../hosts/index.js';
|
||||
import { ensureGameFileSchema } from './schema.js';
|
||||
import { manifestChecksum, receiveGameFile, validateGamePath, validateManifest, verifyGameFile } from './storage.js';
|
||||
import { MAX_UPLOAD_CHUNK_BYTES, validateUploadPlan, getUploadFileProgress, receiveUploadChunk, hashUploadedFiles, withUploadLock } from './uploads.js';
|
||||
import type { GameFileEntry, GameLibrary, GameLibraryGame, GameLibraryVersion, HostLibraryCache, LibraryCacheState } from '../../game-files.js';
|
||||
|
||||
function database() { const handle = db(); ensureGameFileSchema(handle); return handle; }
|
||||
@@ -17,10 +18,10 @@ const cacheFromRow = (row: CacheRow): HostLibraryCache => ({ hostId: row.host_id
|
||||
function versionFromRow(row: VersionRow): GameLibraryVersion {
|
||||
const files = JSON.parse(row.manifest) as GameFileEntry[];
|
||||
return { id: row.id, libraryId: row.library_id, game: row.game, version: row.version,
|
||||
description: row.description, dlc: JSON.parse(row.dlc), state: row.state, sizeBytes: row.size_bytes,
|
||||
files, fileCount: files.length, manifestSha256: row.manifest_sha256, createdAt: row.created_at,
|
||||
publishedAt: row.published_at, storageLocation: row.storage_location, sourceHostId: row.source_host_id,
|
||||
sourceVolume: row.source_volume, error: row.error, operationId: row.operation_id,
|
||||
description: row.description, state: row.state, sizeBytes: row.size_bytes,
|
||||
files, fileCount: files.length || (database().prepare('SELECT COUNT(*) AS count FROM game_file_upload_entries WHERE version_id=?').get(row.id) as { count: number }).count, manifestSha256: row.manifest_sha256, createdAt: row.created_at,
|
||||
publishedAt: row.published_at, storageLocation: row.storage_location, sourceHostId: row.source_host_id || null,
|
||||
sourceVolume: row.source_volume || null, error: row.error, operationId: row.operation_id,
|
||||
caches: (database().prepare('SELECT * FROM host_library_caches WHERE version_id = ?').all(row.id) as CacheRow[]).map(cacheFromRow) };
|
||||
}
|
||||
export function getLibraryVersion(id: string): GameLibraryVersion | null {
|
||||
@@ -60,6 +61,112 @@ function textField(input: unknown, label: string, max: number, required = true):
|
||||
if (typeof input !== 'string' || input.length > max || (required && !input.trim())) throw new Error(`Provide a valid ${label}.`);
|
||||
return input.trim();
|
||||
}
|
||||
|
||||
/** Register a folder on the controller; no host or Docker volume is needed. */
|
||||
export function createLibraryUpload(input: Record<string, unknown>): GameLibraryVersion {
|
||||
const game = input.game;
|
||||
if (game !== 't5' && game !== 't6') throw new Error('Choose T5 or T6 game files.');
|
||||
const name = textField(input.name, 'library name', 160);
|
||||
const description = textField(input.description ?? '', 'description', 4000, false);
|
||||
const version = textField(input.version, 'version label', 120);
|
||||
const files = validateUploadPlan(input.files);
|
||||
const handle = database();
|
||||
const id = randomUUID(); const now = new Date().toISOString();
|
||||
handle.transaction(() => {
|
||||
let library = handle.prepare('SELECT id,game FROM game_file_libraries WHERE name=?').get(name) as { id: string; game: string } | undefined;
|
||||
if (library && library.game !== game) throw new Error('This library name is already used for another game.');
|
||||
if (!library) {
|
||||
library = { id: randomUUID(), game };
|
||||
handle.prepare('INSERT INTO game_file_libraries(id,name,game,description,created_at) VALUES(?,?,?,?,?)').run(library.id, name, game, description, now);
|
||||
}
|
||||
if (handle.prepare('SELECT 1 FROM game_file_versions WHERE library_id=? AND version=?').get(library.id, version)) throw new Error('This version label already exists. Choose a new version.');
|
||||
// Keep legacy non-null columns for existing databases and published versions.
|
||||
handle.prepare(`INSERT INTO game_file_versions(id,library_id,version,description,dlc,state,size_bytes,created_at,storage_location,source_host_id,source_volume)
|
||||
VALUES(?,?,?,?,'[]','importing',?,?,?,'','')`).run(id, library.id, version, description, files.reduce((sum, file) => sum + file.size, 0), now, join(gameFilesRoot(), game, id));
|
||||
const insert = handle.prepare('INSERT INTO game_file_upload_entries(version_id,path,size,last_modified) VALUES(?,?,?,?)');
|
||||
for (const file of files) insert.run(id, file.path, file.size, file.lastModified);
|
||||
})();
|
||||
return getLibraryVersion(id)!;
|
||||
}
|
||||
|
||||
type UploadEntry = { path: string; size: number; lastModified: number };
|
||||
function requireBrowserUpload(id: string): GameLibraryVersion {
|
||||
const version = getLibraryVersion(id);
|
||||
if (!version || version.sourceHostId !== null || !database().prepare('SELECT 1 FROM game_file_upload_entries WHERE version_id=? LIMIT 1').get(id)) {
|
||||
throw Object.assign(new Error('Folder upload not found.'), { status: 404 });
|
||||
}
|
||||
return version;
|
||||
}
|
||||
function uploadEntries(id: string): UploadEntry[] {
|
||||
return database().prepare('SELECT path,size,last_modified AS lastModified FROM game_file_upload_entries WHERE version_id=? ORDER BY path').all(id) as UploadEntry[];
|
||||
}
|
||||
async function uploadStorageRoot(version: GameLibraryVersion): Promise<string> {
|
||||
// Recover publication interrupted after the atomic rename but before its DB commit.
|
||||
try { if ((await stat(version.storageLocation)).isDirectory()) return version.storageLocation; }
|
||||
catch (cause) { if ((cause as NodeJS.ErrnoException).code !== 'ENOENT') throw cause; }
|
||||
return stagingRoot(version.id);
|
||||
}
|
||||
export async function browserUploadStatus(id: string) {
|
||||
const version = requireBrowserUpload(id);
|
||||
const status = version.state === 'ready' ? 'published' as const : publishing.has(id) ? 'verifying' as const : version.state === 'failed' ? 'failed' as const : 'pending' as const;
|
||||
const root = await uploadStorageRoot(version);
|
||||
const entries = uploadEntries(id);
|
||||
const files = [];
|
||||
// Avoid opening thousands of files concurrently for a large folder.
|
||||
for (const file of entries) files.push({ ...file, ...(status === 'published' ? { receivedBytes: file.size, complete: true } : await getUploadFileProgress(root, file)) });
|
||||
const { files: _manifest, ...summary } = version;
|
||||
return { status, chunkSize: MAX_UPLOAD_CHUNK_BYTES, files, version: summary, error: version.error };
|
||||
}
|
||||
export async function uploadBrowserFile(id: string, path: string, chunk: { offset: number; size: number; sha256: string }, body: ReadableStream<Uint8Array> | null) {
|
||||
validateGamePath(path);
|
||||
const checkWritable = () => {
|
||||
const version = requireBrowserUpload(id);
|
||||
if (version.state === 'ready' || version.manifestSha256 || publishing.has(id)) throw Object.assign(new Error('This upload is no longer writable.'), { status: 409 });
|
||||
};
|
||||
checkWritable();
|
||||
const file = database().prepare('SELECT path,size,last_modified AS lastModified FROM game_file_upload_entries WHERE version_id=? AND path=?').get(id, path) as UploadEntry | undefined;
|
||||
if (!file) throw new Error('File is not listed in this upload.');
|
||||
const progress = await receiveUploadChunk(stagingRoot(id), file, chunk, body, checkWritable);
|
||||
database().prepare("UPDATE game_file_versions SET state='importing',error=NULL WHERE id=? AND state IN ('importing','failed')").run(id);
|
||||
return progress;
|
||||
}
|
||||
export async function publishBrowserUpload(id: string): Promise<GameLibraryVersion> {
|
||||
const version = requireBrowserUpload(id);
|
||||
if (version.state === 'ready') return version;
|
||||
const existing = publishing.get(id); if (existing) return existing;
|
||||
const task = withUploadLock(stagingRoot(id), async () => {
|
||||
const root = await uploadStorageRoot(version);
|
||||
const files = await hashUploadedFiles(root, uploadEntries(id));
|
||||
const checksum = manifestChecksum(files);
|
||||
if (version.manifestSha256 && checksum !== version.manifestSha256) throw new Error('Stored files no longer match the verified manifest.');
|
||||
database().transaction(() => {
|
||||
database().prepare("UPDATE game_file_versions SET state='importing',manifest=?,manifest_sha256=?,error=NULL WHERE id=? AND state IN ('importing','failed')").run(JSON.stringify(files), checksum, id);
|
||||
database().prepare('DELETE FROM game_file_entries WHERE version_id=?').run(id);
|
||||
const insert = database().prepare('INSERT INTO game_file_entries(version_id,path,size,sha256) VALUES(?,?,?,?)');
|
||||
for (const file of files) insert.run(id, file.path, file.size, file.sha256);
|
||||
})();
|
||||
if (root !== version.storageLocation) {
|
||||
await mkdir(dirname(version.storageLocation), { recursive: true });
|
||||
await rename(root, version.storageLocation);
|
||||
}
|
||||
database().prepare("UPDATE game_file_versions SET state='ready',published_at=?,error=NULL WHERE id=? AND state='importing'").run(new Date().toISOString(), id);
|
||||
return getLibraryVersion(id)!;
|
||||
});
|
||||
publishing.set(id, task);
|
||||
try { return await task; } finally { publishing.delete(id); }
|
||||
}
|
||||
export async function requestBrowserPublication(id: string) {
|
||||
const version = requireBrowserUpload(id);
|
||||
if (version.state !== 'ready' && !publishing.has(id)) {
|
||||
database().prepare("UPDATE game_file_versions SET state='importing',error=NULL WHERE id=? AND state IN ('importing','failed')").run(id);
|
||||
void publishBrowserUpload(id).catch(cause => {
|
||||
database().prepare("UPDATE game_file_versions SET state='failed',error=? WHERE id=? AND state='importing'")
|
||||
.run((cause instanceof Error ? cause.message : 'Folder publication failed.').slice(0, 2000), id);
|
||||
});
|
||||
}
|
||||
return browserUploadStatus(id);
|
||||
}
|
||||
|
||||
export function createLibraryImport(input: Record<string, unknown>): GameLibraryVersion {
|
||||
const game = input.game;
|
||||
if (game !== 't5' && game !== 't6') throw new Error('Choose T5 or T6 game files.');
|
||||
@@ -69,9 +176,6 @@ export function createLibraryImport(input: Record<string, unknown>): GameLibrary
|
||||
const name = textField(input.name, 'library name', 160);
|
||||
const description = textField(input.description ?? '', 'description', 4000, false);
|
||||
const version = textField(input.version, 'version label', 120);
|
||||
const dlcInput = input.dlc ?? [];
|
||||
if (!Array.isArray(dlcInput) || dlcInput.length > 64) throw new Error('DLC must be a list of content names.');
|
||||
const dlc = dlcInput.map(value => textField(value, 'DLC name', 120));
|
||||
const sourceVolume = game === 't5' ? 't5_game_files' : 't6_game_files';
|
||||
const handle = database();
|
||||
let library = handle.prepare('SELECT id,game FROM game_file_libraries WHERE name=?').get(name) as { id: string; game: string } | undefined;
|
||||
@@ -84,7 +188,7 @@ export function createLibraryImport(input: Record<string, unknown>): GameLibrary
|
||||
}
|
||||
if (handle.prepare('SELECT 1 FROM game_file_versions WHERE library_id=? AND version=?').get(library.id, version)) throw new Error('This version label already exists. Choose a new version.');
|
||||
handle.prepare(`INSERT INTO game_file_versions(id,library_id,version,description,dlc,state,created_at,storage_location,source_host_id,source_volume)
|
||||
VALUES(?,?,?,?,?,'importing',?,?,?,?)`).run(id, library.id, version, description, JSON.stringify(dlc), now, join(gameFilesRoot(), game, id), hostId, sourceVolume);
|
||||
VALUES(?,?,?,?,?,'importing',?,?,?,?)`).run(id, library.id, version, description, '[]', now, join(gameFilesRoot(), game, id), hostId, sourceVolume);
|
||||
})();
|
||||
try {
|
||||
const operation = queueHostOperation(hostId, 'library.import', {
|
||||
|
||||
@@ -29,6 +29,11 @@ export function ensureGameFileSchema(handle: Database.Database): void {
|
||||
version_id TEXT NOT NULL REFERENCES game_file_versions(id), path TEXT NOT NULL,
|
||||
size INTEGER NOT NULL, sha256 TEXT NOT NULL, PRIMARY KEY(version_id,path)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS game_file_upload_entries (
|
||||
version_id TEXT NOT NULL REFERENCES game_file_versions(id), path TEXT NOT NULL,
|
||||
size INTEGER NOT NULL, last_modified INTEGER NOT NULL,
|
||||
PRIMARY KEY(version_id,path)
|
||||
);
|
||||
INSERT OR IGNORE INTO game_file_entries(version_id,path,size,sha256)
|
||||
SELECT v.id,json_extract(f.value,'$.path'),json_extract(f.value,'$.size'),json_extract(f.value,'$.sha256')
|
||||
FROM game_file_versions v,json_each(v.manifest) f;
|
||||
|
||||
@@ -63,13 +63,18 @@ export async function assertRegularPath(root: string, path: string, allowMissing
|
||||
return result;
|
||||
}
|
||||
|
||||
export async function verifyGameFile(root: string, file: GameFileEntry): Promise<void> {
|
||||
/** Compute a file digest without buffering game archives in memory. */
|
||||
export async function hashGameFile(root: string, file: Pick<GameFileEntry, 'path' | 'size'>): Promise<string> {
|
||||
const path = await assertRegularPath(root, file.path);
|
||||
const info = await stat(path);
|
||||
if (info.size !== file.size) throw new Error(`Size verification failed for ${file.path}.`);
|
||||
const hash = createHash('sha256');
|
||||
for await (const chunk of createReadStream(path)) hash.update(chunk);
|
||||
if (hash.digest('hex') !== file.sha256) throw new Error(`Checksum verification failed for ${file.path}.`);
|
||||
return hash.digest('hex');
|
||||
}
|
||||
|
||||
export async function verifyGameFile(root: string, file: GameFileEntry): Promise<void> {
|
||||
if (await hashGameFile(root, file) !== file.sha256) throw new Error(`Checksum verification failed for ${file.path}.`);
|
||||
}
|
||||
|
||||
/** Stream to a private temporary file; publish only after byte count and SHA256 match. */
|
||||
|
||||
@@ -0,0 +1,155 @@
|
||||
import { createHash, randomUUID } from 'node:crypto';
|
||||
import { constants, createReadStream, createWriteStream } from 'node:fs';
|
||||
import { lstat, mkdir, open, rm } from 'node:fs/promises';
|
||||
import { dirname, resolve } from 'node:path';
|
||||
import { Readable, Transform } from 'node:stream';
|
||||
import { pipeline } from 'node:stream/promises';
|
||||
import type { GameFileEntry } from '../../game-files.js';
|
||||
import { assertRegularPath, hashGameFile, validateManifest } from './storage.js';
|
||||
|
||||
export const MAX_UPLOAD_CHUNK_BYTES = 8 * 1024 * 1024;
|
||||
|
||||
export interface UploadFilePlan {
|
||||
path: string;
|
||||
size: number;
|
||||
lastModified: number;
|
||||
}
|
||||
|
||||
export interface UploadFileProgress {
|
||||
receivedBytes: number;
|
||||
complete: boolean;
|
||||
}
|
||||
|
||||
export class UploadOffsetError extends Error {
|
||||
readonly status = 409;
|
||||
readonly receivedBytes: number;
|
||||
constructor(receivedBytes: number) {
|
||||
super(`Upload offset does not match the stored file. Resume at byte ${receivedBytes}.`);
|
||||
this.name = 'UploadOffsetError';
|
||||
this.receivedBytes = receivedBytes;
|
||||
}
|
||||
}
|
||||
|
||||
/** Apply the same path, case, size and file/directory collision rules as published manifests. */
|
||||
export function validateUploadPlan(input: unknown): UploadFilePlan[] {
|
||||
if (!Array.isArray(input) || !input.length || input.length > 200_000) throw new Error('Provide a folder containing 1–200000 files.');
|
||||
const modified = new Map<string, number>();
|
||||
const manifest = validateManifest(input.map(raw => {
|
||||
if (!raw || typeof raw !== 'object') throw new Error('Invalid upload file.');
|
||||
const lastModified = raw.lastModified === undefined ? 0 : raw.lastModified;
|
||||
if (!Number.isSafeInteger(lastModified) || lastModified < 0) throw new Error('Invalid file modification time.');
|
||||
modified.set(raw.path, lastModified);
|
||||
return { path: raw.path, size: raw.size, sha256: '0'.repeat(64) };
|
||||
}));
|
||||
return manifest.map(file => ({ path: file.path, size: file.size, lastModified: modified.get(file.path)! }));
|
||||
}
|
||||
|
||||
const uploadLocks = new Map<string, Promise<void>>();
|
||||
|
||||
/** Serialize transfers and final publication for one import; a rejected operation never poisons the lock. */
|
||||
export async function withUploadLock<T>(root: string, callback: () => Promise<T> | T): Promise<T> {
|
||||
const key = resolve(root);
|
||||
const previous = uploadLocks.get(key) ?? Promise.resolve();
|
||||
let release!: () => void;
|
||||
const current = new Promise<void>(done => { release = done; });
|
||||
uploadLocks.set(key, current);
|
||||
await previous;
|
||||
try { return await callback(); }
|
||||
finally {
|
||||
release();
|
||||
if (uploadLocks.get(key) === current) uploadLocks.delete(key);
|
||||
}
|
||||
}
|
||||
|
||||
/** File size is the resume checkpoint, including after a controller restart during an append. */
|
||||
export async function getUploadFileProgress(root: string, file: Pick<UploadFilePlan, 'path' | 'size'>): Promise<UploadFileProgress> {
|
||||
const path = await assertRegularPath(root, file.path, true);
|
||||
try {
|
||||
const info = await lstat(path);
|
||||
if (!info.isFile() || info.isSymbolicLink()) throw new Error('Game storage contains a non-regular path.');
|
||||
if (info.size > file.size) throw new Error(`Stored upload exceeds the declared size of ${file.path}.`);
|
||||
return { receivedBytes: info.size, complete: info.size === file.size };
|
||||
} catch (cause) {
|
||||
if ((cause as NodeJS.ErrnoException).code === 'ENOENT') return { receivedBytes: 0, complete: false };
|
||||
throw cause;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify one bounded request before touching the destination. Only verified bytes may be
|
||||
* appended, so a process interruption during the append can resume at the actual file size.
|
||||
* beforeWrite runs under the lock: callers must recheck that the import is still writable.
|
||||
*/
|
||||
export async function receiveUploadChunk(
|
||||
root: string,
|
||||
file: Pick<UploadFilePlan, 'path' | 'size'>,
|
||||
chunk: { offset: number; size: number; sha256: string },
|
||||
body: ReadableStream<Uint8Array> | null,
|
||||
beforeWrite?: () => Promise<void> | void
|
||||
): Promise<UploadFileProgress> {
|
||||
if (!Number.isSafeInteger(chunk.offset) || chunk.offset < 0 || !Number.isSafeInteger(chunk.size)
|
||||
|| chunk.size < 0 || chunk.size > MAX_UPLOAD_CHUNK_BYTES || chunk.offset + chunk.size > file.size
|
||||
|| !Number.isSafeInteger(chunk.offset + chunk.size) || !/^[a-f0-9]{64}$/.test(chunk.sha256)
|
||||
|| (chunk.size === 0 && file.size !== 0)) {
|
||||
throw new Error('Invalid upload chunk size, offset or SHA256.');
|
||||
}
|
||||
if (!body && chunk.size !== 0) throw new Error('A file chunk body is required.');
|
||||
|
||||
return withUploadLock(root, async () => {
|
||||
await beforeWrite?.();
|
||||
const progress = await getUploadFileProgress(root, file);
|
||||
if (chunk.offset !== progress.receivedBytes) throw new UploadOffsetError(progress.receivedBytes);
|
||||
const destination = await assertRegularPath(root, file.path, true);
|
||||
// Keep transient chunks outside the tree that will become the immutable library.
|
||||
const chunkRoot = `${resolve(root)}.chunks`;
|
||||
const temporary = await assertRegularPath(chunkRoot, randomUUID(), true);
|
||||
await mkdir(dirname(temporary), { recursive: true });
|
||||
let received = 0;
|
||||
const hash = createHash('sha256');
|
||||
const verifier = new Transform({ transform(data, _encoding, done) {
|
||||
received += data.length;
|
||||
if (received > chunk.size) return done(new Error('Upload exceeds the declared chunk size.'));
|
||||
hash.update(data); done(null, data);
|
||||
} });
|
||||
try {
|
||||
await pipeline(body ? Readable.fromWeb(body as never) : Readable.from([]), verifier,
|
||||
createWriteStream(temporary, { flags: 'wx', mode: 0o600, flush: true }));
|
||||
if (received !== chunk.size || hash.digest('hex') !== chunk.sha256) throw new Error('Upload chunk checksum or size mismatch.');
|
||||
|
||||
await mkdir(dirname(destination), { recursive: true });
|
||||
await assertRegularPath(root, file.path, true);
|
||||
const target = await open(destination, constants.O_WRONLY | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
|
||||
try {
|
||||
const info = await target.stat();
|
||||
if (!info.isFile()) throw new Error('Game storage contains a non-regular path.');
|
||||
if (info.size !== chunk.offset) throw new UploadOffsetError(info.size);
|
||||
let position = chunk.offset;
|
||||
try {
|
||||
for await (const data of createReadStream(temporary)) {
|
||||
const bytes = data as Buffer;
|
||||
let written = 0;
|
||||
while (written < bytes.length) {
|
||||
const result = await target.write(bytes, written, bytes.length - written, position);
|
||||
if (result.bytesWritten === 0) throw new Error('Unable to append the upload chunk.');
|
||||
written += result.bytesWritten;
|
||||
position += result.bytesWritten;
|
||||
}
|
||||
}
|
||||
await target.sync();
|
||||
} catch (cause) {
|
||||
await target.truncate(chunk.offset);
|
||||
await target.sync();
|
||||
throw cause;
|
||||
}
|
||||
} finally { await target.close(); }
|
||||
return { receivedBytes: chunk.offset + chunk.size, complete: chunk.offset + chunk.size === file.size };
|
||||
} finally { await rm(temporary, { force: true }); }
|
||||
});
|
||||
}
|
||||
|
||||
/** Caller holds withUploadLock through hashing and publication to prevent concurrent writes. */
|
||||
export async function hashUploadedFiles(root: string, files: ReadonlyArray<Pick<UploadFilePlan, 'path' | 'size'>>): Promise<GameFileEntry[]> {
|
||||
const manifest: GameFileEntry[] = [];
|
||||
for (const file of files) manifest.push({ path: file.path, size: file.size, sha256: await hashGameFile(root, file) });
|
||||
return validateManifest(manifest);
|
||||
}
|
||||
@@ -204,7 +204,7 @@ export function previewCreation(input: { game?: unknown; mapSlug?: unknown; blue
|
||||
{ label: 'Lobby', state: name ? 'pass' : 'blocked', detail: name ?? 'All 20 lobbies for this map are occupied or reserved.' },
|
||||
{ label: 'Game port', state: port === null ? 'blocked' : 'pass', detail: port === null ? 'No free game port. Free capacity before launching.' : `${port} / UDP and TCP. Availability is checked again at launch.` },
|
||||
{ label: 'Promoted configuration', state: 'pass', detail: recipe.configSource },
|
||||
{ label: 'Game files and host readiness', state: 'info', detail: 'The host must have the selected game and DLC files. This preview does not probe volumes, images, credentials, or network access.' }
|
||||
{ label: 'Game files and host readiness', state: 'info', detail: 'The host must have the selected game files. This preview does not probe volumes, images, credentials, or network access.' }
|
||||
];
|
||||
const id = randomUUID();
|
||||
const expiresAt = new Date(Date.now() + 30 * 60_000).toISOString();
|
||||
|
||||
@@ -30,7 +30,7 @@
|
||||
{#if !loading && !hosts.some(candidate => candidate.readiness === 'ready')}<p>No deployment-ready hosts. <a href="/hosts" target="_blank" rel="noopener">Set up a host</a>, then refresh.</p>{/if}
|
||||
{#if host}<p>{host.hostname} · ports {host.portMin}–{host.portMax} · {host.publicAddress || host.bindAddress}</p>{/if}
|
||||
{#each games as game}<label>{game === 't5' ? 'Black Ops I' : 'Black Ops II'} game-file version<select bind:value={selection.libraryIds[game]} disabled={disabled || loading || !host} onchange={() => onchange?.()}><option value="">Choose an immutable library version</option>{#each versions.filter(version => version.game === game) as version}<option value={version.id} disabled={!cacheReady(version.id)}>{version.name} · {version.version} · {cacheReady(version.id) ? 'Ready on host' : 'Not cached on host'}</option>{/each}</select></label>{/each}
|
||||
<p><a href="/game-files" target="_blank" rel="noopener">Import or download game files to a host</a>, then refresh. Each launch stays pinned to its selected library version.</p>
|
||||
<p><a href="/game-files" target="_blank" rel="noopener">Upload a game folder or download a version to a host</a>, then refresh. Each launch stays pinned to its selected library version.</p>
|
||||
<label>Plutainer runtime image<input required bind:value={selection.image} disabled={disabled} onchange={() => onchange?.()} /></label>
|
||||
{#if host && !imageReady}<p class="error">Prepare this runtime image from <a href={`/hosts/${host.id}`} target="_blank" rel="noopener">host setup</a> before launch.</p>{/if}
|
||||
{#if network}<details><summary>Network overrides</summary><label>Local bind address<input bind:value={selection.bindAddress} placeholder={host?.bindAddress ?? 'Host default'} disabled={disabled} onchange={() => onchange?.()} /></label><label>Public / NAT address<input bind:value={selection.publicAddress} placeholder={host?.publicAddress || 'Host default'} disabled={disabled} onchange={() => onchange?.()} /></label><label>Public / NAT port<input type="number" min="1" max="65535" bind:value={selection.publicPort} placeholder="Same as local port" disabled={disabled} onchange={() => onchange?.()} /></label><p>Public mapping does not change the local Docker port reservation.</p></details>{/if}
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
export interface SelectedGameFile { path: string; file: File }
|
||||
export interface SelectedGameFolder { name: string; files: SelectedGameFile[]; size: number }
|
||||
|
||||
/** Directory inputs include the selected folder in every relative path. Remove
|
||||
* that one component and retain the complete game directory below it. */
|
||||
export function selectGameFolder(selection: Iterable<File>): SelectedGameFolder {
|
||||
const files: SelectedGameFile[] = [];
|
||||
const paths = new Set<string>();
|
||||
let name = '';
|
||||
let size = 0;
|
||||
for (const file of selection) {
|
||||
const [root, ...parts] = file.webkitRelativePath.split('/');
|
||||
if (!root || root === '.' || root === '..' || !parts.length || name && root !== name) throw new Error('Choose one game folder with the folder picker.');
|
||||
name = root;
|
||||
const path = parts.join('/');
|
||||
if (path.length > 1024 || /[\\\x00-\x1f\x7f:]/.test(path) || parts.some(part => !part || part === '.' || part === '..' || /[. ]$/.test(part))) {
|
||||
throw new Error(`This file has an unsupported game path: ${file.webkitRelativePath}`);
|
||||
}
|
||||
const key = path.toLowerCase();
|
||||
if (paths.has(key)) throw new Error(`This folder has duplicate game paths: ${path}`);
|
||||
paths.add(key);
|
||||
size += file.size;
|
||||
if (!Number.isSafeInteger(size)) throw new Error('This folder exceeds the supported upload size.');
|
||||
files.push({ path, file });
|
||||
if (files.length > 200_000) throw new Error('Choose a folder with no more than 200,000 files.');
|
||||
}
|
||||
if (!files.length) throw new Error('The selected folder contains no files.');
|
||||
for (const { path } of files) {
|
||||
const parents = path.toLowerCase().split('/');
|
||||
parents.pop();
|
||||
while (parents.length) {
|
||||
if (paths.has(parents.join('/'))) throw new Error(`This folder uses the same game path for a file and a directory: ${path}`);
|
||||
parents.pop();
|
||||
}
|
||||
}
|
||||
files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
|
||||
return { name, files, size };
|
||||
}
|
||||
@@ -1,10 +1,10 @@
|
||||
import { json } from '@sveltejs/kit';
|
||||
import { createLibraryImport, libraryOverview } from '$lib/server/game-files/index.js';
|
||||
import { createLibraryUpload, libraryOverview } from '$lib/server/game-files/index.js';
|
||||
import { gameFileError, readGameJson } from '$lib/server/game-files/http.js';
|
||||
import { requireManagementOrigin } from '$lib/server/hosts/http.js';
|
||||
|
||||
export function GET() { return json(libraryOverview()); }
|
||||
export async function POST({ request }: { request: Request }) {
|
||||
try { requireManagementOrigin(request); return json({ version: createLibraryImport(await readGameJson(request)) }, { status: 202 }); }
|
||||
try { requireManagementOrigin(request); return json({ version: createLibraryUpload(await readGameJson(request, 32 * 1024 * 1024)) }, { status: 202 }); }
|
||||
catch (cause) { return gameFileError(cause); }
|
||||
}
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
import { json } from '@sveltejs/kit';
|
||||
import { browserUploadStatus } from '$lib/server/game-files/index.js';
|
||||
import { gameFileError } from '$lib/server/game-files/http.js';
|
||||
|
||||
export async function GET({ params }: { params: { id: string } }) {
|
||||
try { return json(await browserUploadStatus(params.id), { headers: { 'Cache-Control': 'no-store' } }); }
|
||||
catch (cause) { return gameFileError(cause); }
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
import { json } from '@sveltejs/kit';
|
||||
import { requestBrowserPublication } from '$lib/server/game-files/index.js';
|
||||
import { gameFileError } from '$lib/server/game-files/http.js';
|
||||
import { requireManagementOrigin } from '$lib/server/hosts/http.js';
|
||||
|
||||
export async function POST({ request, params }: { request: Request; params: { id: string } }) {
|
||||
try {
|
||||
requireManagementOrigin(request);
|
||||
return json(await requestBrowserPublication(params.id), { status: 202 });
|
||||
} catch (cause) { return gameFileError(cause); }
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
import { json } from '@sveltejs/kit';
|
||||
import { uploadBrowserFile } from '$lib/server/game-files/index.js';
|
||||
import { gameFileError } from '$lib/server/game-files/http.js';
|
||||
import { requireManagementOrigin } from '$lib/server/hosts/http.js';
|
||||
|
||||
function integerHeader(request: Request, name: string): number {
|
||||
const value = request.headers.get(name);
|
||||
if (value === null || !/^\d+$/.test(value) || !Number.isSafeInteger(Number(value))) throw new Error(`Provide a valid ${name} header.`);
|
||||
return Number(value);
|
||||
}
|
||||
export async function PUT({ request, params }: { request: Request; params: { id: string; path: string } }) {
|
||||
try {
|
||||
requireManagementOrigin(request);
|
||||
const chunk = { offset: integerHeader(request, 'X-Upload-Offset'), size: integerHeader(request, 'X-Upload-Length'), sha256: request.headers.get('X-Content-SHA256') ?? '' };
|
||||
return json(await uploadBrowserFile(params.id, params.path, chunk, request.body));
|
||||
} catch (cause) { return gameFileError(cause); }
|
||||
}
|
||||
@@ -1,9 +1,11 @@
|
||||
<script lang="ts">
|
||||
import { onMount } from 'svelte';
|
||||
import { onMount, tick } from 'svelte';
|
||||
import { page } from '$app/stores';
|
||||
import { beforeNavigate } from '$app/navigation';
|
||||
import type { GameLibrary, GameLibraryVersion } from '$lib/game-files.js';
|
||||
import { formatGameBytes } from '$lib/game-files.js';
|
||||
import type { Host } from '$lib/hosts.js';
|
||||
import { selectGameFolder, type SelectedGameFolder } from '$ui/game-folder.js';
|
||||
import { pollVisible } from '$ui/poll.js';
|
||||
import SectionHeader from '$ui/components/primitives/SectionHeader.svelte';
|
||||
import Button from '$ui/components/primitives/Button.svelte';
|
||||
@@ -11,110 +13,265 @@
|
||||
import EmptyState from '$ui/components/primitives/EmptyState.svelte';
|
||||
|
||||
type OverviewLibrary = Omit<GameLibrary, 'versions'> & { versions: Omit<GameLibraryVersion, 'files'>[] };
|
||||
let libraries = $state<OverviewLibrary[]>([]);
|
||||
let hosts = $state<Host[]>([]);
|
||||
let loaded = $state(false);
|
||||
let error = $state(''); let notice = $state(''); let busy = $state(false);
|
||||
let showImport = $state(false); let game = $state<'t5' | 't6'>('t5');
|
||||
let name = $state(''); let version = $state(''); let description = $state(''); let dlc = $state(''); let hostId = $state('');
|
||||
let filterGame = $state('all');
|
||||
let targets = $state<Record<string, string>>({});
|
||||
interface UploadFile { path: string; size: number; lastModified: number; receivedBytes: number; complete: boolean }
|
||||
interface UploadStatus { status: 'pending' | 'verifying' | 'published' | 'failed'; chunkSize: number; files: UploadFile[]; error?: string | null; version: { id: string; state: string } }
|
||||
type Phase = 'idle' | 'preparing' | 'uploading' | 'paused' | 'verifying' | 'published';
|
||||
let libraries = $state<OverviewLibrary[]>([]); let hosts = $state<Host[]>([]);
|
||||
let loaded = $state(false); let error = $state(''); let notice = $state(''); let busy = $state(false);
|
||||
let showUpload = $state(false); let game = $state<'t5' | 't6'>('t5');
|
||||
let name = $state(''); let version = $state(''); let description = $state('');
|
||||
let filterGame = $state('all'); let targets = $state<Record<string, string>>({});
|
||||
let folder = $state.raw<SelectedGameFolder | null>(null);
|
||||
let uploadStatus = $state.raw<UploadStatus | null>(null);
|
||||
let uploadId = $state(''); let uploadBusy = $state(false); let uploadError = $state('');
|
||||
let phase = $state<Phase>('idle'); let currentPath = $state(''); let pauseRequested = $state(false);
|
||||
let acceptedBytes = $state(0); let sendingBytes = $state(0); let completedFiles = $state(0);
|
||||
let folderInput = $state<HTMLInputElement>();
|
||||
let activeRequest: XMLHttpRequest | null = null; let disposed = false;
|
||||
const canManage = $derived($page.data.user?.role === 'admin');
|
||||
const onlineHosts = $derived(hosts.filter(host => host.connected && host.credentialActive && host.mode !== 'disabled'));
|
||||
const matching = $derived(libraries.filter(library => filterGame === 'all' || library.game === filterGame));
|
||||
const hostName = (id: string) => hosts.find(host => host.id === id)?.name ?? id;
|
||||
const totalBytes = $derived(folder?.size ?? uploadStatus?.files.reduce((total, file) => total + file.size, 0) ?? 0);
|
||||
const totalFiles = $derived(folder?.files.length ?? uploadStatus?.files.length ?? 0);
|
||||
const progressBytes = $derived(Math.min(totalBytes, acceptedBytes + sendingBytes));
|
||||
const transferring = $derived(uploadBusy && (phase === 'preparing' || phase === 'uploading'));
|
||||
const hostName = (id: string | null) => id ? hosts.find(host => host.id === id)?.name ?? id : 'Browser upload';
|
||||
|
||||
async function responseBody(response: Response) {
|
||||
let body;
|
||||
try { body = await response.json(); } catch { throw new Error('The controller returned an unexpected response. Sign in again if your session expired, then resume the upload.'); }
|
||||
if (!response.ok) throw new Error(body.error ?? 'The controller could not complete this request.');
|
||||
return body;
|
||||
}
|
||||
async function load() {
|
||||
try {
|
||||
const response = await fetch('/api/game-files');
|
||||
const body = await response.json();
|
||||
if (!response.ok) throw new Error(body.error ?? 'Could not load game libraries.');
|
||||
const body = await responseBody(await fetch('/api/game-files'));
|
||||
libraries = body.libraries; hosts = body.hosts; loaded = true;
|
||||
} catch (cause) { error = (cause as Error).message; }
|
||||
}
|
||||
async function act(url: string, payload: Record<string, unknown>, message: string) {
|
||||
async function download(versionId: string) {
|
||||
busy = true; error = ''; notice = '';
|
||||
try {
|
||||
const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
|
||||
const result = await response.json();
|
||||
if (!response.ok) throw new Error(result.error ?? 'Could not start this operation.');
|
||||
notice = message; await load(); return true;
|
||||
} catch (cause) { error = (cause as Error).message; return false; }
|
||||
finally { busy = false; }
|
||||
await responseBody(await fetch(`/api/game-files/${versionId}/download`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ hostId: targets[versionId] }) }));
|
||||
notice = 'Library download queued. Progress will update below.'; await load();
|
||||
} catch (cause) { error = (cause as Error).message; } finally { busy = false; }
|
||||
}
|
||||
async function startImport(event: SubmitEvent) {
|
||||
event.preventDefault();
|
||||
if (await act('/api/game-files', { game, name, version, description, dlc: dlc.split(',').map(value => value.trim()).filter(Boolean), hostId }, 'Import queued. The source host will scan and upload files, then verify and publish this version.')) showImport = false;
|
||||
function resetUpload() {
|
||||
folder = null; uploadStatus = null; uploadId = ''; phase = 'idle'; uploadError = ''; currentPath = '';
|
||||
acceptedBytes = 0; sendingBytes = 0; completedFiles = 0; pauseRequested = false;
|
||||
if (folderInput) folderInput.value = '';
|
||||
}
|
||||
function newVersion(library: OverviewLibrary) {
|
||||
showImport = true; game = library.game; name = library.name; description = library.description;
|
||||
dlc = library.versions[0]?.dlc.join(', ') ?? ''; version = '';
|
||||
document.getElementById('library-import')?.scrollIntoView({ behavior: 'smooth' });
|
||||
async function newUpload(library?: OverviewLibrary) {
|
||||
resetUpload(); showUpload = true; game = library?.game ?? 't5'; name = library?.name ?? '';
|
||||
description = library?.description ?? ''; version = '';
|
||||
await tick(); document.getElementById('library-upload')?.scrollIntoView({ behavior: 'smooth' });
|
||||
}
|
||||
onMount(() => pollVisible(load, 5000));
|
||||
function chooseFolder(event: Event) {
|
||||
uploadError = ''; folder = null;
|
||||
const input = event.currentTarget as HTMLInputElement;
|
||||
if (!input.files?.length) return;
|
||||
try {
|
||||
const selected = selectGameFolder(Array.from(input.files));
|
||||
if (uploadStatus) checkSelection(selected, uploadStatus);
|
||||
folder = selected;
|
||||
if (!name && !uploadId) name = game === 't5' ? 'Black Ops I game files' : 'Black Ops II game files';
|
||||
} catch (cause) { uploadError = (cause as Error).message; input.value = ''; }
|
||||
}
|
||||
function checkSelection(selected: SelectedGameFolder, status: UploadStatus) {
|
||||
const originals = new Map(status.files.map(file => [file.path, file]));
|
||||
if (selected.files.length !== originals.size || selected.files.some(({ path, file }) => {
|
||||
const original = originals.get(path); return !original || original.size !== file.size || original.lastModified !== file.lastModified;
|
||||
})) throw new Error('This folder does not match the original upload. Select the same unchanged folder, including its original file names, sizes, and modification dates. Upload changed game files as a new version.');
|
||||
}
|
||||
function applyStatus(status: UploadStatus) {
|
||||
uploadStatus = status;
|
||||
acceptedBytes = status.files.reduce((total, file) => total + file.receivedBytes, 0);
|
||||
completedFiles = status.files.filter(file => file.complete).length; sendingBytes = 0;
|
||||
}
|
||||
async function getStatus(): Promise<UploadStatus> {
|
||||
const status = await responseBody(await fetch(`/api/game-files/${uploadId}/upload`)) as UploadStatus;
|
||||
applyStatus(status); return status;
|
||||
}
|
||||
async function followVerification(initial: UploadStatus) {
|
||||
let status = initial; phase = 'verifying'; currentPath = '';
|
||||
while (!disposed && status.status === 'verifying') {
|
||||
await new Promise(resolve => setTimeout(resolve, 1500));
|
||||
if (disposed) return;
|
||||
status = await getStatus();
|
||||
}
|
||||
if (disposed) return;
|
||||
if (status.status !== 'published') throw new Error(status.error || 'Verification did not finish. Retry this upload to continue.');
|
||||
phase = 'published'; folder = null; notice = `${name || 'Game files'} ${version} published. You can download this version to a host below.`;
|
||||
if (folderInput) folderInput.value = '';
|
||||
await load();
|
||||
}
|
||||
async function resumeUpload(library: OverviewLibrary, item: OverviewLibrary['versions'][number]) {
|
||||
resetUpload(); showUpload = true; uploadId = item.id; game = library.game; name = library.name; version = item.version; description = item.description;
|
||||
uploadBusy = true;
|
||||
try {
|
||||
const status = await getStatus();
|
||||
if (status.status === 'verifying' || status.status === 'published') await followVerification(status);
|
||||
else { phase = 'paused'; uploadError = status.error ?? ''; }
|
||||
} catch (cause) { uploadError = (cause as Error).message; phase = 'paused'; }
|
||||
finally { uploadBusy = false; }
|
||||
await tick(); document.getElementById('library-upload')?.scrollIntoView({ behavior: 'smooth' });
|
||||
}
|
||||
function pauseUpload() { pauseRequested = true; activeRequest?.abort(); }
|
||||
async function sendChunk(path: string, file: File, offset: number, length: number): Promise<number> {
|
||||
const chunk = file.slice(offset, offset + length);
|
||||
const hash = await crypto.subtle.digest('SHA-256', await chunk.arrayBuffer());
|
||||
if (pauseRequested || disposed) throw new Error('Upload paused.');
|
||||
const sha256 = [...new Uint8Array(hash)].map(value => value.toString(16).padStart(2, '0')).join('');
|
||||
return new Promise((resolve, reject) => {
|
||||
const request = new XMLHttpRequest(); activeRequest = request;
|
||||
request.open('PUT', `/api/game-files/${uploadId}/upload/files/${path.split('/').map(encodeURIComponent).join('/')}`);
|
||||
request.setRequestHeader('Content-Type', 'application/octet-stream');
|
||||
request.setRequestHeader('X-Upload-Offset', String(offset)); request.setRequestHeader('X-Upload-Length', String(length));
|
||||
request.setRequestHeader('X-Content-SHA256', sha256); request.timeout = 300_000;
|
||||
request.upload.onprogress = event => { sendingBytes = Math.min(length, event.loaded); };
|
||||
request.onload = () => {
|
||||
activeRequest = null;
|
||||
try {
|
||||
const body = JSON.parse(request.responseText);
|
||||
if (request.status < 200 || request.status >= 300) throw new Error(body.error ?? `Upload failed (${request.status}).`);
|
||||
if (body.receivedBytes !== offset + length) throw new Error('The upload position changed. Resume to check the saved progress.');
|
||||
resolve(body.receivedBytes);
|
||||
} catch (cause) { reject(cause); }
|
||||
};
|
||||
request.onerror = () => { activeRequest = null; reject(new Error('The connection was interrupted. Resume to continue from the last saved chunk.')); };
|
||||
request.ontimeout = () => { activeRequest = null; reject(new Error('This chunk timed out. Resume to check saved progress and retry.')); };
|
||||
request.onabort = () => { activeRequest = null; reject(new Error('Upload paused.')); };
|
||||
request.send(chunk);
|
||||
});
|
||||
}
|
||||
async function startUpload(event: SubmitEvent) {
|
||||
event.preventDefault(); if (uploadBusy || !folder) return;
|
||||
if (!globalThis.crypto?.subtle) { uploadError = 'Folder uploads require a secure connection. Open this controller over HTTPS or localhost.'; return; }
|
||||
uploadBusy = true; pauseRequested = false; uploadError = ''; notice = ''; phase = 'preparing';
|
||||
try {
|
||||
if (!uploadId) {
|
||||
const result = await responseBody(await fetch('/api/game-files', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ game, name, version, description, files: folder.files.map(({ path, file }) => ({ path, size: file.size, lastModified: file.lastModified })) }) }));
|
||||
uploadId = result.version.id;
|
||||
}
|
||||
const status = await getStatus();
|
||||
if (status.status === 'verifying' || status.status === 'published') { await followVerification(status); return; }
|
||||
checkSelection(folder, status);
|
||||
const localFiles = new Map(folder.files.map(item => [item.path, item.file]));
|
||||
const chunkSize = Math.min(8_388_608, Math.max(1, status.chunkSize));
|
||||
phase = 'uploading';
|
||||
for (const remote of status.files) {
|
||||
if (pauseRequested || disposed) break;
|
||||
if (remote.complete) continue;
|
||||
currentPath = remote.path;
|
||||
const file = localFiles.get(remote.path)!;
|
||||
do {
|
||||
if (pauseRequested || disposed) break;
|
||||
const length = Math.min(chunkSize, remote.size - remote.receivedBytes);
|
||||
remote.receivedBytes = await sendChunk(remote.path, file, remote.receivedBytes, length);
|
||||
acceptedBytes += length; sendingBytes = 0;
|
||||
if (remote.receivedBytes === remote.size) { remote.complete = true; completedFiles++; }
|
||||
} while (!remote.complete);
|
||||
}
|
||||
if (pauseRequested || disposed) { phase = 'paused'; return; }
|
||||
phase = 'verifying'; currentPath = '';
|
||||
const verification = await responseBody(await fetch(`/api/game-files/${uploadId}/upload/complete`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' })) as UploadStatus;
|
||||
applyStatus(verification); await followVerification(verification);
|
||||
} catch (cause) {
|
||||
if (!disposed) { uploadError = pauseRequested ? '' : (cause as Error).message; phase = 'paused'; }
|
||||
} finally { uploadBusy = false; sendingBytes = 0; if (!disposed) void load(); }
|
||||
}
|
||||
beforeNavigate(navigation => {
|
||||
if (!transferring) return;
|
||||
if (navigation.type === 'leave' || !window.confirm('This upload is still transferring files. Leave this page? You can resume later by selecting the original unchanged folder.')) navigation.cancel();
|
||||
});
|
||||
onMount(() => {
|
||||
const stop = pollVisible(load, 5000);
|
||||
return () => { disposed = true; pauseRequested = true; activeRequest?.abort(); stop(); };
|
||||
});
|
||||
</script>
|
||||
|
||||
<svelte:head><title>Game Files | Electric Cherry</title></svelte:head>
|
||||
<div class="page">
|
||||
<SectionHeader title="Game Files" subtitle="Import immutable base-game versions and distribute verified copies to your hosts.">
|
||||
{#snippet actions()}{#if canManage}<Button onclick={() => showImport = !showImport}>{showImport ? 'Close import' : 'Import game files'}</Button>{/if}{/snippet}
|
||||
<SectionHeader title="Game Files" subtitle="Upload your T5 or T6 game folder, then distribute verified versions to your hosts.">
|
||||
{#snippet actions()}{#if canManage}<Button disabled={uploadBusy} onclick={() => newUpload()}>Upload game folder</Button>{/if}{/snippet}
|
||||
</SectionHeader>
|
||||
{#if error}<p class="ui-error" role="alert">{error}</p>{/if}
|
||||
{#if notice}<p role="status">{notice}</p>{/if}
|
||||
{#if !canManage}<p class="muted">Administrators import game files and distribute verified copies to hosts.</p>{/if}
|
||||
{#if canManage && showImport}
|
||||
<section class="card" id="library-import">
|
||||
<h2>Import an existing game volume</h2>
|
||||
<p>The selected host scans its {game}_game_files Docker volume, calculates SHA256 checksums, and streams a copy into controller storage. Publication requires every file to pass verification.</p>
|
||||
<form onsubmit={startImport}>
|
||||
<div class="fields">
|
||||
{#if !canManage}<p class="muted">Administrators upload game files and distribute verified copies to hosts.</p>{/if}
|
||||
{#if canManage && showUpload}
|
||||
<section class="card" id="library-upload">
|
||||
<div class="heading"><h2>{uploadId ? phase === 'published' ? 'Version published' : 'Continue folder upload' : 'Upload a game folder'}</h2><Button size="sm" variant="ghost" disabled={uploadBusy} onclick={() => showUpload = false}>Close</Button></div>
|
||||
<p>Select your complete T5 or T6 game folder, including its installed DLC. The files upload directly to this controller; a game host is only needed when you are ready to run servers.</p>
|
||||
{#if uploadError}<p class="ui-error" role="alert">{uploadError}</p>{/if}
|
||||
<form onsubmit={startUpload}>
|
||||
<fieldset disabled={uploadBusy || !!uploadId} class="fields">
|
||||
<label>Game<select bind:value={game}><option value="t5">Black Ops I (T5)</option><option value="t6">Black Ops II (T6)</option></select></label>
|
||||
<label>Source host<select required bind:value={hostId}><option value="">Select an online host</option>{#each onlineHosts as host}<option value={host.id}>{host.name}</option>{/each}</select></label>
|
||||
<label>Library name<input required maxlength="160" bind:value={name} placeholder="Black Ops II — Complete Server Files" /></label>
|
||||
<label>New version label<input required maxlength="120" bind:value={version} placeholder="2026-10-03" /></label>
|
||||
<label class="wide">Description<textarea maxlength="4000" bind:value={description} rows="2"></textarea></label>
|
||||
<label class="wide">Content / DLC (comma separated)<input bind:value={dlc} placeholder="Base game, Nuketown, Die Rise, Mob of the Dead, Buried, Origins" /></label>
|
||||
<label>Library name<input required maxlength="160" bind:value={name} placeholder="Black Ops II game files" /></label>
|
||||
<label>Version label<input required maxlength="120" bind:value={version} placeholder="2026-10-04" /></label>
|
||||
<label class="wide">Description <span class="muted">(optional)</span><textarea maxlength="4000" bind:value={description} rows="2"></textarea></label>
|
||||
</fieldset>
|
||||
{#if phase !== 'verifying' && phase !== 'published'}
|
||||
<label class="folder-picker">{uploadId ? 'Select the original unchanged folder' : 'Game folder'}<input bind:this={folderInput} type="file" webkitdirectory multiple onchange={chooseFolder} disabled={uploadBusy} aria-describedby="folder-help" /></label>
|
||||
<p class="muted" id="folder-help">{uploadId ? 'To resume, file names, sizes, and modification dates must match the original upload.' : 'Choose the game directory itself. Its top-level folder name is removed once; all files and subfolders inside it keep their paths.'}</p>
|
||||
{/if}
|
||||
{#if folder}<div class="folder-summary"><strong>{folder.name}</strong><span>{folder.files.length.toLocaleString()} files · {formatGameBytes(folder.size)}</span><details><summary>Preview folder paths</summary><ul class="path-list">{#each folder.files.slice(0, 8) as file}<li>{file.path}</li>{/each}</ul>{#if folder.files.length > 8}<p class="muted">And {(folder.files.length - 8).toLocaleString()} more files.</p>{/if}</details></div>{/if}
|
||||
{#if phase !== 'idle'}<div class="upload-progress" aria-live="polite">
|
||||
<div class="heading"><strong>{phase === 'preparing' ? 'Preparing upload…' : phase === 'uploading' ? 'Uploading game files' : phase === 'verifying' ? 'Verifying and publishing…' : phase === 'published' ? 'Published and ready to distribute' : 'Upload paused'}</strong><span>{completedFiles.toLocaleString()} / {totalFiles.toLocaleString()} files</span></div>
|
||||
<progress max={totalBytes || Math.max(1, totalFiles)} value={totalBytes ? progressBytes : completedFiles} aria-label="Game folder upload progress"></progress>
|
||||
<p>{formatGameBytes(progressBytes)} / {formatGameBytes(totalBytes)} saved or transferring</p>
|
||||
{#if currentPath}<p class="current-file">{currentPath}</p>{/if}
|
||||
{#if phase === 'verifying'}<p class="muted">The controller checks every file and publishes this version when verification finishes. Verification continues if you leave this page.</p>{:else if phase === 'paused'}<p class="muted">Saved chunks are kept on the controller. Resume this upload to check the saved progress and retry.</p>{/if}
|
||||
</div>{/if}
|
||||
<div class="upload-actions">
|
||||
{#if transferring}<Button onclick={pauseUpload} disabled={pauseRequested}>{pauseRequested ? 'Pausing…' : 'Pause upload'}</Button>
|
||||
{:else if phase !== 'verifying' && phase !== 'published'}<Button type="submit" variant="primary" disabled={uploadBusy || !folder}>{uploadId ? 'Resume upload' : 'Upload and publish'}</Button>{/if}
|
||||
{#if phase === 'idle' || phase === 'uploading'}<span class="muted">Keep this page open while files transfer. Interrupted uploads can be resumed below.</span>{/if}
|
||||
</div>
|
||||
<Button type="submit" disabled={busy || !onlineHosts.length}>Start import</Button>
|
||||
{#if !onlineHosts.length}<p>Enroll an online source host in <a href="/hosts">Hosts</a> before importing.</p>{/if}
|
||||
</form>
|
||||
</section>
|
||||
{/if}
|
||||
<div class="filters"><label>Game<select bind:value={filterGame}><option value="all">All games</option><option value="t5">Black Ops I</option><option value="t6">Black Ops II</option></select></label><span class="muted">{libraries.length} libraries · Base-game files and runtime images are versioned separately.</span></div>
|
||||
<div class="filters"><label>Game<select bind:value={filterGame}><option value="all">All games</option><option value="t5">Black Ops I</option><option value="t6">Black Ops II</option></select></label><span class="muted">{libraries.length} libraries · Game folders and runtime images are versioned separately.</span></div>
|
||||
{#each matching as library (library.id)}
|
||||
<section class="card">
|
||||
<div class="heading"><div><h2>{library.name}</h2><p class="muted">{library.game.toUpperCase()} · {library.description}</p></div>{#if canManage}<Button size="sm" onclick={() => newVersion(library)}>Import new version</Button>{/if}</div>
|
||||
<div class="heading"><div><h2>{library.name}</h2><p class="muted">{library.game.toUpperCase()} · {library.description}</p></div>{#if canManage}<Button size="sm" disabled={uploadBusy} onclick={() => newUpload(library)}>Upload new version</Button>{/if}</div>
|
||||
{#each library.versions as item (item.id)}
|
||||
{@const browserUpload = !item.sourceHostId}
|
||||
<article class="version">
|
||||
<div class="heading"><h3>{item.version}</h3><Badge variant={item.state === 'failed' ? 'danger' : item.state === 'ready' ? 'online' : 'info'}>{item.state === 'ready' ? 'Published' : item.state === 'importing' ? 'Importing' : 'Failed'}</Badge></div>
|
||||
<div class="heading"><h3>{item.version}</h3><Badge variant={item.state === 'failed' ? 'danger' : item.state === 'ready' ? 'online' : 'info'}>{item.state === 'ready' ? 'Published' : item.state === 'importing' ? browserUpload ? item.id === uploadId && phase === 'verifying' ? 'Verifying' : 'Uploading' : 'Importing' : 'Failed'}</Badge></div>
|
||||
<p>{formatGameBytes(item.sizeBytes)} · {item.fileCount.toLocaleString()} files · Created {new Date(item.createdAt).toLocaleString()}</p>
|
||||
{#if item.dlc.length}<p>Content: {item.dlc.join(', ')}</p>{/if}
|
||||
{#if item.error}<p class="ui-error">{item.error}</p>{/if}
|
||||
<details><summary>Version details</summary><dl><dt>Immutable version ID</dt><dd>{item.id}</dd><dt>Manifest SHA256</dt><dd>{item.manifestSha256 ?? 'Waiting for source scan'}</dd><dt>Controller storage</dt><dd>{item.storageLocation}</dd><dt>Imported from</dt><dd>{hostName(item.sourceHostId)} / {item.sourceVolume}</dd></dl><a href={`/api/game-files/${item.id}`} target="_blank" rel="noreferrer">View complete file manifest</a></details>
|
||||
<details><summary>Version details</summary><dl><dt>Immutable version ID</dt><dd>{item.id}</dd><dt>Manifest SHA256</dt><dd>{item.manifestSha256 ?? 'Available after verification'}</dd><dt>Uploaded from</dt><dd>{browserUpload ? 'Game folder in browser' : `${hostName(item.sourceHostId)} / ${item.sourceVolume}`}</dd></dl>{#if item.state === 'ready'}<a href={`/api/game-files/${item.id}`} target="_blank" rel="noreferrer">View complete file manifest</a>{/if}</details>
|
||||
{#if item.state === 'ready'}
|
||||
{#if canManage}<div class="download"><label>Download to host<select bind:value={targets[item.id]}><option value="">Select host</option>{#each onlineHosts as host}<option value={host.id}>{host.name} · {formatGameBytes(Number(host.inventory.storageAvailable ?? 0))} free</option>{/each}</select></label><Button size="sm" disabled={busy || !targets[item.id]} onclick={() => act(`/api/game-files/${item.id}/download`, { hostId: targets[item.id] }, 'Library download queued. Progress will update below.')}>Download / verify</Button></div>{/if}
|
||||
{#if canManage}<div class="download"><label>Download to host<select bind:value={targets[item.id]}><option value="">Select host</option>{#each onlineHosts as host}<option value={host.id}>{host.name} · {formatGameBytes(Number(host.inventory.storageAvailable ?? 0))} free</option>{/each}</select></label><Button size="sm" disabled={busy || !targets[item.id]} onclick={() => download(item.id)}>Download / verify</Button></div>{#if !onlineHosts.length}<p class="muted">This version is stored and ready. <a href="/hosts">Connect a host</a> when you want to deploy game servers.</p>{/if}{/if}
|
||||
<div class="table-wrap"><table><thead><tr><th>Host</th><th>Cache state</th><th>Progress</th><th>Detail</th></tr></thead><tbody>
|
||||
{#each item.caches as cache}<tr><td><a href={`/hosts/${cache.hostId}`}>{hostName(cache.hostId)}</a></td><td>{cache.status}{!hosts.find(host => host.id === cache.hostId)?.connected ? ' · offline' : ''}</td><td>{#if cache.status === 'downloading' || cache.status === 'verifying'}<progress max={cache.bytesTotal || 1} value={cache.bytesDownloaded}></progress><small>{formatGameBytes(cache.bytesDownloaded)} / {formatGameBytes(cache.bytesTotal)}</small>{:else if cache.status === 'ready' || cache.status === 'outdated'}Verified{cache.status === 'outdated' ? ' · older version' : ''}{:else}—{/if}</td><td>{cache.error ?? ''}</td></tr>{:else}<tr><td colspan="4">Enroll a host to cache this version.</td></tr>{/each}
|
||||
{#each item.caches as cache}<tr><td><a href={`/hosts/${cache.hostId}`}>{hostName(cache.hostId)}</a></td><td>{cache.status}{!hosts.find(host => host.id === cache.hostId)?.connected ? ' · offline' : ''}</td><td>{#if cache.status === 'downloading' || cache.status === 'verifying'}<progress max={cache.bytesTotal || 1} value={cache.bytesDownloaded} aria-label="Host download progress"></progress><small>{formatGameBytes(cache.bytesDownloaded)} / {formatGameBytes(cache.bytesTotal)}</small>{:else if cache.status === 'ready' || cache.status === 'outdated'}Verified{cache.status === 'outdated' ? ' · older version' : ''}{:else}—{/if}</td><td>{cache.error ?? ''}</td></tr>{:else}<tr><td colspan="4">No host copies yet.</td></tr>{/each}
|
||||
</tbody></table></div>
|
||||
{:else if item.state === 'importing'}<p class="muted">The agent operation continues independently of this page. An interrupted import is reconciled when the host reconnects.</p>{/if}
|
||||
{:else if browserUpload}<p class="muted">Resume with the original unchanged folder. Published versions can be downloaded to any enrolled host.</p>{#if canManage}<div><Button size="sm" disabled={uploadBusy} onclick={() => resumeUpload(library, item)}>Resume upload</Button></div>{/if}
|
||||
{:else if item.state === 'importing'}<p class="muted">The existing host import continues independently. It is reconciled when the host reconnects.</p>{/if}
|
||||
</article>
|
||||
{/each}
|
||||
</section>
|
||||
{:else}{#if loaded}<EmptyState title="No game libraries yet" description="Administrators can import T5 or T6 game files from an enrolled host. Each published version can be shared by many instances." />{:else}<p role="status">Loading game libraries…</p>{/if}{/each}
|
||||
{:else}{#if loaded}<EmptyState title="No game libraries yet" description="Upload a complete T5 or T6 game folder to get started. You can add a host after the files are published." />{:else}<p role="status">Loading game libraries…</p>{/if}{/each}
|
||||
</div>
|
||||
|
||||
<style>
|
||||
.page, .card, .version, form { display: grid; gap: 20px; }
|
||||
.card { padding: 24px; border: 1px solid var(--border-subtle); background: var(--surface); border-radius: var(--radius-md); }
|
||||
.version { padding-top: 20px; border-top: 1px solid var(--border-subtle); }
|
||||
.heading, .filters, .download { display: flex; gap: 16px; align-items: center; justify-content: space-between; flex-wrap: wrap; }
|
||||
.download { justify-content: flex-start; align-items: end; }
|
||||
.fields { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 16px; }
|
||||
.wide { grid-column: 1 / -1; } label { display: grid; gap: 6px; font-size: var(--text-sm); }
|
||||
input, select, textarea { width: 100%; min-width: 0; box-sizing: border-box; padding: 10px; background: var(--surface); color: inherit; border: 1px solid var(--border-strong); border-radius: var(--radius-sm); }
|
||||
h2, h3, p { margin: 0; } h2 { font-size: var(--text-md); } h3 { font-size: var(--text-sm); }
|
||||
p, td, th, details { font-size: var(--text-sm); line-height: 1.6; } .muted, small { color: var(--text-secondary); }
|
||||
small { display: block; } a { color: var(--accent-primary-hover); } summary { cursor: pointer; }
|
||||
dl { display: grid; grid-template-columns: auto 1fr; gap: 6px 16px; } dd { margin: 0; overflow-wrap: anywhere; }
|
||||
.table-wrap { overflow-x: auto; } table { width: 100%; border-collapse: collapse; text-align: left; } th, td { padding: 10px; border-bottom: 1px solid var(--border-subtle); }
|
||||
@media(max-width: 640px) { .fields { grid-template-columns: 1fr; } .card { padding: 16px; } dl { grid-template-columns: 1fr; } }
|
||||
.page, .card, .version, form { display:grid; gap:20px; }
|
||||
.card { padding:24px; min-width:0; border:1px solid var(--border-subtle); background:var(--surface); border-radius:var(--radius-md); }
|
||||
.version { padding-top:20px; border-top:1px solid var(--border-subtle); }
|
||||
.heading, .filters, .download, .upload-actions { display:flex; gap:16px; align-items:center; justify-content:space-between; flex-wrap:wrap; }
|
||||
.download, .upload-actions { justify-content:flex-start; align-items:end; }
|
||||
.fields { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:16px; border:0; padding:0; margin:0; min-width:0; }
|
||||
.wide { grid-column:1/-1; } label { display:grid; gap:6px; font-size:var(--text-sm); }
|
||||
input, select, textarea { width:100%; min-width:0; box-sizing:border-box; padding:10px; background:var(--surface); color:inherit; border:1px solid var(--border-strong); border-radius:var(--radius-sm); }
|
||||
input:disabled, select:disabled, textarea:disabled { opacity:.7; } input[type='file'] { padding:16px; cursor:pointer; }
|
||||
.folder-summary,.upload-progress { padding:20px; display:grid; gap:12px; background:var(--surface-sunken); border:1px solid var(--border-subtle); border-radius:var(--radius-md); min-width:0; }
|
||||
.folder-summary>span,.upload-progress span,.upload-actions>span { color:var(--text-secondary); font-size:var(--text-sm); }
|
||||
.path-list { padding-left:20px; font-family:var(--font-mono); font-size:var(--text-xs); overflow-wrap:anywhere; }
|
||||
.current-file { font-family:var(--font-mono); font-size:var(--text-xs); overflow-wrap:anywhere; } progress { width:100%; accent-color:var(--accent-primary); }
|
||||
h2,h3,p { margin:0; } h2 { font-size:var(--text-md); } h3 { font-size:var(--text-sm); }
|
||||
p,td,th,details { font-size:var(--text-sm); line-height:1.6; } .muted,small { color:var(--text-secondary); }
|
||||
small { display:block; } a { color:var(--accent-primary-hover); } summary { cursor:pointer; }
|
||||
dl { display:grid; grid-template-columns:auto 1fr; gap:6px 16px; } dd { margin:0; overflow-wrap:anywhere; }
|
||||
.table-wrap { overflow-x:auto; } table { width:100%; border-collapse:collapse; text-align:left; } th,td { padding:10px; border-bottom:1px solid var(--border-subtle); }
|
||||
@media(max-width:640px) { .fields { grid-template-columns:1fr; } .card,.folder-summary,.upload-progress { padding:16px; } dl { grid-template-columns:1fr; } .heading>div { min-width:0; } }
|
||||
</style>
|
||||
|
||||
Reference in New Issue
Block a user