Merge pull request #1129 from bbassie/refactor/async-factory

Replace bootstrap methods with async factories
This commit is contained in:
Cooldude2606 authored and GitHub committed 2026-10-27 21:31:49 +00:00
commit e36a76acc5
18 files changed
+540 -281

No files matched your search

+7 -8
View File
@@ -147,15 +147,15 @@ async function handleBootstrapCommand(
path.join(databaseDirectory, "roles.json"),
);
const roles = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const roles = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "roles.json"),
lib.Role.fromJSON.bind(lib.Role),
).bootstrap());
));
const users = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const users = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "users.json"),
UserRecord.fromJSON.bind(UserRecord),
).bootstrap());
));
const userManager = new UserManager(users, roles, controllerConfig);
@@ -474,13 +474,12 @@ async function startup() {
return;
}
controller = new Controller(
clusterLogger,
pluginInfos,
controller = await Controller.fromConfig(
controllerConfig,
pluginInfos,
clusterLogger,
Boolean(args.canRestart),
Boolean(args.recovery),
...await Controller.bootstrap(controllerConfig)
);
// Refuse to start if there are no users loaded
+31 -19
View File
@@ -148,7 +148,14 @@ export default class Controller {
}
});
static async bootstrap(config: lib.ControllerConfig) {
/** Create a controller with its datastores and mod store loaded from disk */
static async fromConfig(
config: lib.ControllerConfig,
pluginInfos: lib.PluginNodeEnvInfo[],
clusterLogger: winston.Logger,
canRestart = false,
recoveryMode = false,
) {
let databaseDirectory = config.get("controller.database_directory");
await fs.mkdir(databaseDirectory, { recursive: true });
@@ -158,23 +165,23 @@ export default class Controller {
path.join(databaseDirectory, "roles.json"),
);
const systems = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const systems = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "systems.json"),
lib.SystemInfo.fromJSON.bind(lib.SystemInfo),
this.migrateSystems,
).bootstrap());
));
const hosts = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const hosts = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "hosts.json"),
HostRecord.fromJSON.bind(HostRecord),
this.migrateHosts, this.finaliseHosts,
).bootstrap());
));
const instances = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const instances = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "instances.json"),
InstanceRecord.fromJSON.bind(InstanceRecord),
this.migrateInstances, this.finaliseInstances,
).bootstrap());
));
// Save plugin versions written while loading
for (const instance of instances.values()) {
if (instance.config.dirty) {
@@ -182,33 +189,33 @@ export default class Controller {
}
}
const saves = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const saves = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "saves.json"),
lib.SaveDetails.fromJSON.bind(lib.SaveDetails)
).bootstrap());
));
const modPacks = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const modPacks = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "mod-packs.json"),
lib.ModPack.fromJSON.bind(lib.ModPack),
this.migrateModPacks,
).bootstrap());
));
const roles = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const roles = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "roles.json"),
lib.Role.fromJSON.bind(lib.Role),
this.migrateRoles,
).bootstrap());
));
const users = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const users = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "users.json"),
UserRecord.fromJSON.bind(UserRecord),
undefined, this.finaliseUsers,
).bootstrap());
));
const notes = new lib.SubscribableDatastore(...await new lib.JsonIdDatastoreProvider(
const notes = await lib.SubscribableDatastore.fromProvider(new lib.JsonIdDatastoreProvider(
path.join(databaseDirectory, "notes.json"),
lib.Note.fromJSON.bind(lib.Note),
).bootstrap());
));
let modsDirectory = config.get("controller.mods_directory");
await fs.mkdir(modsDirectory, { recursive: true });
@@ -223,7 +230,12 @@ export default class Controller {
lib.Role.ensureDefaultAdminRole(roles);
lib.Role.ensureDefaultPlayerRole(roles);
return [
return new this(
clusterLogger,
pluginInfos,
config,
canRestart,
recoveryMode,
systems,
hosts,
instances,
@@ -233,7 +245,7 @@ export default class Controller {
roles,
users,
notes,
] as const;
);
}
constructor(
+2 -3
View File
@@ -233,13 +233,12 @@ async function startHost() {
}
let hostConnector = new HostConnector(hostConfig, pluginInfos);
host = new Host(
hostConnector,
host = await Host.fromConfig(
hostConfig,
pluginInfos,
hostConnector,
Boolean(args.canRestart),
Boolean(args.recovery),
...await Host.bootstrap(hostConfig)
);
// Handle interrupts
+31 -13
View File
@@ -353,6 +353,8 @@ export default class Host extends lib.Link {
_startup = true;
_disconnecting = false;
_shuttingDown = false;
/** Instances waiting on {@link Instance.fromConfig} */
_startingInstances = new Set<number>();
startedAtMs = Date.now();
@@ -360,12 +362,18 @@ export default class Host extends lib.Link {
"_warning": "Changes to this file will be overwritten by the controller's copy.",
};
static async bootstrap(hostConfig: lib.HostConfig) {
/** Create a host with its mod store loaded from disk */
static async fromConfig(
hostConfig: lib.HostConfig,
pluginInfos: lib.PluginNodeEnvInfo[],
connector: HostConnector,
canRestart = false,
recoveryMode = false,
) {
const modsDirectory = hostConfig.get("host.mods_directory");
await fs.mkdir(modsDirectory, { recursive: true });
return [
await lib.ModStore.fromDirectory(modsDirectory),
] as const;
const modStore = await lib.ModStore.fromDirectory(modsDirectory);
return new this(connector, hostConfig, pluginInfos, canRestart, recoveryMode, modStore);
}
constructor(
@@ -788,7 +796,7 @@ export default class Host extends lib.Link {
this.send(
new lib.InstanceStatusChangedEvent(
instanceId,
instanceConnection ? instanceConnection.instance.status : "stopped",
instanceConnection ? instanceConnection.instance.status : this._unconnectedStatus(instanceId),
instanceConnection ? instanceConnection.instance.server.gamePort : this.gamePort(instanceId),
instanceConnection
? instanceConnection.instance.server.version
@@ -904,6 +912,11 @@ export default class Host extends lib.Link {
}
}
/** Status of an instance without a connection */
_unconnectedStatus(instanceId: number) {
return this._startingInstances.has(instanceId) ? "starting" as const : "stopped" as const;
}
/**
* Initialize and connect an unloaded instance
*
@@ -912,22 +925,27 @@ export default class Host extends lib.Link {
*/
async _connectInstance(instanceId: number) {
let unloadedInstance = this.getRequestInstance(instanceId);
if (this.instanceConnections.has(instanceId)) {
if (this.instanceConnections.has(instanceId) || this._startingInstances.has(instanceId)) {
throw new lib.RequestError(`Instance with ID ${instanceId} is running`);
}
let hostAddress = new lib.Address(lib.Address.host, this.config.get("host.id"));
let instanceAddress = new lib.Address(lib.Address.instance, instanceId);
let [connectionClient, connectionServer] = lib.VirtualConnector.makePair(instanceAddress, hostAddress);
let instance = new Instance(
this, connectionClient,
unloadedInstance.path, this.config.get("host.factorio_directory"),
unloadedInstance.config
);
let instance: Instance;
this._startingInstances.add(instanceId);
try {
instance = await Instance.fromConfig(
unloadedInstance.config, this, connectionClient,
unloadedInstance.path, this.config.get("host.factorio_directory"),
);
} finally {
this._startingInstances.delete(instanceId);
}
let instanceConnection = new InstanceConnection(connectionServer, this, instance);
this.instanceConnections.set(instanceId, instanceConnection);
await instance.init(this.pluginInfos);
await instance.loadPlugins(this.pluginInfos);
return instanceConnection;
}
@@ -1295,7 +1313,7 @@ export default class Host extends lib.Link {
let instanceConnection = this.instanceConnections.get(instanceId);
list.push(new lib.HostInstanceUpdate(
instance.config.toRemote("controller"),
instanceConnection ? instanceConnection.instance.status : "stopped",
instanceConnection ? instanceConnection.instance.status : this._unconnectedStatus(instanceId),
instanceConnection ? instanceConnection.instance.server.gamePort : this.gamePort(instanceId),
instanceConnection ? instanceConnection.instance.server.version : undefined,
));
+80 -51
View File
@@ -10,7 +10,7 @@ const execAsync = util.promisify(exec);
// internal libraries
import * as lib from "@clusterio/lib";
import { FactorioServer } from "./server.js";
import { FactorioServer, checkForUpdates } from "./server.js";
import { loadModules, patch } from "./patch.js";
import { exportData } from "./export.js";
import type Host from "./Host.js";
@@ -32,6 +32,13 @@ const scriptCommands = [
"/silent-command", "/sc",
];
function instanceLogger(config: lib.InstanceConfig) {
return lib.logger.child({
instance_id: config.get("instance.id"),
instance_name: config.get("instance.name"),
});
}
// Statuses the instance passes through on its way to running or stopped.
const transitoryStatuses: ReadonlySet<Instance["_status"]> = new Set([
"starting", "stopping", "creating_save", "exporting_data",
@@ -191,8 +198,8 @@ export default class Instance extends lib.Link {
host: Host,
connector: lib.VirtualConnector,
dir: string,
factorioDir: string,
instanceConfig: lib.InstanceConfig
instanceConfig: lib.InstanceConfig,
server: FactorioServer,
) {
super(connector);
this._host = host;
@@ -202,10 +209,7 @@ export default class Instance extends lib.Link {
this.id = this.config.get("instance.id");
this.logger = lib.logger.child({
instance_id: this.id,
instance_name: this.name,
});
this.logger = instanceLogger(instanceConfig);
this.hooks = new InstanceHooks(this.logger);
@@ -225,28 +229,7 @@ export default class Instance extends lib.Link {
};
this.config.on("fieldChanged", this._configFieldChanged);
let serverOptions = {
logger: this.logger,
// TODO: factorio.version is not validated
version: this.config.get("factorio.version") as lib.TargetVersion,
executablePath: this.config.get("factorio.executable_path") ?? undefined,
gamePort: this.config.get("factorio.game_port") ?? host.assignGamePort(this.id),
rconPort: this.config.get("factorio.rcon_port") ?? undefined,
rconPassword: this.config.get("factorio.rcon_password") ?? undefined,
enableLuaUdp: this.config.get("factorio.enable_lua_udp"),
luaUdpPort: this.config.get("factorio.lua_udp_port") ?? undefined,
enableWhitelist: this.config.get("factorio.enable_whitelist"),
enableAuthserverBans: this.config.get("factorio.enable_authserver_bans"),
verboseLogging: this.config.get("factorio.verbose_logging"),
consoleLogging: this.config.get("factorio.console_logging"),
stripPaths: this.config.get("factorio.strip_paths"),
maxConcurrentCommands: this.config.get("factorio.max_concurrent_commands"),
shutdownTimeoutMs: this.config.get("factorio.shutdown_timeout") * 1000,
};
this.server = new FactorioServer(
factorioDir, this._dir, serverOptions
);
this.server = server;
this.server.on("output", (parsed, line) => {
this.logger.log("server", { message: line, instance_id: this.id, parsed });
@@ -670,20 +653,22 @@ end`.replace(/\r?\n/g, " ");
this._saveStats().catch(err => this.logger.error(`Error saving stats:\n${err.stack}`));
}
async _loadStats() {
static async _readStats(statsPath: string) {
let instanceStats;
try {
instanceStats = JSON.parse(await fs.readFile(this.path("instance-stats.json"), "utf8"));
instanceStats = JSON.parse(await fs.readFile(statsPath, "utf8"));
} catch (err: any) {
if (err.code === "ENOENT") {
return;
return { playerStats: new Map<string, lib.PlayerStats>(), playerAutosaveSlot: 1 };
}
throw err;
}
this.playerStats = new Map(instanceStats["players"].map(
([id, stats]: [number, Static<typeof lib.PlayerStats.jsonSchema>]) => [id, new lib.PlayerStats(stats)])
);
this._playerAutosaveSlot = instanceStats["player_autosave_slot"] || 1;
return {
playerStats: new Map<string, lib.PlayerStats>(instanceStats["players"].map(
([id, stats]: [string, Static<typeof lib.PlayerStats.jsonSchema>]) => [id, new lib.PlayerStats(stats)]
)),
playerAutosaveSlot: (instanceStats["player_autosave_slot"] as number) || 1,
};
}
async _saveStats() {
@@ -694,21 +679,35 @@ end`.replace(/\r?\n/g, " ");
await lib.safeOutputFile(this.path("instance-stats.json"), content);
}
async init(pluginInfos: lib.PluginNodeEnvInfo[]) {
// After changing the status this function is responsible for calling notifyExit if it throws.
this.notifyStatus("starting");
/**
* Create an instance with a Factorio server, downloading Factorio if needed
*
* The host reports the starting status for the instance while this runs.
*/
static async fromConfig(
config: lib.InstanceConfig,
host: Host,
connector: lib.VirtualConnector,
dir: string,
factorioDir: string,
) {
const id = config.get("instance.id");
// TODO: factorio.version is not validated
const targetVersion = config.get("factorio.version") as lib.TargetVersion;
const gamePort = config.get("factorio.game_port") ?? await host.assignFreeGamePort(id);
host.send(new lib.InstanceStatusChangedEvent(id, "starting", gamePort, targetVersion));
let server: FactorioServer;
let stats: Awaited<ReturnType<typeof Instance._readStats>>;
try {
if (this.config.get("factorio.game_port") === null) {
this.server.gamePort = await this._host.assignFreeGamePort(this.id);
}
const factorioVersions = await this.sendTo("controller", new lib.FactorioVersionsRequest());
await this._loadStats();
const factorioVersions = await host.sendTo("controller", new lib.FactorioVersionsRequest());
stats = await Instance._readStats(path.join(dir, "instance-stats.json"));
// Resolve a release channel target (e.g. "stable") to a concrete
// version using the controller's cached latest-releases data, so the
// existing download/lookup logic can fetch and run it.
const targetVersion = this.config.get("factorio.version") as string;
let version = targetVersion;
if (lib.isReleaseChannel(targetVersion)) {
const releases = await this.sendTo("controller", new lib.LatestReleasesRequest());
const releases = await host.sendTo("controller", new lib.LatestReleasesRequest());
const resolved = lib.resolveReleaseChannel(releases, targetVersion);
if (!resolved) {
throw new Error(
@@ -716,16 +715,46 @@ end`.replace(/\r?\n/g, " ");
"latest-releases unavailable and no cached copy on the controller."
);
}
this.server.setTargetVersion(resolved);
version = resolved;
}
await this.server.checkForUpdates(factorioVersions);
await this.server.init();
const logger = instanceLogger(config);
await checkForUpdates(factorioDir, version, factorioVersions, logger);
server = await FactorioServer.fromOptions(factorioDir, dir, {
logger,
version,
executablePath: config.get("factorio.executable_path") ?? undefined,
gamePort,
rconPort: config.get("factorio.rcon_port") ?? undefined,
rconPassword: config.get("factorio.rcon_password") ?? undefined,
enableLuaUdp: config.get("factorio.enable_lua_udp"),
luaUdpPort: config.get("factorio.lua_udp_port") ?? undefined,
enableWhitelist: config.get("factorio.enable_whitelist"),
enableAuthserverBans: config.get("factorio.enable_authserver_bans"),
verboseLogging: config.get("factorio.verbose_logging"),
consoleLogging: config.get("factorio.console_logging"),
stripPaths: config.get("factorio.strip_paths"),
maxConcurrentCommands: config.get("factorio.max_concurrent_commands"),
shutdownTimeoutMs: config.get("factorio.shutdown_timeout") * 1000,
});
} catch (err) {
this.notifyExit();
await this.sendSaveListUpdate();
host.send(new lib.InstanceStatusChangedEvent(id, "stopped", gamePort, targetVersion));
await host.sendSaveListUpdate(id, path.join(dir, "saves"));
throw err;
}
const instance = new this(host, connector, dir, config, server);
instance._status = "starting";
instance.playerStats = stats.playerStats;
instance._playerAutosaveSlot = stats.playerAutosaveSlot;
return instance;
}
/**
* Load the instance plugins and report the instance as initialised
*
* Must be called once the instance is connected to the host.
*/
async loadPlugins(pluginInfos: lib.PluginNodeEnvInfo[]) {
// load plugins
const plugins: Record<string, string> = {};
for (let pluginInfo of pluginInfos) {
+98 -94
View File
@@ -185,6 +185,73 @@ async function downloadAndExtractTar(url: string, targetDir: string) {
// Factorio downloads in progress by target directory, shared by every server in the process
const downloadsInProgress = new Map<string, Promise<void>>();
/**
* Download the newest Factorio version matching the target if not installed
*
* Call before {@link FactorioServer.fromOptions} for it to find the new version.
*
* @param factorioDir - Path to Factorio installation dirs.
* @param targetVersion - Version to look for, or "latest".
* @param availableVersions - Versions available for download.
* @param logger - Logger to report the download on.
*/
export async function checkForUpdates(
factorioDir: string,
targetVersion: lib.TargetVersion,
availableVersions: lib.ExternalFactorioVersion[],
logger: lib.Logger = lib.logger,
) {
const latestVersion = availableVersions
.filter(v => (
targetVersion === "latest" || v.version === targetVersion || v.version.startsWith(targetVersion)
))
.sort((v1, v2) => versionOrder(v1.version, v2.version))
[0];
if (!latestVersion) {
return;
}
// A version that is still being extracted can already look installed
const dst = path.join(factorioDir, latestVersion.version);
const installedVersions = await listFactorioVersions(factorioDir);
if (!installedVersions.versions.has(latestVersion.version) || downloadsInProgress.has(dst)) {
const v = latestVersion.version;
// Can't download if not linux or this is a direct install
if (installedVersions.direct) {
logger.info(
`A newer version of factorio is available (${v}) but cannot be downloaded automatically ` +
`because ${factorioDir} is a direct (single-version) Factorio install. Use a versioned ` +
`layout, where ${factorioDir} contains a subdirectory per version, to enable automatic ` +
"downloads."
);
return;
}
if (process.platform !== "linux") {
logger.info(
`A newer version of factorio is available (${v}) but must be manually downloaded ` +
"(automatic downloads are only supported on Linux)."
);
return;
}
// Download the newer version, or wait for another server already downloading it
let download = downloadsInProgress.get(dst);
if (download) {
logger.info(`A newer version of factorio is available (${v}), waiting for download...`);
} else {
logger.info(`A newer version of factorio is available (${v}), starting download...`);
download = downloadAndExtractTar(latestVersion.headlessUrl, dst).finally(() => {
downloadsInProgress.delete(dst);
});
downloadsInProgress.set(dst, download);
}
await download;
logger.info(`Downloaded factorio version ${v}`);
}
}
/**
* Find factorio data directory of the given version
*
@@ -670,9 +737,8 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
_factorioDir: string;
_writeDir: string;
// Resolved in init
_version: lib.FullVersion | null = null;
_dataDir: string | null = null;
_version: lib.FullVersion;
_dataDir: string;
// Due to inconsistencies in the factorio api, we must manually watch the whitelist
// https://forums.factorio.com/viewtopic.php?t=123673
@@ -680,8 +746,7 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
_whitelist = new Set<string>();
_logger: lib.Logger;
_targetVersion: lib.TargetVersion;
_state: "new" | "init" | "create" | "running" | "stopping" = "new";
_state: "init" | "create" | "running" | "stopping" = "init";
_server: child_process.ChildProcessWithoutNullStreams | null = null;
_rconClient: Rcon | null= null;
_rconReady = false;
@@ -697,27 +762,36 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
/**
* Create a Factorio server interface
* Create a Factorio server interface for the version found by {@link fromOptions}
*
* @param factorioDir - Directory of the Factorio install(s).
* @param writeDir - Directory to write runtime data to.
* @param options - Optional parameters.
* @param dataDir - Data directory of the Factorio version to run.
* @param version - Factorio version to run.
* @param options - Optional parameters, `version` is ignored.
*/
constructor(factorioDir: string, writeDir: string, options: FactorioServerOptions) {
constructor(
factorioDir: string,
writeDir: string,
dataDir: string,
version: lib.FullVersion,
options: FactorioServerOptions & { rconPassword: string },
) {
super();
this._factorioDir = factorioDir;
this._writeDir = writeDir;
this._dataDir = dataDir;
this._version = version;
this._logger = options.logger || lib.logger;
this._targetVersion = options.version || "latest";
this.executablePath = options.executablePath;
/** UDP port used for hosting the Factorio game server on */
this.gamePort = options.gamePort || randomDynamicPort();
/** TCP port used for RCON on the Factorio game server */
this.rconPort = options.rconPort || randomDynamicPort();
/** Password used for RCON on the Factorio game server */
this.rconPassword = options.rconPassword as string; // init will generate one if not there
this.rconPassword = options.rconPassword;
/** Enable UDP messaging with the Factorio game server */
this.enableLuaUdp = options.enableLuaUdp || false;
/** UDP port the Factorio game server receives Lua UDP messages on */
@@ -886,7 +960,7 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
// Factorio before 2.1.10 crashes when a packet is received on a headless server
_checkLuaUdpVersion() {
if (this.enableLuaUdp && lib.integerFullVersion(this._version!) < lib.integerFullVersion("2.1.10")) {
if (this.enableLuaUdp && lib.integerFullVersion(this._version) < lib.integerFullVersion("2.1.10")) {
throw new Error("Lua UDP requires Factorio 2.1.10 or later");
}
}
@@ -1075,94 +1149,25 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
}
/**
* Override the target version of Factorio to run
* Create a Factorio server interface for an installed version
*
* Used to substitute a concrete version for a release channel target
* (e.g. "stable" or "experimental") before {@link checkForUpdates} and
* {@link init} run. Must be called before the server is initialized.
*/
setTargetVersion(version: lib.TargetVersion) {
this._check(["new"]);
this._targetVersion = version;
}
/**
* Initialize class instance
*
* Must be called before instances of this class can be used.
* @param factorioDir - Directory of the Factorio install(s).
* @param writeDir - Directory to write runtime data to.
* @param options - Optional parameters.
* @throws {Error} if the requested version of Factorio was not found.
*/
async init() {
this._check(["new"]);
[this._dataDir, this._version] = await findVersion(this._factorioDir, this._targetVersion);
this.rconPassword = this.rconPassword as string | undefined ?? await generatePassword(10);
this._state = "init";
}
/**
* Check of updated versions to download
*
* Should be called before init for the new version to be detected during init
*/
async checkForUpdates(availableVersions: lib.ExternalFactorioVersion[]) {
const targetVersion = this._targetVersion;
const latestVersion = availableVersions
.filter(v => (
targetVersion === "latest" || v.version === targetVersion || v.version.startsWith(targetVersion)
))
.sort((v1, v2) => versionOrder(v1.version, v2.version))
[0];
if (!latestVersion) {
return;
}
// A version that is still being extracted can already look installed
const dst = path.join(this._factorioDir, latestVersion.version);
const installedVersions = await listFactorioVersions(this._factorioDir);
if (!installedVersions.versions.has(latestVersion.version) || downloadsInProgress.has(dst)) {
const v = latestVersion.version;
// Can't download if not linux or this is a direct install
if (installedVersions.direct) {
this._logger.info(
`A newer version of factorio is available (${v}) but cannot be downloaded automatically ` +
`because ${this._factorioDir} is a direct (single-version) Factorio install. Use a versioned ` +
`layout, where ${this._factorioDir} contains a subdirectory per version, to enable automatic ` +
"downloads."
);
return;
}
if (process.platform !== "linux") {
this._logger.info(
`A newer version of factorio is available (${v}) but must be manually downloaded ` +
"(automatic downloads are only supported on Linux)."
);
return;
}
// Download the newer version, or wait for another server already downloading it
let download = downloadsInProgress.get(dst);
if (download) {
this._logger.info(`A newer version of factorio is available (${v}), waiting for download...`);
} else {
this._logger.info(`A newer version of factorio is available (${v}), starting download...`);
download = downloadAndExtractTar(latestVersion.headlessUrl, dst).finally(() => {
downloadsInProgress.delete(dst);
});
downloadsInProgress.set(dst, download);
}
await download;
this._logger.info(`Downloaded factorio version ${v}`);
}
static async fromOptions(factorioDir: string, writeDir: string, options: FactorioServerOptions) {
const [dataDir, version] = await findVersion(factorioDir, options.version || "latest");
const rconPassword = options.rconPassword ?? await generatePassword(10);
return new this(factorioDir, writeDir, dataDir, version, { ...options, rconPassword });
}
/**
* The version of Factorio in use. This will be the actual version if
* "latest" (the default) was specified as `factorioVersion` to the constructor.
* This will be undefined before the server is initialized, or if init failed.
* "latest" (the default) was passed to {@link fromOptions}.
*/
get version(): lib.FullVersion | undefined {
return this._version ?? undefined;
get version(): lib.FullVersion {
return this._version;
}
/**
@@ -1681,14 +1686,13 @@ export class FactorioServer extends events.EventEmitter<FactorioServerEvents> {
* Return path in data directory
*
* Creates a path using path.join with the given parts that's relative to
* the data directory of the Factorio server. Not valid before init has
* been called.
* the data directory of the Factorio server.
*
* @param parts - Extra parts to add to the data path.
* @returns Data directory path.
*/
dataPath(...parts: string[]) {
return path.join(this._dataDir!, ...parts);
return path.join(this._dataDir, ...parts);
}
/**
+2 -2
View File
@@ -435,7 +435,7 @@ export class DebugWsMessageEvent {
export class FactorioVersionsRequest {
declare ["constructor"]: typeof FactorioVersionsRequest;
static type = "request" as const;
static src = ["control", "instance"] as const;
static src = ["control", "host", "instance"] as const;
static dst = "controller" as const;
static permission = "core.external.get_factorio_versions" as const;
@@ -457,7 +457,7 @@ export class FactorioVersionsRequest {
export class LatestReleasesRequest {
declare ["constructor"]: typeof LatestReleasesRequest;
static type = "request" as const;
static src = ["control", "instance"] as const;
static src = ["control", "host", "instance"] as const;
static dst = "controller" as const;
static permission = "core.external.get_latest_releases" as const;
+10 -5
View File
@@ -17,11 +17,6 @@ export abstract class DatastoreProvider<
> {
abstract save(data: Map<K, V>): Promise<void>
abstract load(): Promise<Map<K, V>>
// Load data from the source and return it, this should be passed to the constructor of a datastore
async bootstrap() {
return [this, await this.load()] as const;
}
}
// Store all data in memory, used as a default and should be avoided
@@ -251,6 +246,11 @@ export class KeyValueDatastore<
K extends DatastoreKey,
V extends DatastoreValue,
> extends Datastore<K, V, [key: K, value: V, isDeleted?: boolean]> {
// Create a datastore populated with the data loaded from the provider
static async fromProvider<K extends DatastoreKey, V extends DatastoreValue>(provider: DatastoreProvider<K, V>) {
return new this(provider, await provider.load());
}
// Set the value in the datastore, be careful of race conditions if you await any functions before calling set
set(key: K, value: V) {
this.data.set(key, value);
@@ -316,6 +316,11 @@ export class SubscribableDatastore<
this.lastUpdatedAtMs = SubscribableDatastore.maxUpdatedAtMs(this.data.values());
}
// Create a datastore populated with the data loaded from the provider
static async fromProvider<V extends SubscribableValue>(provider: DatastoreProvider<V["id"], V>) {
return new this(provider, await provider.load());
}
async load() {
await super.load();
this.lastUpdatedAtMs = SubscribableDatastore.maxUpdatedAtMs(this.data.values());