Merge pull request #1014 from bbassie/feature/patched-scenario

Add create-scenario command to clusteriohost
This commit is contained in:
Cooldude2606 authored and GitHub committed 2026-10-06 16:37:16 +01:00
commit b07c25aa7e
11 files changed
+496 -36

No files matched your search

+2 -24
View File
@@ -10,7 +10,7 @@ const execAsync = util.promisify(exec);
import * as lib from "@clusterio/lib";
import { FactorioServer } from "./server.js";
import { SaveModule, patch } from "./patch.js";
import { loadModules, patch } from "./patch.js";
import { exportData } from "./export.js";
import type Host from "./Host.js";
import { BaseInstancePlugin, InstanceHooks } from "./BaseInstancePlugin.js";
@@ -1007,29 +1007,7 @@ end`.replace(/\r?\n/g, " ");
// Patch save with lua modules from plugins
this.logger.verbose("Patching save");
// Find plugin modules to patch in
let modules: Map<string, SaveModule> = new Map();
for (const pluginInfo of this.loadedPlugins) {
let module = await SaveModule.fromPluginInfo(pluginInfo);
if (!module) {
continue;
}
modules.set(module.info.name, module);
}
// Find stand alone modules to load
// XXX for now only the included clusterio module is loaded
let modulesDirectory = path.join(import.meta.dirname, "..", "..", "..", "modules");
for (let entry of await fs.readdir(modulesDirectory, { withFileTypes: true })) {
if (entry.isDirectory()) {
if (modules.has(entry.name)) {
throw new Error(`Module with name ${entry.name} already exists in a plugin`);
}
let module = await SaveModule.fromDirectory(path.join(modulesDirectory, entry.name));
modules.set(module.info.name, module);
}
}
let modules = await loadModules(this.loadedPlugins);
await patch(this.path("saves", saveName), [...modules.values()]);
return saveName;
}
+171
View File
@@ -0,0 +1,171 @@
// Implementation of the create-scenario command
import fs from "node:fs/promises";
import os from "node:os";
import JSZip from "jszip";
import path from "path";
import * as lib from "@clusterio/lib";
import { logger } from "@clusterio/lib";
import { loadModules, patch, SaveModule } from "./patch.js";
import { findVersion } from "./server.js";
/**
* Create a scenario patched with the given modules
*
* Runs the save patching on the scenario at scenarioPath and writes the
* result to outputPath. The scenario can be a directory, a zipped
* scenario or a save.
*
* @param scenarioPath - Path to the scenario to patch.
* @param outputPath - Path to write the patched scenario to.
* @param modules - Description of the modules to patch.
* @param zip - Write a zip file instead of a directory.
*/
export async function createScenario(
scenarioPath: string,
outputPath: string,
modules: SaveModule[],
zip = false,
) {
try {
await fs.stat(outputPath);
throw new Error(`${outputPath} already exists`);
} catch (err: any) {
if (err.code !== "ENOENT") {
throw err;
}
}
const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "clusterio-scenario-"));
try {
const tempPath = path.join(tempDir, "scenario.zip");
if ((await fs.stat(scenarioPath)).isDirectory()) {
await zipDirectory(scenarioPath, tempPath);
} else {
await fs.copyFile(scenarioPath, tempPath);
}
await patch(tempPath, modules);
if (zip) {
await fs.mkdir(path.dirname(outputPath), { recursive: true });
await fs.copyFile(tempPath, outputPath);
} else {
await extractZip(tempPath, outputPath);
}
} finally {
await fs.rm(tempDir, { recursive: true, force: true });
}
}
async function zipDirectory(dirPath: string, zipPath: string) {
const root = path.basename(path.resolve(dirPath));
const zip = new JSZip();
let dirs: [string, string][] = [[dirPath, root]];
while (dirs.length) {
let [dir, relativeDir] = dirs.pop()!;
for (let entry of await fs.readdir(dir, { withFileTypes: true })) {
let fsPath = path.join(dir, entry.name);
let relativePath = path.posix.join(relativeDir, entry.name);
if (entry.isFile()) {
zip.file(relativePath, await fs.readFile(fsPath));
} else if (entry.isDirectory()) {
dirs.push([fsPath, relativePath]);
}
}
}
await fs.writeFile(zipPath, await zip.generateAsync({ type: "nodebuffer" }));
}
async function extractZip(zipPath: string, dirPath: string) {
const zip = await JSZip.loadAsync(await fs.readFile(zipPath));
const root = lib.findRoot(zip);
for (let file of Object.values(zip.files)) {
if (file.dir || !file.name.startsWith(`${root}/`)) {
continue;
}
const fsPath = path.join(dirPath, file.name.slice(root.length + 1));
await fs.mkdir(path.dirname(fsPath), { recursive: true });
await fs.writeFile(fsPath, await file.async("nodebuffer"));
}
}
/**
* Yargs create-scenario command
*
* @param yargs - yargs command builder.
*/
export function createScenarioCommand(yargs: any) {
yargs
.positional("output", {
describe: "Path to write the scenario to",
type: "string",
})
.option("zip", {
type: "boolean", nargs: 0, default: false,
describe: "Write the scenario as a zip file instead of a directory",
})
.option("scenario", {
nargs: 1,
describe:
"Path to a scenario directory, zipped scenario or save to patch. " +
"Defaults to the freeplay scenario of the Factorio install in host.factorio_directory",
type: "string",
})
.option("factorio-version", {
nargs: 1,
describe: "Factorio version to take the freeplay scenario from",
default: "latest",
type: "string",
})
.option("plugins", {
describe: "Plugins to patch modules from, defaults to all plugins enabled in the host config",
type: "array",
})
;
}
/**
* Handle yargs create-scenario command
*
* @param args - yargs args object.
* @param hostConfig - Host config.
* @param pluginInfos - Plugins available to the host.
*/
export async function handleCreateScenarioCommand(
args: Record<string, unknown>,
hostConfig: lib.HostConfig,
pluginInfos: lib.PluginNodeEnvInfo[],
) {
let selected: lib.PluginNodeEnvInfo[];
if (args.plugins) {
selected = (args.plugins as string[]).map(name => {
const pluginInfo = pluginInfos.find(info => info.name === name);
if (!pluginInfo) {
throw new Error(`Plugin ${name} is not in the plugin list`);
}
return pluginInfo;
});
} else {
selected = pluginInfos.filter(
info => info.instanceEntrypoint && hostConfig.get(`${info.name}.load_plugin`)
);
}
let scenarioPath = args.scenario as string | undefined;
if (scenarioPath === undefined) {
const factorioDir = hostConfig.get("host.factorio_directory");
const version = args.factorioVersion as lib.TargetVersion;
if (!lib.isTargetVersion(version)) {
throw new Error(`Invalid Factorio version ${version}`);
}
const [dataDir] = await findVersion(factorioDir, version);
scenarioPath = path.join(dataDir, "base", "scenarios", "freeplay");
}
const modules = await loadModules(selected);
logger.info(`Patching ${scenarioPath} with modules ${[...modules.keys()].join(", ")}`);
await createScenario(scenarioPath, args.output as string, [...modules.values()], Boolean(args.zip));
logger.info(`Created scenario ${args.output}`);
}
+34
View File
@@ -145,6 +145,40 @@ export class SaveModule {
}
}
/**
* Load the modules to patch into a save
*
* Collects the modules provided by the given plugins together with the
* modules bundled with the host package.
*
* @param pluginInfos - Plugins to load modules from.
* @returns Map of module name to module.
*/
export async function loadModules(pluginInfos: Iterable<lib.PluginNodeEnvInfo>) {
let modules: Map<string, SaveModule> = new Map();
for (let pluginInfo of pluginInfos) {
let module = await SaveModule.fromPluginInfo(pluginInfo);
if (!module) {
continue;
}
modules.set(module.info.name, module);
}
// Find stand alone modules to load
// XXX for now only the included clusterio module is loaded
let modulesDirectory = path.join(import.meta.dirname, "..", "..", "..", "modules");
for (let entry of await fs.readdir(modulesDirectory, { withFileTypes: true })) {
if (entry.isDirectory()) {
if (modules.has(entry.name)) {
throw new Error(`Module with name ${entry.name} already exists in a plugin`);
}
let module = await SaveModule.fromDirectory(path.join(modulesDirectory, entry.name));
modules.set(module.info.name, module);
}
}
return modules;
}
export class PatchInfo {
static currentVersion = 1;
+4 -3
View File
@@ -181,9 +181,11 @@ async function downloadAndExtractTar(url: string, targetDir: string) {
* Version to look for, supports the special value "latest" for the
* latest version available.
* @returns Array with path to data dir and version found.
* @internal
*/
async function findVersion(factorioDir: string, targetVersion: lib.TargetVersion): Promise<[string, lib.FullVersion]> {
export async function findVersion(
factorioDir: string,
targetVersion: lib.TargetVersion,
): Promise<[string, lib.FullVersion]> {
// Check if this is a direct installation dir
const directVersion = await getFactorioVersion(factorioDir);
if (directVersion !== null) {
@@ -1609,7 +1611,6 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
// For testing only
export const _getFactorioVersion = getFactorioVersion;
export const _versionOrder = versionOrder;
export const _findVersion = findVersion;
export const _listFactorioVersions = listFactorioVersions;
export const _downloadAndExtractZip = downloadAndExtractZip;
export const _downloadAndExtractTar = downloadAndExtractTar;