Create FactorioServer and Instance through async factories

FactorioServer.fromOptions finds the Factorio install and generates the
RCON password before constructing, so _version and _dataDir are never
null and setTargetVersion and init are gone. checkForUpdates is now a
module function called before fromOptions.

Instance.fromConfig resolves the version, downloads Factorio if needed
and builds the server, then constructs the instance with it. It runs
before the instance is connected, so the starting and stopped statuses
and the version requests go through the host link. FactorioVersionsRequest
and LatestReleasesRequest now accept host as a source, and the host
tracks starting instances so a second start during a download is
rejected. Plugin loading stays a separate loadPlugins step after the
instance is connected.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
bbassieandClaude Opus 5.5 committed 2026-10-24 00:11:22 +00:00
1 parent 3a81cfd94b
commit abb04f3258
12 files changed
+364 -221

No files matched your search

+23
View File
@@ -77,6 +77,29 @@ describe("host/src/Host", function() {
await fs.access(modsDirectory);
});
});
describe("._connectInstance()", function() {
const originalFromConfig = Instance.fromConfig;
afterEach(function() {
Instance.fromConfig = originalFromConfig;
});
it("should reject a second start while the instance is starting", async function() {
const hostConfig = new lib.HostConfig("host");
const host = new Host(new HostConnector(hostConfig, []), hostConfig, []);
const instanceConfig = new lib.InstanceConfig("host", { "instance.id": 7 });
host.assignedInstances.set(7, { path: "dir", config: instanceConfig });
let fail;
Instance.fromConfig = () => new Promise((resolve, reject) => { fail = reject; });
const first = host._connectInstance(7);
await assert.rejects(host._connectInstance(7), /Instance with ID 7 is running/);
assert.equal(host._unconnectedStatus(7), "starting");
fail(new Error("start failed"));
await assert.rejects(first, /start failed/);
assert.equal(host._unconnectedStatus(7), "stopped");
assert.equal(host.instanceConnections.has(7), false);
});
});
describe(".handleSyncUserListsEvent()", function() {
const hostAddress = lib.Address.fromShorthand({ hostId: 1 });
const instanceAddress = lib.Address.fromShorthand({ instanceId: 1 });
+75 -2
View File
@@ -1,4 +1,5 @@
import assert from "node:assert/strict";
import fs from "node:fs/promises";
import path from "node:path";
import * as lib from "@clusterio/lib";
@@ -12,6 +13,79 @@ const addr = lib.Address.fromShorthand;
describe("class Instance", function() {
describe(".fromConfig()", function() {
const factorioDir = path.join("test", "file", "factorio");
const dir = path.join("temp", "test", "instance_from_config");
let host;
let sent;
let saveListUpdates;
let requests;
function makeConfig(fields) {
return new lib.InstanceConfig("host", { "instance.id": 5, "instance.name": "foo", ...fields });
}
function fromConfig(config) {
const connector = new MockConnector(addr({ instanceId: 5 }), addr({ hostId: 1 }));
return Instance.fromConfig(config, host, connector, dir, factorioDir);
}
beforeEach(async function() {
await fs.rm(dir, { recursive: true, force: true });
await fs.mkdir(dir, { recursive: true });
sent = [];
saveListUpdates = [];
requests = [];
host = {
assignFreeGamePort: async () => 34100,
send(event) { sent.push(event); },
async sendTo(dst, request) {
requests.push(request.constructor.name);
if (request instanceof lib.FactorioVersionsRequest) {
return [];
}
if (request instanceof lib.LatestReleasesRequest) {
return { stable: { headless: "0.1.1" } };
}
throw new Error(`Unexpected request ${request.constructor.name}`);
},
async sendSaveListUpdate(instanceId, savesDir) { saveListUpdates.push([instanceId, savesDir]); },
};
});
it("should create an instance with a server for the installed version", async function() {
const instance = await fromConfig(makeConfig({}));
assert.equal(instance.status, "starting");
assert.equal(instance.server.version, "0.1.2");
assert.equal(instance.server.gamePort, 34100);
assert.deepEqual(sent, [new lib.InstanceStatusChangedEvent(5, "starting", 34100, "latest")]);
assert.deepEqual(requests, ["FactorioVersionsRequest"]);
});
it("should use the configured game port", async function() {
const instance = await fromConfig(makeConfig({ "factorio.game_port": 34200 }));
assert.equal(instance.server.gamePort, 34200);
});
it("should resolve a release channel through the controller", async function() {
const instance = await fromConfig(makeConfig({ "factorio.version": "stable" }));
assert.equal(instance.server.version, "0.1.1");
assert.deepEqual(requests, ["FactorioVersionsRequest", "LatestReleasesRequest"]);
});
it("should load player stats", async function() {
await fs.writeFile(path.join(dir, "instance-stats.json"), JSON.stringify({
players: [["player", { join_count: 2 }]],
player_autosave_slot: 3,
}));
const instance = await fromConfig(makeConfig({}));
assert.equal(instance.playerStats.get("player").joinCount, 2);
assert.equal(instance._playerAutosaveSlot, 3);
});
it("should report the instance stopped if the version is not installed", async function() {
await assert.rejects(fromConfig(makeConfig({ "factorio.version": "0.1.5" })), /0\.1\.5/);
assert.deepEqual(sent, [
new lib.InstanceStatusChangedEvent(5, "starting", 34100, "0.1.5"),
new lib.InstanceStatusChangedEvent(5, "stopped", 34100, "0.1.5"),
]);
assert.deepEqual(saveListUpdates, [[5, path.join(dir, "saves")]]);
});
});
let src;
let dst = addr({ hostId: 1 });
let instance;
@@ -21,8 +95,7 @@ describe("class Instance", function() {
instanceConfig.set("instance.name", "foo");
src = addr({ instanceId: instanceConfig.get("instance.id") });
connector = new MockConnector(src, dst);
instance = new Instance({ assignGamePort: () => 1 }, connector, "dir", "factorioDir", instanceConfig);
instance.server = new MockServer();
instance = new Instance({}, connector, "dir", instanceConfig, new MockServer());
});
describe(".name", function() {
+1 -2
View File
@@ -9,8 +9,7 @@ describe("host/src/export", function() {
let testServer;
before(async function() {
let writePath = path.join("temp", "test", "server");
testServer = new FactorioServer(path.join("test", "file", "factorio"), writePath, {});
await testServer.init();
testServer = await FactorioServer.fromOptions(path.join("test", "file", "factorio"), writePath, {});
});
describe("exportLocale()", function() {
+52 -51
View File
@@ -223,7 +223,10 @@ describe("host/server", function() {
describe("class FactorioServer", function() {
let writePath = path.join("temp", "test", "server");
let server = new hostServer.FactorioServer(path.join("test", "file", "factorio"), writePath, {});
let server;
before(async function() {
server = await hostServer.FactorioServer.fromOptions(path.join("test", "file", "factorio"), writePath, {});
});
describe("constructor()", function() {
it("should handle dashes in write path with strapPaths enabled", function() {
@@ -231,28 +234,37 @@ describe("host/server", function() {
new hostServer.FactorioServer(
path.join("test", "file", "factorio"),
path.join("temp", "test", "server-1"),
{ stripPaths: true }
path.join("test", "file", "factorio", "0.1.2", "data"),
"0.1.2",
{ stripPaths: true, rconPassword: "" }
);
});
});
describe(".setTargetVersion()", function() {
it("should override the target version before init", function() {
const fresh = new hostServer.FactorioServer(
path.join("test", "file", "factorio"), writePath, {}
describe(".fromOptions()", function() {
it("should resolve the requested version", async function() {
const found = await hostServer.FactorioServer.fromOptions(
path.join("test", "file", "factorio"), writePath, { version: "0.1.1" }
);
fresh.setTargetVersion("0.1.5");
assert.equal(fresh._targetVersion, "0.1.5");
assert.equal(found.version, "0.1.1");
assert.equal(found.dataPath(), path.join("test", "file", "factorio", "0.1.1", "data"));
assert.equal(found._state, "init");
});
});
describe(".init()", function() {
it("should not throw on first call", async function() {
await server.init();
it("should generate an RCON password if none is given", async function() {
assert.equal(typeof server.rconPassword, "string");
assert.equal(server.rconPassword.length, 10);
const given = await hostServer.FactorioServer.fromOptions(
path.join("test", "file", "factorio"), writePath, { rconPassword: "secret" }
);
assert.equal(given.rconPassword, "secret");
});
it("should throw if called twice", async function() {
await assert.rejects(server.init(), new Error("Expected state new but state is init"));
it("should reject if the version is not installed", async function() {
await assert.rejects(
hostServer.FactorioServer.fromOptions(
path.join("test", "file", "factorio"), writePath, { version: "0.1.5" }
),
/Unable to find Factorio version 0.1.5/
);
});
});
@@ -314,7 +326,7 @@ describe("host/server", function() {
describe(".handle()", function() {
it("should log validation errors from ipc handlers", async function() {
let logged = [];
let ipcServer = new hostServer.FactorioServer(
let ipcServer = await hostServer.FactorioServer.fromOptions(
path.join("test", "file", "factorio"), writePath,
{ logger: { error: msg => { logged.push(msg); } } }
);
@@ -571,7 +583,7 @@ describe("host/server", function() {
});
});
describe(".checkForUpdates()", function() {
describe("checkForUpdates()", function() {
let _fetch;
let fetchCalledWith;
let _platform = process.platform;
@@ -589,7 +601,6 @@ describe("host/server", function() {
});
afterEach(function() {
global.fetch = _fetch;
server._factorioDir = path.join("test", "file", "factorio");
Object.defineProperty(process, "platform", {
value: _platform,
});
@@ -602,18 +613,17 @@ describe("host/server", function() {
]) {
/* eslint-disable no-loop-func */
describe(suite, function() {
const factorioDir = path.join("test", "file", "factorio");
// A target that matches the 0.1.5 download but not the installed 0.1.1
const newerTarget = target === "0.1.1" ? "0.1.5" : target;
it("should do nothing when there are no versions", async function() {
server._factorioDir = path.join("test", "file", "factorio");
server._targetVersion = target;
await server.checkForUpdates([]);
await hostServer.checkForUpdates(factorioDir, target, []);
assert.equal(fetchCalledWith, null);
});
if (target !== "latest") {
it("should do nothing when no version matches", async function() {
server._factorioDir = path.join("test", "file", "factorio");
server._targetVersion = target;
await server.checkForUpdates([{
await hostServer.checkForUpdates(factorioDir, target, [{
stable: true,
version: "0.2.1",
headlessUrl: "test1",
@@ -627,9 +637,7 @@ describe("host/server", function() {
});
}
it("should do nothing when there is no newer version", async function() {
server._factorioDir = path.join("test", "file", "factorio");
server._targetVersion = target;
await server.checkForUpdates([{
await hostServer.checkForUpdates(factorioDir, target, [{
stable: true,
version: "0.1.1",
headlessUrl: "test1",
@@ -642,9 +650,7 @@ describe("host/server", function() {
assert.equal(fetchCalledWith, null);
});
it("should do nothing for direct installs", async function() {
server._factorioDir = path.join("test", "file", "factorio", "0.1.1");
server._targetVersion = target === "0.1.1" ? "0.1.5" : target;
await server.checkForUpdates([{
await hostServer.checkForUpdates(path.join(factorioDir, "0.1.1"), newerTarget, [{
stable: true,
version: "0.1.5",
headlessUrl: "test1",
@@ -662,12 +668,10 @@ describe("host/server", function() {
});
it("should do nothing when on windows", async function() {
let logLine = null;
server._logger = { info: line => { logLine = line; } };
const logger = { info: line => { logLine = line; } };
Object.defineProperty(process, "platform", { value: "win32" });
server._factorioDir = path.join("test", "file", "factorio");
server._targetVersion = target === "0.1.1" ? "0.1.5" : target;
await server.checkForUpdates([{
await hostServer.checkForUpdates(factorioDir, newerTarget, [{
stable: true,
version: "0.1.5",
headlessUrl: "test1",
@@ -679,7 +683,7 @@ describe("host/server", function() {
stable: false,
version: "0.1.0",
headlessUrl: "test3",
}]);
}], logger);
assert.equal(fetchCalledWith, null);
assert.ok(logLine !== null);
@@ -687,12 +691,10 @@ describe("host/server", function() {
});
it("should do attempt to download on linux", async function() {
let logLine = null;
server._logger = { info: line => { logLine = line; } };
const logger = { info: line => { logLine = line; } };
Object.defineProperty(process, "platform", { value: "linux" });
server._factorioDir = path.join("test", "file", "factorio");
server._targetVersion = target === "0.1.1" ? "0.1.5" : target;
await assert.rejects(server.checkForUpdates([{
await assert.rejects(hostServer.checkForUpdates(factorioDir, newerTarget, [{
stable: true,
version: "0.1.5",
headlessUrl: "test1",
@@ -704,7 +706,7 @@ describe("host/server", function() {
stable: false,
version: "0.1.0",
headlessUrl: "test3",
}]), new Error("Failed to fetch test1: -1 Fetch called"));
}], logger), new Error("Failed to fetch test1: -1 Fetch called"));
assert.equal(fetchCalledWith, "test1");
assert.ok(logLine !== null);
@@ -716,7 +718,7 @@ describe("host/server", function() {
describe("concurrent downloads", function() {
const versions = [{ stable: true, version: "0.1.5", headlessUrl: "test1" }];
// Holds the mocked download open until release() and resolves waiting once a server waits for it
// Holds the mocked download open until release() and resolves waiting once a check waits for it
function holdDownload(factorioDir) {
const held = { fetches: 0 };
const release = new Promise(resolve => { held.release = resolve; });
@@ -731,7 +733,7 @@ describe("host/server", function() {
let waited;
held.waiting = new Promise(resolve => { waited = resolve; });
const logger = { info: line => line.endsWith("waiting for download...") && waited() };
held.servers = [0, 1].map(() => new hostServer.FactorioServer(factorioDir, writePath, { logger }));
held.check = () => hostServer.checkForUpdates(factorioDir, "latest", versions, logger);
Object.defineProperty(process, "platform", { value: "linux" });
return held;
}
@@ -739,7 +741,7 @@ describe("host/server", function() {
it("should download once when servers check at the same time", async function() {
const held = holdDownload(path.join("test", "file", "factorio"));
let settled = 0;
const checks = held.servers.map(s => s.checkForUpdates(versions).finally(() => { settled += 1; }));
const checks = [0, 1].map(() => held.check().finally(() => { settled += 1; }));
await held.waiting;
assert.equal(held.fetches, 1);
@@ -754,14 +756,14 @@ describe("host/server", function() {
await fs.rm(factorioDir, { force: true, recursive: true });
await fs.mkdir(factorioDir, { recursive: true });
const held = holdDownload(factorioDir);
const first = held.servers[0].checkForUpdates(versions);
const first = held.check();
await held.fetching;
// The extraction has written the changelog but has not finished
const dataDir = path.join(factorioDir, "0.1.5", "data");
await fs.mkdir(dataDir, { recursive: true });
await fs.writeFile(path.join(dataDir, "changelog.txt"), "Version: 0.1.5\n");
const second = held.servers[1].checkForUpdates(versions);
const second = held.check();
await held.waiting;
held.release();
@@ -776,12 +778,11 @@ describe("host/server", function() {
this.skip();
}
server._factorioDir = path.join("temp", "test", "factorioDownload");
server._targetVersion = "latest";
const factorioDir = path.join("temp", "test", "factorioDownload");
global.fetch = _fetch;
await fs.rm(server._factorioDir, { force: true, recursive: true, maxRetries: 10 });
await fs.mkdir(server._factorioDir, { recursive: true });
await server.checkForUpdates([{
await fs.rm(factorioDir, { force: true, recursive: true, maxRetries: 10 });
await fs.mkdir(factorioDir, { recursive: true });
await hostServer.checkForUpdates(factorioDir, "latest", [{
stable: true,
version: "2.0.73",
headlessUrl: "https://www.factorio.com/get-download/2.0.73/headless/linux64",
+4 -1
View File
@@ -15,7 +15,10 @@ class FakeProcess extends events.EventEmitter {
}
function createStartedServer() {
const server = new FactorioServer(path.join("test", "file", "factorio"), path.join("temp", "test", "server"), {});
const server = new FactorioServer(
path.join("test", "file", "factorio"), path.join("temp", "test", "server"),
path.join("test", "file", "factorio", "0.1.2", "data"), "0.1.2", { rconPassword: "" },
);
server._state = "running";
server._rconReady = false;
server._server = new FakeProcess();
+1 -2
View File
@@ -12,8 +12,7 @@ describe("Integration of lib/factorio/export", function() {
requiresFactorio(this);
it("returns a nested Map with base game locale information", async function() {
let writePath = path.join("temp", "test", "server");
let testServer = new FactorioServer(factorioDir, writePath, {});
await testServer.init();
let testServer = await FactorioServer.fromOptions(factorioDir, writePath, {});
let locale = await _exportLocale(testServer, new Map(), new Map(), ["base"], "en");
+2 -1
View File
@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
import * as lib from "@clusterio/lib";
import { Host, Instance, InstanceConnection } from "@clusterio/host";
import { ControlConnection, Controller, HostConnection, InstanceRecord } from "@clusterio/controller";
import { MockServer } from "../mock.js";
// Although there are no imports, the file has side-effects such as "before" which can effect tests
import "./index.js";
@@ -39,7 +40,7 @@ function connectInstance(controller, host, instanceId) {
instanceConfig.set("instance.assigned_host", host.config.get("host.id"));
host.assignedInstances.set(instanceId, { path: "invalid", config: instanceConfig });
controller.instances.records.set(new InstanceRecord(instanceConfig, "stopped"));
const instance = new Instance(host, instanceSide, "invalid", "invalid", instanceConfig);
const instance = new Instance(host, instanceSide, "invalid", instanceConfig, new MockServer());
const instanceConnection = new InstanceConnection(hostSide, host, instance);
host.instanceConnections.set(instanceId, instanceConnection);
return instance;
+5 -6
View File
@@ -40,12 +40,14 @@ describe("Integration of host/src/server", function() {
describe("class FactorioServer", function() {
let writePath = path.join("temp", "test", "integration");
let server = new FactorioServer(factorioDir, writePath, {});
// Let Factorio bind an OS-assigned UDP port instead of guessing a free one.
server.gamePort = 0;
let server;
let logFile;
before(async function() {
server = await FactorioServer.fromOptions(factorioDir, writePath, {});
// Let Factorio bind an OS-assigned UDP port instead of guessing a free one.
server.gamePort = 0;
// Delete result from previous run of these tests
await fs.rm(writePath, { force: true, recursive: true, maxRetries: 10 });
@@ -63,9 +65,6 @@ describe("Integration of host/src/server", function() {
}
logFile.write(`${JSON.stringify(output)}\n`);
});
// Initialize sever.
await server.init();
});
after(function() {