mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-21 08:03:13 +09:00
Compare commits
9
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
bd41801c8d | ||
|
|
34deacb881 | ||
|
|
3aefcb062f | ||
|
|
c5ad1953ad | ||
|
|
f52821d1cd | ||
|
|
f49c633e77 | ||
|
|
23187859d6 | ||
|
|
8550df69eb | ||
|
|
10beffe167 |
No files matched your search
@@ -15,10 +15,10 @@ jobs:
|
||||
check:
|
||||
# Bot pull requests do not fill in the template.
|
||||
if: github.event.pull_request.user.type != 'Bot'
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- uses: useblacksmith/checkout@v1
|
||||
- uses: actions/checkout@v7
|
||||
with:
|
||||
sparse-checkout: scripts
|
||||
- uses: actions/setup-node@v7
|
||||
|
||||
@@ -15,14 +15,14 @@ on:
|
||||
|
||||
jobs:
|
||||
changes:
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
outputs:
|
||||
build_and_test: ${{ steps.syntax.outputs.build_and_test || steps.paths.outputs.code }}
|
||||
js_lint: ${{ steps.lint.outputs.js_lint }}
|
||||
lua_lint: ${{ steps.lint.outputs.lua_lint }}
|
||||
steps:
|
||||
- uses: useblacksmith/checkout@v1
|
||||
- uses: actions/checkout@v7
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- uses: dorny/paths-filter@v4
|
||||
|
||||
@@ -18,9 +18,9 @@ jobs:
|
||||
lint:
|
||||
needs: changes
|
||||
if: ${{ !cancelled() && needs.changes.outputs.lua_lint != 'false' }}
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: useblacksmith/checkout@v1
|
||||
- uses: actions/checkout@v7
|
||||
- uses: actions/setup-node@v7
|
||||
with:
|
||||
node-version: lts/*
|
||||
|
||||
@@ -23,7 +23,7 @@ jobs:
|
||||
test:
|
||||
needs: changes
|
||||
if: ${{ !cancelled() && needs.changes.outputs.build_and_test != 'false' }}
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
strategy:
|
||||
fail-fast: false
|
||||
@@ -89,7 +89,7 @@ jobs:
|
||||
version-compat:
|
||||
needs: changes
|
||||
if: ${{ !cancelled() && needs.changes.outputs.build_and_test != 'false' }}
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 15
|
||||
env:
|
||||
# npm version spec for the published side of the compatibility test.
|
||||
@@ -121,7 +121,7 @@ jobs:
|
||||
lint:
|
||||
needs: changes
|
||||
if: ${{ !cancelled() && needs.changes.outputs.js_lint != 'false' }}
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- uses: actions/checkout@v7
|
||||
@@ -134,7 +134,7 @@ jobs:
|
||||
build:
|
||||
needs: changes
|
||||
if: ${{ !cancelled() && needs.changes.outputs.build_and_test != 'false' }}
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- uses: actions/checkout@v7
|
||||
|
||||
@@ -12,10 +12,10 @@ permissions:
|
||||
|
||||
jobs:
|
||||
npm:
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: useblacksmith/checkout@v1
|
||||
- uses: actions/checkout@v7
|
||||
- uses: pnpm/action-setup@v6
|
||||
- uses: actions/setup-node@v7
|
||||
with:
|
||||
@@ -30,10 +30,10 @@ jobs:
|
||||
files: pnpm-lock.yaml
|
||||
|
||||
factorio:
|
||||
runs-on: blacksmith-4vcpu-ubuntu-2604
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: useblacksmith/checkout@v1
|
||||
- uses: actions/checkout@v7
|
||||
- uses: pnpm/action-setup@v6
|
||||
- uses: actions/setup-node@v7
|
||||
with:
|
||||
|
||||
+38
-2
@@ -31,11 +31,47 @@ Many thanks to the following for contributing to this release:
|
||||
[@username](https://github.com/username)
|
||||
-->
|
||||
|
||||
## Unreleased
|
||||
## Version 2.1.1
|
||||
|
||||
### Features
|
||||
|
||||
- Hosts on ARM64 Linux download and run the ARM64 headless build of Factorio, available from Factorio 2.1.18. [#1228](<https://github.com/clusterio/clusterio/pull/1228>)
|
||||
- Added `requiredMods` to plugin declarations. Instances refuse to start when their mod pack lacks a mod a loaded plugin requires, and the controller downloads missing required mods and their dependencies from the mod portal on start. Subspace Storage requires the subspace_storage mod. [#535](<https://github.com/clusterio/clusterio/issues/535>)
|
||||
- Added `--output json` and `--output wire` to clusterioctl for machine readable results and errors. [#1230](<https://github.com/clusterio/clusterio/pull/1230>)
|
||||
|
||||
### Fixes
|
||||
|
||||
- Fixed cramped plugin rows and wrapping header branding on mobile screens.
|
||||
- Fixed a newly paired host reporting that it needs a restart. [#1204](<https://github.com/clusterio/clusterio/issues/1204>)
|
||||
- Fixed the installer's run-controller and run-host scripts exiting with 0 when the controller or host exited with 8 to stop the restart loop. [#1208](<https://github.com/clusterio/clusterio/issues/1208>)
|
||||
- Fixed clusterioctl user list, user show and role list printing [object Set] for roles, instances and permissions. [#1205](<https://github.com/clusterio/clusterio/issues/1205>)
|
||||
- Fixed typo in the delete instance confirmation. [#1209](<https://github.com/clusterio/clusterio/issues/1209>)
|
||||
- The Search Mod Portal dialog now opens on the default mod pack's Factorio version instead of always 2.0. [#1209](<https://github.com/clusterio/clusterio/issues/1209>)
|
||||
- Fixed the mod portal cache key logging "undefined" when hide_deprecated was not sent. [#1209](<https://github.com/clusterio/clusterio/issues/1209>)
|
||||
- Fixed player_sync losing quick bar slots of blueprint library records when a player joins an instance for the first time. [#1219](<https://github.com/clusterio/clusterio/issues/1219>)
|
||||
- Fixed cramped plugin rows and wrapping header branding on mobile screens. [#1223](<https://github.com/clusterio/clusterio/pull/1223>)
|
||||
- Fixed player_sync keeping an instance's old copy of a player after the controller refused its upload, which let an instance restarted after a crash overwrite newer player data. [#1218](<https://github.com/clusterio/clusterio/issues/1218>)
|
||||
|
||||
### Changes
|
||||
|
||||
- Restarting the controller or a host from the web interface now asks for confirmation, and for hosts lists the running instances that will be stopped. [#1207](<https://github.com/clusterio/clusterio/issues/1207>)
|
||||
- New clusters default controller.default_mod_pack_id to the newest Base Game mod pack, so instances can create saves and start without setting it first. [#1203](<https://github.com/clusterio/clusterio/issues/1203>)
|
||||
- Output from npm during `plugin install` now goes through the logger. [#1224](<https://github.com/clusterio/clusterio/pull/1224>)
|
||||
- The controller collects system info, including restart required, right after it starts and when a host connects instead of waiting for the first system metrics interval. [#1227](<https://github.com/clusterio/clusterio/pull/1227>)
|
||||
- clusterioctl prints all tables with the same formatter and prints command results to stdout instead of the log. [#1230](<https://github.com/clusterio/clusterio/pull/1230>)
|
||||
- clusterioctl prints "Command ran successfully" for commands that have no other output. [#1230](<https://github.com/clusterio/clusterio/pull/1230>)
|
||||
|
||||
### Meta
|
||||
|
||||
- Added a CI check that pull request descriptions have a valid changelog section. [#1226](<https://github.com/clusterio/clusterio/pull/1226>)
|
||||
|
||||
### Contributors
|
||||
|
||||
Many thanks to the following for contributing to this release:
|
||||
[@bbassie](<https://github.com/bbassie>), [@ILLISIS](<https://github.com/ILLISIS>), [@Danielv123](<https://github.com/Danielv123>)
|
||||
|
||||
### Statistics
|
||||
|
||||
Commits: 44 Pull Requests: 19 Files Changed: 81 Additions: +2,676 Deletions: -739
|
||||
|
||||
|
||||
## Version 2.1.0
|
||||
|
||||
@@ -8,6 +8,24 @@ Before `clusterioctl` can be used it needs to be configured for the cluster it w
|
||||
The easiest way to do this is to run `npx clusteriocontroller bootstrap create-ctl-config <username>` on the controller, which creates the necessary `config-ctl.json` for managing the cluster as the given user.
|
||||
|
||||
|
||||
## Output Format
|
||||
|
||||
ctl> --output json <command>
|
||||
|
||||
Print the result of the command as JSON on stdout instead of text meant for reading.
|
||||
Lists are printed as an array of objects, other results as an object, and commands that have no result print `{"success": true}`.
|
||||
If the command fails it prints `{"error": "<ClassName>", "message": "<message>"}` and exits with a non-zero exit code.
|
||||
Log messages are written to stderr in all formats.
|
||||
|
||||
`--output wire` prints the same results in the format they are sent between the controller, hosts and clusterioctl, which uses snake_case names like `is_admin`.
|
||||
The `json` format uses the property names shown in the tables of the human format.
|
||||
|
||||
`log follow` and `debug dump-ws` keep running and print one JSON object per line as entries arrive.
|
||||
`instance start-all` and `instance stop-all` print an array with an entry per instance, which has an `error` property if that instance failed to start or stop.
|
||||
|
||||
The default is `--output human`, which prints `Command ran successfully` for commands that have no result.
|
||||
|
||||
|
||||
## Hosts
|
||||
|
||||
### List hosts
|
||||
|
||||
@@ -995,6 +995,20 @@ For a command the `definition` is the arguments to pass to [yargs.command](http:
|
||||
The `handler` is an async function that's invoked when the command is executed and it's passed the parsed command line arguments and a reference to the `Ctl` class of clusterioctl.
|
||||
Note that messages sent from clusterioctl needs to have `"control"` as a part of `src` for it to be accepted by the controller, see [Defining Link Messages](#defining-link-messages) for how to define the messages that can be sent to the controller.
|
||||
|
||||
Commands print their results through `ctl.output` so that `--output json` works for them:
|
||||
|
||||
```js
|
||||
handler: async function(args, ctl) {
|
||||
const result = await ctl.sendTo("controller", new messages.FrobnicateRequest(args.type));
|
||||
ctl.output.result(result, () => console.log(`Frobnicated ${result.count} foos`));
|
||||
},
|
||||
```
|
||||
|
||||
`ctl.output.result(data, human)` prints `data` as JSON in json and wire mode and calls `human` otherwise.
|
||||
`ctl.output.table(rows, map)` prints an array of objects as a JSON array, or as a table in human mode with `map` applied to each row first.
|
||||
`ctl.output.human` is true when the output is meant for reading.
|
||||
Commands that print nothing get `Command ran successfully` or `{"success": true}` printed for them, and errors thrown from the handler are printed as `{"error": "<ClassName>", "message": "<message>"}` in json and wire mode.
|
||||
|
||||
To have the command tree become part of clusterioctl it needs to be added to the rootCommand tree in the `addCommands` hook of the ctl entrypoint:
|
||||
|
||||
```js
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/controller",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Implementation of Clusterio controller",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/create",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Installer for clusterio",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -23,6 +23,11 @@ Common options:
|
||||
* `--create-config` If the config file is missing, create a new one and carry on instead of exiting with an error.
|
||||
Alternative to the `config create` command.
|
||||
|
||||
* `--output <human|json|wire>` Format to print the results of cluster commands in.
|
||||
Defaults to `human`.
|
||||
See [Output format](/docs/managing-a-cluster.md#output-format) for what `json` and `wire` print.
|
||||
The `plugin` and `config` commands described below always print human readable text.
|
||||
|
||||
|
||||
### `plugin <command>`
|
||||
|
||||
|
||||
+57
-17
@@ -17,6 +17,7 @@ import { ConsoleTransport, levels, logger } from "@clusterio/lib";
|
||||
|
||||
import * as commands from "./src/commands.js";
|
||||
import { BaseCtlPlugin, CtlHooks } from "./src/BaseCtlPlugin.js";
|
||||
import { CommandOutput, errorToJson, outputFormats, print, type OutputFormat } from "./src/command_ops.js";
|
||||
|
||||
|
||||
/**
|
||||
@@ -55,6 +56,8 @@ export class Ctl extends lib.Link {
|
||||
config: lib.CtlConfig;
|
||||
/** Keep the control connection alive after the command completes. */
|
||||
keepOpen = false;
|
||||
/** Output of the command being run. */
|
||||
output = new CommandOutput();
|
||||
|
||||
constructor(
|
||||
connector: CtlConnector,
|
||||
@@ -82,12 +85,20 @@ export class Ctl extends lib.Link {
|
||||
}
|
||||
|
||||
async handleLogMessageEvent(event: lib.LogMessageEvent) {
|
||||
logger.log(event.info as any);
|
||||
// Only log following commands print log events as results, the rest log them to stderr
|
||||
if (this.output.streamingLog) {
|
||||
this.output.result(event.info, () => logger.log(event.info as any));
|
||||
} else {
|
||||
logger.log(event.info as any);
|
||||
}
|
||||
}
|
||||
|
||||
async handleDebugWsMessageEvent(event: lib.DebugWsMessageEvent) {
|
||||
// eslint-disable-next-line no-console
|
||||
console.log("WS", event.direction, event.content);
|
||||
this.output.result(
|
||||
{ direction: event.direction, content: event.content },
|
||||
// eslint-disable-next-line no-console
|
||||
() => console.log("WS", event.direction, event.content),
|
||||
);
|
||||
}
|
||||
|
||||
async shutdown() {
|
||||
@@ -126,6 +137,7 @@ interface CtlArguments {
|
||||
$0: string,
|
||||
_: (string | number)[],
|
||||
logLevel: keyof typeof levels,
|
||||
output: OutputFormat,
|
||||
config: string,
|
||||
pluginList: string,
|
||||
bypassLockFile: boolean,
|
||||
@@ -165,6 +177,13 @@ export async function initialize(
|
||||
choices: Object.keys(levels),
|
||||
type: "string",
|
||||
})
|
||||
.option("output", {
|
||||
nargs: 1,
|
||||
describe: "Format to print command results in",
|
||||
default: "human",
|
||||
choices: outputFormats,
|
||||
type: "string",
|
||||
})
|
||||
.option("config", {
|
||||
nargs: 1,
|
||||
describe: "config file to get credentails from",
|
||||
@@ -260,6 +279,20 @@ export function selectTargetCommand(args: CtlArguments, rootCommands: lib.Comman
|
||||
return targetCommand;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the command selected by args, printing results in the format given by args.output
|
||||
*/
|
||||
export async function runCommand(
|
||||
args: CtlArguments,
|
||||
rootCommands: lib.CommandTree,
|
||||
link: lib.Link & { output?: CommandOutput },
|
||||
) {
|
||||
link.output = new CommandOutput(args.output);
|
||||
const targetCommand = selectTargetCommand(args, rootCommands);
|
||||
await targetCommand.run(args, link);
|
||||
link.output.finish();
|
||||
}
|
||||
|
||||
async function startCtl() {
|
||||
const {
|
||||
args,
|
||||
@@ -271,10 +304,19 @@ async function startCtl() {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
await connectAndRun(args, rootCommands, ctlConfig);
|
||||
} catch (err) {
|
||||
if (args.output !== "human") {
|
||||
print(JSON.stringify(errorToJson(err)));
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
async function connectAndRun(args: CtlArguments, rootCommands: lib.CommandTree, ctlConfig: lib.CtlConfig) {
|
||||
if (!ctlConfig.get("ctl.controller_url") || !ctlConfig.get("ctl.controller_token")) {
|
||||
logger.error("Missing URL and/or token to connect with. See README.md for setting up access.");
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
throw new lib.StartupError("Missing URL and/or token to connect with. See README.md for setting up access.");
|
||||
}
|
||||
|
||||
let controlConnector = new CtlConnector(
|
||||
@@ -298,26 +340,25 @@ async function startCtl() {
|
||||
process.on("SIGTERM", lib.createShutdownGuard(logger, "termination", ctl.shutdown.bind(ctl)));
|
||||
|
||||
try {
|
||||
const targetCommand = selectTargetCommand(args, rootCommands);
|
||||
await targetCommand.run(args, ctl);
|
||||
await runCommand(args, rootCommands, ctl);
|
||||
|
||||
} catch (err) {
|
||||
ctl.keepOpen = false;
|
||||
let message: string;
|
||||
if (err instanceof lib.CommandError) {
|
||||
logger.error(`Error running command: ${err.message}`);
|
||||
process.exitCode = 1;
|
||||
message = `Error running command: ${err.message}`;
|
||||
|
||||
} else if (err instanceof lib.ClientError || err instanceof lib.UnavailableError) {
|
||||
logger.error(`Error sending request: ${err.message}`);
|
||||
process.exitCode = 1;
|
||||
message = `Error sending request: ${err.message}`;
|
||||
|
||||
} else if (err instanceof lib.ServerError) {
|
||||
logger.error(`Error sending request:\n${err.stack ?? err.message}`);
|
||||
process.exitCode = 1;
|
||||
message = `Error sending request:\n${err.stack ?? err.message}`;
|
||||
|
||||
} else {
|
||||
throw err;
|
||||
}
|
||||
ctl.output.error(err, () => logger.error(message));
|
||||
process.exitCode = 1;
|
||||
|
||||
} finally {
|
||||
if (!ctl.keepOpen) {
|
||||
@@ -328,6 +369,7 @@ async function startCtl() {
|
||||
|
||||
export function bootstrap() {
|
||||
startCtl().catch(err => {
|
||||
process.exitCode = 1;
|
||||
if (err.errors) {
|
||||
logger.fatal(JSON.stringify(err.errors, null, "\t"));
|
||||
}
|
||||
@@ -340,15 +382,13 @@ export function bootstrap() {
|
||||
${err.stack}`
|
||||
);
|
||||
} else {
|
||||
logger.error(`
|
||||
logger.fatal(`
|
||||
+---------------------------------+
|
||||
| Unable to to start clusterioctl |
|
||||
+---------------------------------+
|
||||
${err.stack}`
|
||||
);
|
||||
}
|
||||
|
||||
process.exitCode = 1;
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { bootstrap } from "./ctl.js";
|
||||
export * from "./ctl.js";
|
||||
export { CommandOutput, type OutputFormat } from "./src/command_ops.js";
|
||||
export { BaseCtlPlugin, CtlHooks, type CtlPluginContext } from "./src/BaseCtlPlugin.js";
|
||||
|
||||
if (import.meta.main) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/ctl",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio command line management tool",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -13,3 +13,120 @@ function formatCell(value: unknown) {
|
||||
}
|
||||
|
||||
export const asTable = asTableModule.configure({ delimiter: " | ", print: formatCell });
|
||||
|
||||
/** Copy of object with only the given fields, or all of them if fields includes "all" */
|
||||
export function pickFields(object: object, fields: string[]) {
|
||||
if (fields.includes("all")) {
|
||||
return object;
|
||||
}
|
||||
return Object.fromEntries(Object.entries(object).filter(([field]) => fields.includes(field)));
|
||||
}
|
||||
|
||||
/** Convert class instances, Sets and Maps into plain JSON values, ignoring wire format toJSON methods */
|
||||
export function toPlain(value: unknown): unknown {
|
||||
if (value instanceof Set || value instanceof Array) {
|
||||
return [...value].map(toPlain);
|
||||
}
|
||||
if (value instanceof Map) {
|
||||
return Object.fromEntries([...value].map(([key, entry]) => [key, toPlain(entry)]));
|
||||
}
|
||||
if (value instanceof Date) {
|
||||
return value.toISOString();
|
||||
}
|
||||
if (typeof value === "object" && value !== null) {
|
||||
return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, toPlain(entry)]));
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
/** Describe an error as `{ error: ClassName, message: string }` */
|
||||
export function errorToJson(err: unknown) {
|
||||
if (err instanceof Error) {
|
||||
return { error: err.constructor.name, message: err.message };
|
||||
}
|
||||
return { error: "Error", message: String(err) };
|
||||
}
|
||||
|
||||
/** JSON.stringify replacer for Sets and Maps that have no toJSON method */
|
||||
function wireReplacer(key: string, value: unknown) {
|
||||
if (value instanceof Set) {
|
||||
return [...value];
|
||||
}
|
||||
if (value instanceof Map) {
|
||||
return Object.fromEntries(value);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
export const outputFormats = ["human", "json", "wire"] as const;
|
||||
export type OutputFormat = typeof outputFormats[number];
|
||||
|
||||
/**
|
||||
* Prints the results of a ctl command in the format chosen with --output
|
||||
*
|
||||
* In json and wire mode each call to result prints one line of JSON to stdout. json uses the
|
||||
* property names of the objects, wire uses their toJSON methods to give the format sent over the link.
|
||||
*/
|
||||
export class CommandOutput {
|
||||
/** True once a result has been printed */
|
||||
written = false;
|
||||
/** Command prints log events as results while it runs and has no final result */
|
||||
streamingLog = false;
|
||||
|
||||
constructor(
|
||||
public format: OutputFormat = "human",
|
||||
) { }
|
||||
|
||||
get human() {
|
||||
return this.format === "human";
|
||||
}
|
||||
|
||||
/**
|
||||
* Print the result of a command
|
||||
*
|
||||
* @param data - Printed as JSON in json and wire mode.
|
||||
* @param human - Prints the result in human mode, defaults to printing data as is.
|
||||
*/
|
||||
result(data: unknown, human: () => void = () => print(data)) {
|
||||
this.written = true;
|
||||
if (this.format === "json") {
|
||||
print(JSON.stringify(toPlain(data)));
|
||||
} else if (this.format === "wire") {
|
||||
print(JSON.stringify(data, wireReplacer));
|
||||
} else {
|
||||
human();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Print a list of objects as a table, or as an array in json and wire mode
|
||||
*
|
||||
* @param rows - Printed as is in json and wire mode.
|
||||
* @param map - Converts each row into the table row printed in human mode.
|
||||
*/
|
||||
table<T extends object>(rows: T[], map: (row: T) => object = row => row) {
|
||||
this.result(rows, () => print(asTable(rows.map(map))));
|
||||
}
|
||||
|
||||
/**
|
||||
* Print an error as `{ "error": ClassName, "message": string }` in json and wire mode
|
||||
*
|
||||
* @param err - Error to print.
|
||||
* @param human - Reports the error in human mode.
|
||||
*/
|
||||
error(err: unknown, human: () => void) {
|
||||
this.written = true;
|
||||
if (this.human) {
|
||||
human();
|
||||
} else {
|
||||
print(JSON.stringify(errorToJson(err)));
|
||||
}
|
||||
}
|
||||
|
||||
/** Print a success result for commands that finished without printing one */
|
||||
finish() {
|
||||
if (!this.written && !this.streamingLog) {
|
||||
this.result({ success: true }, () => print("Command ran successfully"));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,15 +1,15 @@
|
||||
import fs from "node:fs/promises";
|
||||
import asTableModule from "as-table";
|
||||
import events from "events";
|
||||
import os from "os";
|
||||
import child_process from "child_process";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { logger } from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
import { serializedConfigToString, getEditor, configToKeyVal } from "./config_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
import { asTable, print } from "./command_ops.js";
|
||||
import {
|
||||
serializedConfigToString, getEditor, configToKeyVal, printConfig, printRestartRequired,
|
||||
} from "./config_ops.js";
|
||||
|
||||
export const controllerCommands = new lib.CommandTree({ name: "controller", description: "Controller management" });
|
||||
controllerCommands.add(new lib.Command({
|
||||
@@ -44,9 +44,8 @@ controllerCommands.add(new lib.Command({
|
||||
}
|
||||
if (args.restart) {
|
||||
await ctl.send(new lib.ControllerRestartRequest());
|
||||
} else {
|
||||
print("Controller updated; a restart is required to apply the changes.");
|
||||
}
|
||||
printRestartRequired(ctl, !args.restart, "Controller updated");
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -57,11 +56,7 @@ const controllerConfigCommands = new lib.CommandTree({
|
||||
controllerConfigCommands.add(new lib.Command({
|
||||
definition: ["list", "List controller configuration"],
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let config = await ctl.send(new lib.ControllerConfigGetRequest());
|
||||
|
||||
for (let [name, value] of Object.entries(config)) {
|
||||
print(`${name} ${JSON.stringify(value)}`);
|
||||
}
|
||||
printConfig(ctl, await ctl.send(new lib.ControllerConfigGetRequest()));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -146,19 +141,22 @@ controllerConfigCommands.add(new lib.Command({
|
||||
index,
|
||||
final[index],
|
||||
));
|
||||
} catch (err) {
|
||||
// eslint-disable-next-line
|
||||
print(`Attempt to set ${index} to ${final[index] || String(null)} failed; set back to previous value.`);
|
||||
print(err);
|
||||
} catch (err: any) {
|
||||
// If the string is empty, it's better to just print "" instead of nothing
|
||||
logger.error(
|
||||
`Attempt to set ${index} to ${final[index] || String(null)} failed; ` +
|
||||
`set back to previous value: ${err.message}`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
await fs.unlink(tmpFile);
|
||||
} catch (err) {
|
||||
print("err: temporary file", tmpFile, "could not be deleted.");
|
||||
print("This is not fatal, but they may build up over time if the issue persists.");
|
||||
logger.warn(
|
||||
`Temporary file ${tmpFile} could not be deleted. ` +
|
||||
"This is not fatal, but they may build up over time if the issue persists."
|
||||
);
|
||||
}
|
||||
},
|
||||
}));
|
||||
@@ -175,7 +173,7 @@ controllerPluginCommands.add(new lib.Command({
|
||||
let url = new URL(ctl.config.get("ctl.controller_url")!);
|
||||
url.pathname += "api/plugins";
|
||||
let response = await fetch(url);
|
||||
print(asTable(await response.json() as []));
|
||||
ctl.output.table(await response.json() as object[]);
|
||||
},
|
||||
}));
|
||||
controllerPluginCommands.add(new lib.Command({
|
||||
@@ -187,9 +185,8 @@ controllerPluginCommands.add(new lib.Command({
|
||||
await ctl.sendTo("controller", new lib.PluginUpdateRequest(args.plugin));
|
||||
if (args.restart) {
|
||||
await ctl.send(new lib.ControllerRestartRequest());
|
||||
} else {
|
||||
print("Plugin updated; a restart is required to apply the changes.");
|
||||
}
|
||||
printRestartRequired(ctl, !args.restart, "Plugin updated");
|
||||
},
|
||||
}));
|
||||
controllerPluginCommands.add(new lib.Command({
|
||||
@@ -202,13 +199,16 @@ controllerPluginCommands.add(new lib.Command({
|
||||
const response = await ctl.sendTo(
|
||||
"controller", new lib.PluginSearchRequest(args.query, args.page, args.pageSize)
|
||||
);
|
||||
print(asTable(response.results.map(plugin => ({
|
||||
const results = response.results.map(plugin => ({
|
||||
name: plugin.name,
|
||||
version: plugin.version,
|
||||
publisher: plugin.publisher ?? "",
|
||||
description: plugin.description ?? "",
|
||||
}))));
|
||||
print(`Showing ${response.results.length} of ${response.total} results`);
|
||||
}));
|
||||
ctl.output.result({ total: response.total, results }, () => {
|
||||
print(asTable(results));
|
||||
print(`Showing ${results.length} of ${response.total} results`);
|
||||
});
|
||||
},
|
||||
}));
|
||||
controllerPluginCommands.add(new lib.Command({
|
||||
@@ -220,9 +220,8 @@ controllerPluginCommands.add(new lib.Command({
|
||||
await ctl.sendTo("controller", new lib.PluginInstallRequest(args.plugin));
|
||||
if (args.restart) {
|
||||
await ctl.send(new lib.ControllerRestartRequest());
|
||||
} else {
|
||||
print("Plugin installed; a restart is required to apply the changes.");
|
||||
}
|
||||
printRestartRequired(ctl, !args.restart, "Plugin installed");
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import * as lib from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
export const debugCommands = new lib.CommandTree({ name: "debug", description: "Debugging utilities" });
|
||||
debugCommands.add(new lib.Command({
|
||||
@@ -7,6 +8,7 @@ debugCommands.add(new lib.Command({
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
await ctl.send(new lib.DebugDumpWsRequest());
|
||||
ctl.keepOpen = true;
|
||||
ctl.output.streamingLog = true;
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -20,12 +22,6 @@ debugCommands.add(new lib.Command({
|
||||
}],
|
||||
handler: async function(args: { exchangeString: string, pretty: boolean }, ctl: Ctl) {
|
||||
const result = lib.readMapExchangeString(args.exchangeString);
|
||||
if (args.pretty) {
|
||||
// eslint-disable-next-line no-console
|
||||
console.log(JSON.stringify(result, null, 2));
|
||||
} else {
|
||||
// eslint-disable-next-line no-console
|
||||
console.log(JSON.stringify(result));
|
||||
}
|
||||
ctl.output.result(result, () => print(JSON.stringify(result, null, args.pretty ? 2 : undefined)));
|
||||
},
|
||||
}));
|
||||
@@ -1,15 +1,15 @@
|
||||
import fs from "node:fs/promises";
|
||||
import asTableModule from "as-table";
|
||||
import events from "events";
|
||||
import os from "os";
|
||||
import child_process from "child_process";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { logger } from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
import { serializedConfigToString, getEditor, configToKeyVal } from "./config_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
import { asTable, print } from "./command_ops.js";
|
||||
import {
|
||||
serializedConfigToString, getEditor, configToKeyVal, printConfig, printRestartRequired,
|
||||
} from "./config_ops.js";
|
||||
|
||||
export const hostCommands = new lib.CommandTree({ name: "host", description: "Host management" });
|
||||
hostCommands.add(new lib.Command({
|
||||
@@ -45,8 +45,7 @@ hostCommands.add(new lib.Command({
|
||||
hostCommands.add(new lib.Command({
|
||||
definition: [["list", "l"], "List hosts connected to the controller"],
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let hosts = await ctl.send(new lib.HostListRequest());
|
||||
print(asTable(hosts));
|
||||
ctl.output.table(await ctl.send(new lib.HostListRequest()));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -71,17 +70,19 @@ hostCommands.add(new lib.Command({
|
||||
definition: ["pending", "List host installers waiting for approval"],
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let requests = await ctl.send(new lib.HostPairingListRequest());
|
||||
if (!requests.length) {
|
||||
print("No pending host requests");
|
||||
return;
|
||||
}
|
||||
let now = Date.now();
|
||||
print(asTable(requests.map(request => ({
|
||||
code: request.code,
|
||||
name: request.name,
|
||||
address: request.remoteAddress,
|
||||
age: formatAge(now - request.createdAtMs),
|
||||
}))));
|
||||
ctl.output.result(requests, () => {
|
||||
if (!requests.length) {
|
||||
print("No pending host requests");
|
||||
return;
|
||||
}
|
||||
let now = Date.now();
|
||||
print(asTable(requests.map(request => ({
|
||||
code: request.code,
|
||||
name: request.name,
|
||||
address: request.remoteAddress,
|
||||
age: formatAge(now - request.createdAtMs),
|
||||
}))));
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -99,7 +100,10 @@ hostCommands.add(new lib.Command({
|
||||
name = requests.find(request => plainCode(request.code) === plainCode(args.code))?.name;
|
||||
}
|
||||
let hostId = await ctl.send(new lib.HostPairingApproveRequest(args.code, args.name));
|
||||
print(name ? `Approved host ${name} with id ${hostId}` : `Approved host with id ${hostId}`);
|
||||
ctl.output.result(
|
||||
{ id: hostId, name },
|
||||
() => print(name ? `Approved host ${name} with id ${hostId}` : `Approved host with id ${hostId}`),
|
||||
);
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -137,9 +141,8 @@ hostCommands.add(new lib.Command({
|
||||
}
|
||||
if (args.restart) {
|
||||
await ctl.sendTo({ hostId }, new lib.HostRestartRequest());
|
||||
} else {
|
||||
print("Host updated; a restart is required to apply the changes.");
|
||||
}
|
||||
printRestartRequired(ctl, !args.restart, "Host updated");
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -153,11 +156,7 @@ hostConfigCommands.add(new lib.Command({
|
||||
}],
|
||||
handler: async function(args: { host: string }, ctl: Ctl) {
|
||||
let hostId = await lib.resolveHost(ctl, args.host);
|
||||
let config = await ctl.sendTo({ hostId }, new lib.HostConfigGetRequest());
|
||||
|
||||
for (let [name, value] of Object.entries(config)) {
|
||||
print(`${name} ${JSON.stringify(value)}`);
|
||||
}
|
||||
printConfig(ctl, await ctl.sendTo({ hostId }, new lib.HostConfigGetRequest()));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -255,19 +254,22 @@ hostConfigCommands.add(new lib.Command({
|
||||
index,
|
||||
final[index],
|
||||
));
|
||||
} catch (err) {
|
||||
// eslint-disable-next-line
|
||||
print(`Attempt to set ${index} to ${final[index] || String(null)} failed; set back to previous value.`);
|
||||
} catch (err: any) {
|
||||
// If the string is empty, it's better to just print "" instead of nothing
|
||||
print(err);
|
||||
logger.error(
|
||||
`Attempt to set ${index} to ${final[index] || String(null)} failed; ` +
|
||||
`set back to previous value: ${err.message}`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
await fs.unlink(tmpFile);
|
||||
} catch (err) {
|
||||
print("err: temporary file", tmpFile, "could not be deleted.");
|
||||
print("This is not fatal, but they may build up over time if the issue persists.");
|
||||
logger.warn(
|
||||
`Temporary file ${tmpFile} could not be deleted. ` +
|
||||
"This is not fatal, but they may build up over time if the issue persists."
|
||||
);
|
||||
}
|
||||
},
|
||||
}));
|
||||
@@ -285,9 +287,9 @@ hostPluginCommands.add(new lib.Command({
|
||||
handler: async function(args: { host: string }, ctl: Ctl) {
|
||||
let hostId = await lib.resolveHost(ctl, args.host);
|
||||
const plugins = await ctl.sendTo({ hostId }, new lib.PluginListRequest());
|
||||
print(asTable(plugins.map(p => ({
|
||||
ctl.output.table(plugins, p => ({
|
||||
title: p.title, version: p.version, state: p.state, npmPackage: p.npmPackage,
|
||||
}))));
|
||||
}));
|
||||
},
|
||||
}));
|
||||
hostPluginCommands.add(new lib.Command({
|
||||
@@ -301,9 +303,8 @@ hostPluginCommands.add(new lib.Command({
|
||||
await ctl.sendTo({ hostId }, new lib.PluginUpdateRequest(args.plugin));
|
||||
if (args.restart) {
|
||||
await ctl.sendTo({ hostId }, new lib.HostRestartRequest());
|
||||
} else {
|
||||
print("Plugin updated; a restart is required to apply the changes.");
|
||||
}
|
||||
printRestartRequired(ctl, !args.restart, "Plugin updated");
|
||||
},
|
||||
}));
|
||||
hostPluginCommands.add(new lib.Command({
|
||||
@@ -317,9 +318,8 @@ hostPluginCommands.add(new lib.Command({
|
||||
await ctl.sendTo({ hostId }, new lib.PluginInstallRequest(args.plugin));
|
||||
if (args.restart) {
|
||||
await ctl.sendTo({ hostId }, new lib.HostRestartRequest());
|
||||
} else {
|
||||
print("Plugin installed; a restart is required to apply the changes.");
|
||||
}
|
||||
printRestartRequired(ctl, !args.restart, "Plugin installed");
|
||||
},
|
||||
}));
|
||||
hostCommands.add(hostPluginCommands);
|
||||
@@ -1,5 +1,4 @@
|
||||
import fs from "node:fs/promises";
|
||||
import asTableModule from "as-table";
|
||||
import events from "events";
|
||||
import path from "path";
|
||||
import os from "os";
|
||||
@@ -10,10 +9,9 @@ import util from "util";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { logger } from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
import { serializedConfigToString, getEditor, configToKeyVal } from "./config_ops.js";
|
||||
import { errorToJson, print } from "./command_ops.js";
|
||||
import { serializedConfigToString, getEditor, configToKeyVal, printConfig } from "./config_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
const finished = util.promisify(stream.finished);
|
||||
|
||||
export const instanceCommands = new lib.CommandTree({
|
||||
@@ -27,7 +25,7 @@ instanceCommands.add(new lib.Command({
|
||||
}],
|
||||
handler: async function(args: { templates: boolean }, ctl: Ctl) {
|
||||
let list = await ctl.send(new lib.InstanceDetailsListRequest());
|
||||
print(asTable(list.filter(instance => args.templates || !instance.isTemplate)));
|
||||
ctl.output.table(list.filter(instance => args.templates || !instance.isTemplate));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -64,6 +62,7 @@ instanceCommands.add(new lib.Command({
|
||||
instanceConfig.toRemote("controller", fields),
|
||||
args.from
|
||||
));
|
||||
ctl.output.result({ id: instanceConfig.get("instance.id") }, () => {});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -81,19 +80,13 @@ instanceConfigCommands.add(new lib.Command({
|
||||
? config["instance.inherited_fields"] as Record<string, true | string[]> ?? {}
|
||||
: {};
|
||||
|
||||
for (let [name, value] of Object.entries(config)) {
|
||||
if (name === "instance.inherited_fields") {
|
||||
continue;
|
||||
}
|
||||
printConfig(ctl, config, name => {
|
||||
const entry = inherited[name];
|
||||
let note = "";
|
||||
if (entry instanceof Array && entry.length) {
|
||||
note = ` (inherited except ${entry.join(", ")})`;
|
||||
} else if (entry) {
|
||||
note = " (inherited)";
|
||||
return ` (inherited except ${entry.join(", ")})`;
|
||||
}
|
||||
print(`${name} ${JSON.stringify(value)}${note}`);
|
||||
}
|
||||
return entry ? " (inherited)" : "";
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -225,19 +218,22 @@ instanceConfigCommands.add(new lib.Command({
|
||||
index,
|
||||
final[index],
|
||||
));
|
||||
} catch (err) {
|
||||
// eslint-disable-next-line
|
||||
print(`Attempt to set ${index} to ${final[index] || String(null)} failed; set back to previous value.`);
|
||||
} catch (err: any) {
|
||||
// If the string is empty, it's better to just print "" instead of nothing
|
||||
print(err);
|
||||
logger.error(
|
||||
`Attempt to set ${index} to ${final[index] || String(null)} failed; ` +
|
||||
`set back to previous value: ${err.message}`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
await fs.unlink(tmpFile);
|
||||
} catch (err) {
|
||||
print("err: temporary file", tmpFile, "could not be deleted.");
|
||||
print("This is not fatal, but they may build up over time if the issue persists.");
|
||||
logger.warn(
|
||||
`Temporary file ${tmpFile} could not be deleted. ` +
|
||||
"This is not fatal, but they may build up over time if the issue persists."
|
||||
);
|
||||
}
|
||||
},
|
||||
}));
|
||||
@@ -291,9 +287,7 @@ instanceSaveCommands.add(new lib.Command({
|
||||
let instanceId = await lib.resolveInstance(ctl, args.instance);
|
||||
let saves = await ctl.sendTo("controller", new lib.InstanceSaveDetailsListRequest());
|
||||
saves = saves.filter(save => save.instanceId === instanceId);
|
||||
print(asTable(saves.map(
|
||||
({ mtimeMs, ...rest }) => ({ ...rest, mtime: new Date(mtimeMs).toLocaleString() })
|
||||
)));
|
||||
ctl.output.table(saves, ({ mtimeMs, ...rest }) => ({ ...rest, mtime: new Date(mtimeMs).toLocaleString() }));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -394,13 +388,16 @@ instanceSaveCommands.add(new lib.Command({
|
||||
logger.error(requestError);
|
||||
}
|
||||
|
||||
if (result.saves && result.saves.length) {
|
||||
logger.info(`Successfully uploaded as ${result.saves[0]}`);
|
||||
}
|
||||
|
||||
if ((result.errors || []).length || (result.request_errors || []).length) {
|
||||
throw new lib.CommandError("Uploading save failed");
|
||||
}
|
||||
|
||||
const name = result.saves?.[0];
|
||||
ctl.output.result({ name }, () => {
|
||||
if (name) {
|
||||
print(`Successfully uploaded as ${name}`);
|
||||
}
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -439,7 +436,10 @@ instanceSaveCommands.add(new lib.Command({
|
||||
args.copy
|
||||
)
|
||||
);
|
||||
print(`Transferred as ${storedName} to ${args.targetInstance}.`);
|
||||
ctl.output.result(
|
||||
{ name: storedName, instanceId: targetInstanceId },
|
||||
() => print(`Transferred as ${storedName} to ${args.targetInstance}.`),
|
||||
);
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -456,7 +456,10 @@ instanceSaveCommands.add(new lib.Command({
|
||||
url.pathname += `api/stream/${streamId}`;
|
||||
const filename = await lib.downloadFile(url, args.save, "rename");
|
||||
|
||||
logger.info(`Downloaded ${args.save}${args.save === filename ? "" : ` as ${filename}`}`);
|
||||
ctl.output.result(
|
||||
{ filename },
|
||||
() => print(`Downloaded ${args.save}${args.save === filename ? "" : ` as ${filename}`}`),
|
||||
);
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -566,27 +569,34 @@ instanceCommands.add(new lib.Command({
|
||||
});
|
||||
|
||||
if (instancesToStart.length === 0) {
|
||||
print("No instances to start.");
|
||||
ctl.output.result([], () => print("No instances to start."));
|
||||
return;
|
||||
}
|
||||
|
||||
print(`Starting ${instancesToStart.length} instance(s):`);
|
||||
for (const instance of instancesToStart) {
|
||||
print(` - ${instance.name} (ID: ${instance.id})`);
|
||||
const human = ctl.output.human;
|
||||
if (human) {
|
||||
print(`Starting ${instancesToStart.length} instance(s):`);
|
||||
for (const instance of instancesToStart) {
|
||||
print(` - ${instance.name} (ID: ${instance.id})`);
|
||||
}
|
||||
}
|
||||
|
||||
// Start all filtered instances
|
||||
const startPromises = instancesToStart.map(async (instance: lib.InstanceDetails) => {
|
||||
const results = await Promise.all(instancesToStart.map(async (instance: lib.InstanceDetails) => {
|
||||
try {
|
||||
await ctl.sendTo({ instanceId: instance.id }, new lib.InstanceStartRequest());
|
||||
print(`✓ Started ${instance.name}`);
|
||||
if (human) {
|
||||
print(`✓ Started ${instance.name}`);
|
||||
}
|
||||
return { id: instance.id, name: instance.name };
|
||||
} catch (error) {
|
||||
print(`✗ Failed to start ${instance.name}: ${error}`);
|
||||
if (human) {
|
||||
print(`✗ Failed to start ${instance.name}: ${error}`);
|
||||
}
|
||||
return { id: instance.id, name: instance.name, error: errorToJson(error) };
|
||||
}
|
||||
});
|
||||
|
||||
await Promise.all(startPromises);
|
||||
print("Start all operation completed.");
|
||||
}));
|
||||
ctl.output.result(results, () => print("Start all operation completed."));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -646,27 +656,34 @@ instanceCommands.add(new lib.Command({
|
||||
.filter((instance: lib.InstanceDetails) => ["starting", "running"].includes(instance.status));
|
||||
|
||||
if (instancesToStop.length === 0) {
|
||||
print("No instances to stop.");
|
||||
ctl.output.result([], () => print("No instances to stop."));
|
||||
return;
|
||||
}
|
||||
|
||||
print(`Stopping ${instancesToStop.length} instance(s):`);
|
||||
for (const instance of instancesToStop) {
|
||||
print(` - ${instance.name} (ID: ${instance.id})`);
|
||||
const human = ctl.output.human;
|
||||
if (human) {
|
||||
print(`Stopping ${instancesToStop.length} instance(s):`);
|
||||
for (const instance of instancesToStop) {
|
||||
print(` - ${instance.name} (ID: ${instance.id})`);
|
||||
}
|
||||
}
|
||||
|
||||
// Stop all filtered instances
|
||||
const stopPromises = instancesToStop.map(async (instance: lib.InstanceDetails) => {
|
||||
const results = await Promise.all(instancesToStop.map(async (instance: lib.InstanceDetails) => {
|
||||
try {
|
||||
await ctl.sendTo({ instanceId: instance.id }, new lib.InstanceStopRequest());
|
||||
print(`✓ Stopped ${instance.name}`);
|
||||
if (human) {
|
||||
print(`✓ Stopped ${instance.name}`);
|
||||
}
|
||||
return { id: instance.id, name: instance.name };
|
||||
} catch (error) {
|
||||
print(`✗ Failed to stop ${instance.name}: ${error}`);
|
||||
if (human) {
|
||||
print(`✗ Failed to stop ${instance.name}: ${error}`);
|
||||
}
|
||||
return { id: instance.id, name: instance.name, error: errorToJson(error) };
|
||||
}
|
||||
});
|
||||
|
||||
await Promise.all(stopPromises);
|
||||
print("Stop all operation completed.");
|
||||
}));
|
||||
ctl.output.result(results, () => print("Stop all operation completed."));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -703,6 +720,6 @@ instanceCommands.add(new lib.Command({
|
||||
);
|
||||
|
||||
// Factorio includes a newline in its response output.
|
||||
process.stdout.write(result);
|
||||
ctl.output.result({ result }, () => process.stdout.write(result));
|
||||
},
|
||||
}));
|
||||
@@ -27,6 +27,7 @@ logCommands.add(new lib.Command({
|
||||
let hostIds = args.host ? [await lib.resolveHost(ctl, args.host)] : [];
|
||||
await ctl.setLogSubscriptions({ all: args.all, controller: args.controller, hostIds, instanceIds });
|
||||
ctl.keepOpen = true;
|
||||
ctl.output.streamingLog = true;
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -75,16 +76,18 @@ logCommands.add(new lib.Command({
|
||||
result.log.reverse();
|
||||
}
|
||||
|
||||
let stdoutLogger = winston.createLogger({
|
||||
level: "verbose",
|
||||
levels,
|
||||
format: new lib.TerminalFormat({ showTimestamp: true }),
|
||||
transports: [
|
||||
new ConsoleTransport({ errorLevels: [], warnLevels: [] }),
|
||||
],
|
||||
ctl.output.result(result.log, () => {
|
||||
let stdoutLogger = winston.createLogger({
|
||||
level: "verbose",
|
||||
levels,
|
||||
format: new lib.TerminalFormat({ showTimestamp: true }),
|
||||
transports: [
|
||||
new ConsoleTransport({ errorLevels: [], warnLevels: [] }),
|
||||
],
|
||||
});
|
||||
for (let info of result.log) {
|
||||
stdoutLogger.log(info as any);
|
||||
}
|
||||
});
|
||||
for (let info of result.log) {
|
||||
stdoutLogger.log(info as any);
|
||||
}
|
||||
},
|
||||
}));
|
||||
@@ -1,5 +1,4 @@
|
||||
import fs from "node:fs/promises";
|
||||
import asTableModule from "as-table";
|
||||
import events from "events";
|
||||
import path from "path";
|
||||
import stream from "stream";
|
||||
@@ -8,9 +7,7 @@ import util from "util";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { logger } from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
import { asTable, pickFields, print } from "./command_ops.js";
|
||||
const finished = util.promisify(stream.finished);
|
||||
|
||||
export const modCommands = new lib.CommandTree({ name: "mod", description: "Manage uploaded mods" });
|
||||
@@ -24,16 +21,18 @@ modCommands.add(new lib.Command({
|
||||
throw new lib.CommandError("mod-version must match format digit.digit.digit");
|
||||
}
|
||||
let modInfo = await ctl.send(new lib.ModGetRequest(args.name, args.modVersion));
|
||||
for (let [field, value] of Object.entries(modInfo)) {
|
||||
if (value instanceof Array) {
|
||||
print(`${field}:`);
|
||||
for (let entry of value) {
|
||||
print(` ${entry}`);
|
||||
ctl.output.result(modInfo, () => {
|
||||
for (let [field, value] of Object.entries(modInfo)) {
|
||||
if (value instanceof Array) {
|
||||
print(`${field}:`);
|
||||
for (let entry of value) {
|
||||
print(` ${entry}`);
|
||||
}
|
||||
} else {
|
||||
print(`${field}: ${value}`);
|
||||
}
|
||||
} else {
|
||||
print(`${field}: ${value}`);
|
||||
}
|
||||
}
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -50,17 +49,7 @@ modCommands.add(new lib.Command({
|
||||
}],
|
||||
handler: async function(args: { fields: string[] }, ctl: Ctl) {
|
||||
let mods = await ctl.send(new lib.ModListRequest());
|
||||
if (!args.fields.includes("all")) {
|
||||
for (let entry of mods) {
|
||||
for (let field of Object.keys(entry)) {
|
||||
if (!args.fields.includes(field)) {
|
||||
// @ts-expect-error terrible hack
|
||||
delete entry[field];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
print(asTable(mods));
|
||||
ctl.output.table(mods, mod => pickFields(mod, args.fields));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -121,21 +110,19 @@ modCommands.add(new lib.Command({
|
||||
args.sortOrder
|
||||
));
|
||||
let results = response.results.flatMap(result => result.versions);
|
||||
if (!args.fields.includes("all")) {
|
||||
for (let entry of results) {
|
||||
for (let field of Object.keys(entry)) {
|
||||
if (!args.fields.includes(field)) {
|
||||
// @ts-expect-error terrible hack
|
||||
delete entry[field];
|
||||
}
|
||||
}
|
||||
ctl.output.result({
|
||||
page: args.page,
|
||||
pageCount: response.pageCount,
|
||||
resultCount: response.resultCount,
|
||||
queryIssues: response.queryIssues,
|
||||
results,
|
||||
}, () => {
|
||||
for (let issue of response.queryIssues) {
|
||||
print(issue);
|
||||
}
|
||||
}
|
||||
for (let issue of response.queryIssues) {
|
||||
print(issue);
|
||||
}
|
||||
print(`page ${args.page} of ${response.pageCount} (${response.resultCount} results)`);
|
||||
print(asTable(results));
|
||||
print(`page ${args.page} of ${response.pageCount} (${response.resultCount} results)`);
|
||||
print(asTable(results.map(mod => pickFields(mod, args.fields))));
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -174,14 +161,16 @@ modCommands.add(new lib.Command({
|
||||
logger.error(requestError);
|
||||
}
|
||||
|
||||
if (result.mods && result.mods.length) {
|
||||
const mod = lib.ModInfo.fromJSON(result.mods[0]);
|
||||
logger.info(`Successfully uploaded ${mod.filename}`);
|
||||
}
|
||||
|
||||
if ((result.errors || []).length || (result.request_errors || []).length) {
|
||||
throw new lib.CommandError("Uploading mod failed");
|
||||
}
|
||||
|
||||
const uploaded = result.mods?.length ? lib.ModInfo.fromJSON(result.mods[0]).filename : undefined;
|
||||
ctl.output.result({ filename: uploaded }, () => {
|
||||
if (uploaded) {
|
||||
print(`Successfully uploaded ${uploaded}`);
|
||||
}
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -201,7 +190,7 @@ modCommands.add(new lib.Command({
|
||||
let filename = `${args.name}_${args.modVersion}.zip`;
|
||||
await lib.downloadFile(url, filename, "overwrite");
|
||||
|
||||
logger.info(`Downloaded ${filename}`);
|
||||
ctl.output.result({ filename }, () => print(`Downloaded ${filename}`));
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -1,11 +1,7 @@
|
||||
import asTableModule from "as-table";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { logger } from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
import { pickFields, print } from "./command_ops.js";
|
||||
|
||||
export const modPackCommands = new lib.CommandTree({ name: "mod-pack", description: "Mod Pack" });
|
||||
modPackCommands.add(new lib.Command({
|
||||
@@ -19,56 +15,50 @@ modPackCommands.add(new lib.Command({
|
||||
let modPack = await ctl.send(
|
||||
new lib.ModPackGetRequest(await lib.resolveModPack(ctl, args.modPack))
|
||||
);
|
||||
|
||||
for (let [field, value] of Object.entries(modPack)) {
|
||||
if (field === "mods") {
|
||||
print(`${field}:`);
|
||||
for (let [name, entry] of value) {
|
||||
const mod = mods.get(`${name}_${entry.version}`);
|
||||
const missing = !mod && "? ";
|
||||
const badChecksum = mod && entry.sha1 && entry.sha1 !== mod.sha1 && "! ";
|
||||
const warn = missing || badChecksum || "";
|
||||
const enabled = entry.enabled ? "" : "(disabled) ";
|
||||
print(` ${warn}${enabled}${name} ${entry.version}${entry.sha1 ? ` (${entry.sha1})` : ""}`);
|
||||
}
|
||||
} else if (field === "settings") {
|
||||
print(`${field}:`);
|
||||
for (let [scope, settings] of Object.entries(value)) {
|
||||
print(` ${scope}:`);
|
||||
for (let [setting, settingValue] of settings as any) {
|
||||
print(` ${setting}: ${JSON.stringify(settingValue.value)}`);
|
||||
}
|
||||
}
|
||||
} else if (field === "exportManifest") {
|
||||
print(`${field}:`);
|
||||
if (value && value.assets) {
|
||||
print(" assets:");
|
||||
for (let [name, fileName] of Object.entries(value.assets)) {
|
||||
print(` ${name}: ${fileName}`);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
print(`${field}: ${value}`);
|
||||
}
|
||||
}
|
||||
ctl.output.result(modPack, () => printModPack(modPack, mods));
|
||||
},
|
||||
}));
|
||||
|
||||
function printModPack(modPack: lib.ModPack, mods: Map<string, lib.ModInfo>) {
|
||||
for (let [field, value] of Object.entries(modPack)) {
|
||||
if (field === "mods") {
|
||||
print(`${field}:`);
|
||||
for (let [name, entry] of value) {
|
||||
const mod = mods.get(`${name}_${entry.version}`);
|
||||
const missing = !mod && "? ";
|
||||
const badChecksum = mod && entry.sha1 && entry.sha1 !== mod.sha1 && "! ";
|
||||
const warn = missing || badChecksum || "";
|
||||
const enabled = entry.enabled ? "" : "(disabled) ";
|
||||
print(` ${warn}${enabled}${name} ${entry.version}${entry.sha1 ? ` (${entry.sha1})` : ""}`);
|
||||
}
|
||||
} else if (field === "settings") {
|
||||
print(`${field}:`);
|
||||
for (let [scope, settings] of Object.entries(value)) {
|
||||
print(` ${scope}:`);
|
||||
for (let [setting, settingValue] of settings as any) {
|
||||
print(` ${setting}: ${JSON.stringify(settingValue.value)}`);
|
||||
}
|
||||
}
|
||||
} else if (field === "exportManifest") {
|
||||
print(`${field}:`);
|
||||
if (value && value.assets) {
|
||||
print(" assets:");
|
||||
for (let [name, fileName] of Object.entries(value.assets)) {
|
||||
print(` ${name}: ${fileName}`);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
print(`${field}: ${value}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
modPackCommands.add(new lib.Command({
|
||||
definition: [["list", "l"], "List mod packs in the cluster"],
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let modPacks = await ctl.send(new lib.ModPackListRequest());
|
||||
let fields = ["id", "name", "factorioVersion"];
|
||||
for (let entry of modPacks) {
|
||||
for (let field of Object.keys(entry)) {
|
||||
if (!fields.includes(field)) {
|
||||
// @ts-expect-error terrible hack
|
||||
delete entry[field];
|
||||
}
|
||||
}
|
||||
}
|
||||
print(asTable(modPacks));
|
||||
ctl.output.table(modPacks, modPack => pickFields(modPack, ["id", "name", "factorioVersion"]));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -194,10 +184,17 @@ modPackCommands.add(new lib.Command({
|
||||
setModPackModsEnabled(modPack, args.disabledMods, false);
|
||||
setModPackSettings(modPack, args);
|
||||
await ctl.send(new lib.ModPackCreateRequest(modPack));
|
||||
print(`Created mod pack ${modPack.name} (${modPack.id})`);
|
||||
printCreated(ctl, modPack);
|
||||
},
|
||||
}));
|
||||
|
||||
function printCreated(ctl: Ctl, modPack: lib.ModPack) {
|
||||
ctl.output.result(
|
||||
{ id: modPack.id, name: modPack.name },
|
||||
() => print(`Created mod pack ${modPack.name} (${modPack.id})`),
|
||||
);
|
||||
}
|
||||
|
||||
modPackCommands.add(new lib.Command({
|
||||
definition: ["import <string>", "Import mod pack string", (yargs) => {
|
||||
yargs.positional("string", { describe: "Mod pack string to import", type: "string" });
|
||||
@@ -205,7 +202,7 @@ modPackCommands.add(new lib.Command({
|
||||
handler: async function(args: { string: string }, ctl: Ctl) {
|
||||
const modPack = lib.ModPack.fromModPackString(args.string);
|
||||
await ctl.send(new lib.ModPackCreateRequest(modPack));
|
||||
print(`Created mod pack ${modPack.name} (${modPack.id})`);
|
||||
printCreated(ctl, modPack);
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -217,7 +214,8 @@ modPackCommands.add(new lib.Command({
|
||||
const modPack = await ctl.send(
|
||||
new lib.ModPackGetRequest(await lib.resolveModPack(ctl, args.modPack))
|
||||
);
|
||||
print(modPack.toModPackString());
|
||||
const modPackString = modPack.toModPackString();
|
||||
ctl.output.result({ modPackString }, () => print(modPackString));
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -1,11 +1,7 @@
|
||||
import asTableModule from "as-table";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
|
||||
export const noteCommands = new lib.CommandTree({
|
||||
name: "note", description: "Notes attached to hosts, instances, users and other resources",
|
||||
});
|
||||
@@ -20,12 +16,12 @@ noteCommands.add(new lib.Command({
|
||||
if (args.type !== undefined) {
|
||||
notes = notes.filter(note => note.resourceType === args.type);
|
||||
}
|
||||
print(asTable(notes.map(note => ({
|
||||
ctl.output.table(notes, note => ({
|
||||
type: note.resourceType,
|
||||
id: note.resourceId,
|
||||
updatedBy: note.updatedBy,
|
||||
content: note.content,
|
||||
}))));
|
||||
}));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -42,7 +38,7 @@ noteCommands.add(new lib.Command({
|
||||
if (!note) {
|
||||
throw new lib.CommandError(`No note for ${args.type} ${args.id}`);
|
||||
}
|
||||
print(note.content);
|
||||
ctl.output.result(note, () => print(note.content));
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -1,16 +1,10 @@
|
||||
import asTableModule from "as-table";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
const asTable = asTableModule.configure({ delimiter: " | " });
|
||||
|
||||
export const permissionCommands = new lib.CommandTree({ name: "permission", description: "Permission inspection" });
|
||||
permissionCommands.add(new lib.Command({
|
||||
definition: [["list", "l"], "List permissions in the cluster"],
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let permissions = await ctl.send(new lib.PermissionListRequest());
|
||||
print(asTable(permissions));
|
||||
ctl.output.table(await ctl.send(new lib.PermissionListRequest()));
|
||||
},
|
||||
}));
|
||||
@@ -1,15 +1,13 @@
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { logger } from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { asTable, print } from "./command_ops.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
export const roleCommands = new lib.CommandTree({ name: "role", description: "Role management" });
|
||||
roleCommands.add(new lib.Command({
|
||||
definition: [["list", "l"], "List roles in the cluster"],
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let roles = await ctl.send(new lib.RoleListRequest());
|
||||
print(asTable(roles));
|
||||
ctl.output.table(await ctl.send(new lib.RoleListRequest()));
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -27,7 +25,7 @@ roleCommands.add(new lib.Command({
|
||||
args.description,
|
||||
args.permissions,
|
||||
));
|
||||
logger.info(`Created role ID ${id}`);
|
||||
ctl.output.result({ id }, () => print(`Created role ID ${id}`));
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -5,6 +5,10 @@ import * as lib from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { asTable, print } from "./command_ops.js";
|
||||
|
||||
function printProperties(object: object) {
|
||||
print(asTable(Object.entries(object).map(([property, value]) => ({ property, value }))));
|
||||
}
|
||||
|
||||
export const userCommands = new lib.CommandTree({ name: "user", alias: ["u"], description: "User management" });
|
||||
userCommands.add(new lib.Command({
|
||||
definition: ["show <name>", "Show details for one user", (yargs) => {
|
||||
@@ -14,30 +18,23 @@ userCommands.add(new lib.Command({
|
||||
});
|
||||
}],
|
||||
handler: async function(args: { name: string, instanceStats: boolean }, ctl: Ctl) {
|
||||
let user = await ctl.send(new lib.UserGetRequest(args.name));
|
||||
Object.assign(user, user.playerStats);
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.playerStats;
|
||||
let instanceStats = user.instanceStats;
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.instanceStats;
|
||||
print(asTable(Object.entries(user).map(([property, value]) => ({ property, value }))));
|
||||
|
||||
if (args.instanceStats) {
|
||||
let instances = await ctl.send(new lib.InstanceDetailsListRequest());
|
||||
function instanceName(id: number) {
|
||||
let instance = instances.find(i => i.id === id);
|
||||
if (instance) {
|
||||
return instance.name;
|
||||
}
|
||||
return "<deleted>";
|
||||
const user = await ctl.send(new lib.UserGetRequest(args.name));
|
||||
const { playerStats, instanceStats, ...properties } = user;
|
||||
const instances = args.instanceStats && ctl.output.human
|
||||
? await ctl.send(new lib.InstanceDetailsListRequest())
|
||||
: [];
|
||||
ctl.output.result(user, () => {
|
||||
printProperties({ ...properties, ...playerStats });
|
||||
if (!args.instanceStats) {
|
||||
return;
|
||||
}
|
||||
for (let [id, playerInstanceStats] of instanceStats || []) {
|
||||
for (let [id, playerInstanceStats] of instanceStats) {
|
||||
const name = instances.find(i => i.id === id)?.name ?? "<deleted>";
|
||||
print();
|
||||
print(`Instance ${instanceName(id)} (${id}):`);
|
||||
print(asTable(Object.entries(playerInstanceStats).map(([property, value]) => ({ property, value }))));
|
||||
print(`Instance ${name} (${id}):`);
|
||||
printProperties(playerInstanceStats);
|
||||
}
|
||||
}
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -49,29 +46,17 @@ userCommands.add(new lib.Command({
|
||||
});
|
||||
}],
|
||||
handler: async function(args: { stats: boolean, attributes: boolean }, ctl: Ctl) {
|
||||
let users = await ctl.send(new lib.UserListRequest());
|
||||
for (let user of users) {
|
||||
if (args.stats) {
|
||||
Object.assign(user, user.playerStats);
|
||||
}
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.playerStats;
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.isDeleted;
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.banReason;
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.instanceStats;
|
||||
if (!args.attributes) {
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.isAdmin;
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.isWhitelisted;
|
||||
// @ts-expect-error Terrible hack
|
||||
delete user.isBanned;
|
||||
}
|
||||
}
|
||||
print(asTable(users));
|
||||
const users = await ctl.send(new lib.UserListRequest());
|
||||
ctl.output.table(users, user => {
|
||||
const {
|
||||
playerStats, isDeleted, banReason, instanceStats, isAdmin, isWhitelisted, isBanned, ...row
|
||||
} = user;
|
||||
return {
|
||||
...row,
|
||||
...args.attributes && { isAdmin, isWhitelisted, isBanned },
|
||||
...args.stats && playerStats,
|
||||
};
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -219,11 +204,17 @@ async function handleImportOrRestore(args: {
|
||||
new lib.UserBulkImportRequest(importType, importType === "users" ? data.users : data, restore)
|
||||
);
|
||||
|
||||
print(`${restore ? "Restored" : "Imported"} ${importType} from ${args.filepath}`);
|
||||
let backupFile: string | undefined;
|
||||
if (restore && backup && !args.noBackup) {
|
||||
await fs.writeFile(`${importType}-backup.json`, JSON.stringify(backup, undefined, "\t"));
|
||||
print(`Wrote backup to ${importType}-backup.json`);
|
||||
backupFile = `${importType}-backup.json`;
|
||||
await fs.writeFile(backupFile, JSON.stringify(backup, undefined, "\t"));
|
||||
}
|
||||
ctl.output.result({ type: importType, backupFile }, () => {
|
||||
print(`${restore ? "Restored" : "Imported"} ${importType} from ${args.filepath}`);
|
||||
if (backupFile) {
|
||||
print(`Wrote backup to ${backupFile}`);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
userCommands.add(new lib.Command({
|
||||
@@ -296,6 +287,9 @@ userCommands.add(new lib.Command({
|
||||
await fs.writeFile(args.filepath, JSON.stringify(await ctl.send(
|
||||
new lib.UserBulkExportRequest(exportType)
|
||||
), undefined, "\t"));
|
||||
print(`Exported ${exportType} to ${args.filepath}`);
|
||||
ctl.output.result(
|
||||
{ type: exportType, filepath: args.filepath },
|
||||
() => print(`Exported ${exportType} to ${args.filepath}`),
|
||||
);
|
||||
},
|
||||
}));
|
||||
@@ -1,4 +1,6 @@
|
||||
import * as lib from "@clusterio/lib";
|
||||
import type { Ctl } from "../ctl.js";
|
||||
import { print } from "./command_ops.js";
|
||||
|
||||
export async function getEditor(argsEditor: string) {
|
||||
// eslint-disable-next-line
|
||||
@@ -53,3 +55,24 @@ export function serializedConfigToString(
|
||||
}
|
||||
return allConfigElements;
|
||||
}
|
||||
|
||||
/** Print config fields as `name value` lines, or as an object in json mode */
|
||||
export function printConfig(ctl: Ctl, config: lib.ConfigSchema, note = (name: string) => "") {
|
||||
ctl.output.result(config, () => {
|
||||
for (let [name, value] of Object.entries(config)) {
|
||||
// Shown as an (inherited) note on each field by instance config list instead
|
||||
if (name !== "instance.inherited_fields") {
|
||||
print(`${name} ${JSON.stringify(value)}${note(name)}`);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/** Print whether a restart is still needed after an update or install */
|
||||
export function printRestartRequired(ctl: Ctl, restartRequired: boolean, action: string) {
|
||||
ctl.output.result({ restartRequired }, () => {
|
||||
if (restartRequired) {
|
||||
print(`${action}; a restart is required to apply the changes.`);
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/host",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Implementation of Clusterio host server",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/lib",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Shared library for Clusterio",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/web_ui",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio web interface implementation",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/plugin-global_chat",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio plugin forwarding between Factorio servers",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/plugin-player_auth",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio plugin authenticating logged in players to the web interface",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
+51
-26
@@ -30,14 +30,20 @@ playerSyncCommands.add(new lib.Command({
|
||||
handler: async function(args: object, ctl: Ctl) {
|
||||
let players = await ctl.send(new msg.ListPlayersRequest());
|
||||
players.sort((a, b) => a.name.localeCompare(b.name));
|
||||
print("name | generation | size | acquired by");
|
||||
for (let player of players) {
|
||||
print(
|
||||
`${player.name} | ${player.generation ?? "-"} | ` +
|
||||
`${player.size === undefined ? "-" : lib.formatBytes(player.size)} | ` +
|
||||
`${await instanceName(ctl, player.instanceId)}`
|
||||
);
|
||||
if (!ctl.output.human) {
|
||||
ctl.output.result(players);
|
||||
return;
|
||||
}
|
||||
let rows = [];
|
||||
for (let player of players) {
|
||||
rows.push({
|
||||
name: player.name,
|
||||
generation: player.generation ?? "-",
|
||||
size: player.size === undefined ? "-" : lib.formatBytes(player.size),
|
||||
"acquired by": await instanceName(ctl, player.instanceId),
|
||||
});
|
||||
}
|
||||
ctl.output.table(rows);
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -47,24 +53,37 @@ playerSyncCommands.add(new lib.Command({
|
||||
}],
|
||||
handler: async function(args: { player: string }, ctl: Ctl) {
|
||||
let response = await ctl.send(new msg.GetPlayerDataRequest(args.player));
|
||||
print(`acquired by: ${await instanceName(ctl, response.instanceId)}`);
|
||||
let playerData = response.playerData;
|
||||
if (!playerData) {
|
||||
print(`No player data stored for ${args.player}`);
|
||||
return;
|
||||
}
|
||||
print(`generation: ${playerData.generation}`);
|
||||
print(`size: ${lib.formatBytes(JSON.stringify(playerData).length)}`);
|
||||
print(`controller: ${playerData.controller}`);
|
||||
print(`force: ${playerData.force}`);
|
||||
for (let inventory of summarizePlayerInventories(playerData)) {
|
||||
print(`${inventory.name}:`);
|
||||
for (let item of inventory.items) {
|
||||
let quality = item.quality ? ` (${item.quality})` : "";
|
||||
let size = item.exportSize ? ` ${lib.formatBytes(item.exportSize)}` : "";
|
||||
print(` ${item.count} ${item.name}${quality}${size}`);
|
||||
const summary = {
|
||||
instanceId: response.instanceId,
|
||||
...playerData && {
|
||||
generation: playerData.generation,
|
||||
size: JSON.stringify(playerData).length,
|
||||
controller: playerData.controller,
|
||||
force: playerData.force,
|
||||
inventories: summarizePlayerInventories(playerData),
|
||||
},
|
||||
};
|
||||
const acquiredBy = ctl.output.human ? await instanceName(ctl, response.instanceId) : "";
|
||||
ctl.output.result(summary, () => {
|
||||
print(`acquired by: ${acquiredBy}`);
|
||||
if (!playerData) {
|
||||
print(`No player data stored for ${args.player}`);
|
||||
return;
|
||||
}
|
||||
}
|
||||
print(`generation: ${summary.generation}`);
|
||||
print(`size: ${lib.formatBytes(summary.size!)}`);
|
||||
print(`controller: ${summary.controller}`);
|
||||
print(`force: ${summary.force}`);
|
||||
for (let inventory of summary.inventories!) {
|
||||
print(`${inventory.name}:`);
|
||||
for (let item of inventory.items) {
|
||||
let quality = item.quality ? ` (${item.quality})` : "";
|
||||
let size = item.exportSize ? ` ${lib.formatBytes(item.exportSize)}` : "";
|
||||
print(` ${item.count} ${item.name}${quality}${size}`);
|
||||
}
|
||||
}
|
||||
});
|
||||
},
|
||||
}));
|
||||
|
||||
@@ -81,9 +100,12 @@ playerSyncCommands.add(new lib.Command({
|
||||
let content = JSON.stringify(response.playerData, null, "\t");
|
||||
if (args.file) {
|
||||
await fs.writeFile(args.file, content);
|
||||
print(`Wrote player data for ${args.player} to ${args.file}`);
|
||||
ctl.output.result(
|
||||
{ file: args.file },
|
||||
() => print(`Wrote player data for ${args.player} to ${args.file}`),
|
||||
);
|
||||
} else {
|
||||
print(content);
|
||||
ctl.output.result(response.playerData, () => print(content));
|
||||
}
|
||||
},
|
||||
}));
|
||||
@@ -101,7 +123,10 @@ playerSyncCommands.add(new lib.Command({
|
||||
playerData.name = args.player;
|
||||
playerData.generation ??= 0;
|
||||
let response = await ctl.send(new msg.SetPlayerDataRequest(args.player, playerData));
|
||||
print(`Stored player data for ${args.player} as generation ${response.generation}`);
|
||||
ctl.output.result(
|
||||
{ generation: response.generation },
|
||||
() => print(`Stored player data for ${args.player} as generation ${response.generation}`),
|
||||
);
|
||||
},
|
||||
}));
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/plugin-player_sync",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio plugin forwarding between Factorio servers",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Danielv <danielv@danielv.no>",
|
||||
|
||||
@@ -4,7 +4,7 @@ import os from "node:os";
|
||||
import path from "node:path";
|
||||
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { CtlHooks } from "@clusterio/ctl";
|
||||
import { CommandOutput, CtlHooks } from "@clusterio/ctl";
|
||||
|
||||
import * as mock from "../../../test/mock.js";
|
||||
import { testRoundTripJsonSerialisable, testMatrix } from "../../../test/common.js";
|
||||
@@ -303,6 +303,7 @@ describe("player_sync plugin", function() {
|
||||
let printed;
|
||||
let responses;
|
||||
const ctl = {
|
||||
output: new CommandOutput(),
|
||||
async send(message) {
|
||||
sent.push(message);
|
||||
const handler = responses.get(message.constructor);
|
||||
@@ -331,6 +332,7 @@ describe("player_sync plugin", function() {
|
||||
beforeEach(function() {
|
||||
sent = [];
|
||||
printed = [];
|
||||
ctl.output = new CommandOutput();
|
||||
responses = new Map([
|
||||
[lib.InstanceDetailsGetRequest, request => ({ id: request.instanceId, name: "Test" })],
|
||||
[msg.ListPlayersRequest, () => [
|
||||
@@ -360,10 +362,12 @@ describe("player_sync plugin", function() {
|
||||
|
||||
it("list should print sorted entries", async function() {
|
||||
await run("list");
|
||||
assert.deepEqual(printed, [
|
||||
"name | generation | size | acquired by",
|
||||
`alice | 2 | ${lib.formatBytes(100)} | -`,
|
||||
"bob | - | - | Test (1)",
|
||||
const lines = printed.join("\n").split("\n").map(line => line.trimEnd());
|
||||
assert.deepEqual(lines, [
|
||||
"name | generation | size | acquired by",
|
||||
"--------------------------------------------",
|
||||
`alice | 2 | ${lib.formatBytes(100)} | -`,
|
||||
"bob | - | - | Test (1)",
|
||||
]);
|
||||
});
|
||||
it("show should print a summary", async function() {
|
||||
@@ -384,7 +388,7 @@ describe("player_sync plugin", function() {
|
||||
throw new lib.PermissionError("Permission denied");
|
||||
});
|
||||
await run("list");
|
||||
assert.equal(printed[2], "bob | - | - | 1");
|
||||
assert.match(printed[0], /bob +\| - +\| - +\| 1/);
|
||||
printed = [];
|
||||
await run("show", { player: "alice" });
|
||||
assert.equal(printed[0], "acquired by: 1");
|
||||
@@ -421,6 +425,23 @@ describe("player_sync plugin", function() {
|
||||
new lib.CommandError("Player data must be a JSON object"),
|
||||
);
|
||||
});
|
||||
it("should print JSON in json mode", async function() {
|
||||
ctl.output = new CommandOutput("json");
|
||||
await run("list");
|
||||
assert.deepEqual(JSON.parse(printed[0]), [
|
||||
{ name: "alice", generation: 2, size: 100 },
|
||||
{ name: "bob", instanceId: 1 },
|
||||
]);
|
||||
printed = [];
|
||||
await run("show", { player: "alice" });
|
||||
const shown = JSON.parse(printed[0]);
|
||||
assert.equal(shown.instanceId, 1);
|
||||
assert.equal(shown.generation, 2);
|
||||
assert.deepEqual(shown.inventories[0].items[0], { name: "wood", count: 5, quality: "rare" });
|
||||
printed = [];
|
||||
await run("export", { player: "alice" });
|
||||
assert.deepEqual(JSON.parse(printed[0]), storedData);
|
||||
});
|
||||
it("delete and release should send requests", async function() {
|
||||
await run("delete", { player: "alice" });
|
||||
await run("release", { player: "alice" });
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/plugin-research_sync",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio plugin for synchronizing research between Factorio servers",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/plugin-statistics_exporter",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio plugin for gathering statistics from Factorio servers",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "@clusterio/plugin-subspace_storage",
|
||||
"version": "2.1.0",
|
||||
"version": "2.1.1",
|
||||
"description": "Clusterio plugin for sharing storage between Factorio servers",
|
||||
"homepage": "https://github.com/clusterio/clusterio#readme",
|
||||
"author": "Hornwitser <github@hornwitser.no>",
|
||||
|
||||
@@ -0,0 +1,95 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { CommandOutput, errorToJson, pickFields, toPlain } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
describe("ctl/command_ops", function() {
|
||||
describe("toPlain()", function() {
|
||||
it("converts Sets, Maps and Dates", function() {
|
||||
assert.deepEqual(
|
||||
toPlain({ set: new Set([1, 2]), map: new Map([[3, { a: new Set(["b"]) }]]), date: new Date(0) }),
|
||||
{ set: [1, 2], map: { 3: { a: ["b"] } }, date: "1970-01-01T00:00:00.000Z" },
|
||||
);
|
||||
});
|
||||
it("uses own properties instead of toJSON", function() {
|
||||
const role = new lib.Role(1, "name", "desc", new Set(["core.admin"]));
|
||||
assert.deepEqual(toPlain(role).permissions, ["core.admin"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("pickFields()", function() {
|
||||
it("keeps only the given fields unless all is given", function() {
|
||||
assert.deepEqual(pickFields({ a: 1, b: 2 }, ["a"]), { a: 1 });
|
||||
assert.deepEqual(pickFields({ a: 1, b: 2 }, ["all"]), { a: 1, b: 2 });
|
||||
});
|
||||
});
|
||||
|
||||
describe("errorToJson()", function() {
|
||||
it("uses the class name of the error", function() {
|
||||
assert.deepEqual(errorToJson(new lib.NotFoundError("gone")), { error: "NotFoundError", message: "gone" });
|
||||
assert.deepEqual(errorToJson("text"), { error: "Error", message: "text" });
|
||||
});
|
||||
});
|
||||
|
||||
describe("class CommandOutput", function() {
|
||||
it("calls the human formatter in human mode", function() {
|
||||
const output = new CommandOutput("human");
|
||||
const human = () => console.log("human"); // eslint-disable-line no-console
|
||||
assert.deepEqual(captureLog(() => output.result({ a: 1 }, human)), ["human"]);
|
||||
assert.deepEqual(captureLog(() => output.finish()), []);
|
||||
});
|
||||
it("prints a success line in human mode for commands without a result", function() {
|
||||
assert.deepEqual(captureLog(() => new CommandOutput("human").finish()), ["Command ran successfully"]);
|
||||
});
|
||||
it("prints one line of JSON per result in json mode", function() {
|
||||
const output = new CommandOutput("json");
|
||||
const lines = captureLog(() => {
|
||||
output.result({ a: new Set([1]) }, () => assert.fail("called human formatter"));
|
||||
output.table([{ b: 2 }]);
|
||||
output.finish();
|
||||
});
|
||||
assert.deepEqual(lines, ['{"a":[1]}', '[{"b":2}]']);
|
||||
});
|
||||
it("prints the toJSON format in wire mode", function() {
|
||||
const output = new CommandOutput("wire");
|
||||
const role = new lib.Role(1, "name", "desc", new Set(["core.admin"]));
|
||||
const lines = captureLog(() => output.result({ role, set: new Set([1]), map: new Map([["a", 2]]) }));
|
||||
assert.deepEqual(JSON.parse(lines[0]), { role: JSON.parse(JSON.stringify(role)), set: [1], map: { a: 2 } });
|
||||
});
|
||||
it("prints success for commands without a result", function() {
|
||||
assert.deepEqual(captureLog(() => new CommandOutput("json").finish()), ['{"success":true}']);
|
||||
const streaming = new CommandOutput("json");
|
||||
streaming.streamingLog = true;
|
||||
assert.deepEqual(captureLog(() => streaming.finish()), []);
|
||||
});
|
||||
it("prints errors as JSON", function() {
|
||||
const output = new CommandOutput("json");
|
||||
const lines = captureLog(() => {
|
||||
output.error(new lib.CommandError("failed"), () => assert.fail("called human formatter"));
|
||||
output.finish();
|
||||
});
|
||||
assert.deepEqual(lines, ['{"error":"CommandError","message":"failed"}']);
|
||||
});
|
||||
it("calls the human error reporter in human mode", function() {
|
||||
const output = new CommandOutput("human");
|
||||
const human = () => console.log("failed"); // eslint-disable-line no-console
|
||||
const lines = captureLog(() => {
|
||||
output.error(new lib.CommandError("failed"), human);
|
||||
output.finish();
|
||||
});
|
||||
assert.deepEqual(lines, ["failed"]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,88 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { modCommands } from "@clusterio/ctl/dist/node/src/commands_mod.js";
|
||||
import { modPackCommands } from "@clusterio/ctl/dist/node/src/commands_mod_pack.js";
|
||||
import { userCommands } from "@clusterio/ctl/dist/node/src/commands_user.js";
|
||||
import { CommandOutput } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
async function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
await fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
/** Mock ctl answering requests by their class */
|
||||
function mockCtl(responses) {
|
||||
return {
|
||||
output: new CommandOutput(),
|
||||
async send(message) {
|
||||
return responses.get(message.constructor)(message);
|
||||
},
|
||||
async sendTo(destination, message) {
|
||||
return this.send(message);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
describe("ctl/commands", function() {
|
||||
describe("mod show", function() {
|
||||
const show = modCommands.get("show");
|
||||
it("prints list fields one entry per line", async function() {
|
||||
const ctl = mockCtl(new Map([
|
||||
[lib.ModGetRequest, () => ({ name: "a_mod", dependencies: ["base", "? other"] })],
|
||||
]));
|
||||
const lines = await captureLog(() => show.run({ name: "a_mod", modVersion: "1.0.0" }, ctl));
|
||||
assert.deepEqual(lines, ["name: a_mod", "dependencies:", " base", " ? other"]);
|
||||
});
|
||||
it("rejects an invalid version", async function() {
|
||||
await assert.rejects(
|
||||
show.run({ name: "a_mod", modVersion: "latest" }, mockCtl(new Map())),
|
||||
new lib.CommandError("mod-version must match format digit.digit.digit"),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("mod-pack show", function() {
|
||||
it("marks missing mods and checksum mismatches and lists export assets", async function() {
|
||||
const modPack = lib.ModPack.fromJSON({ id: 7, name: "pack" });
|
||||
modPack.mods.set("gone", { name: "gone", enabled: true, version: "1.0.0" });
|
||||
modPack.mods.set("changed", { name: "changed", enabled: false, version: "1.0.0", sha1: "aaa" });
|
||||
modPack.exportManifest = { assets: { settings: "settings.json" } };
|
||||
const ctl = mockCtl(new Map([
|
||||
[lib.ModListRequest, () => [{ id: "changed_1.0.0", sha1: "bbb" }]],
|
||||
[lib.ModPackListRequest, () => [modPack]],
|
||||
[lib.ModPackGetRequest, () => modPack],
|
||||
]));
|
||||
const lines = await captureLog(() => modPackCommands.get("show").run({ modPack: "pack" }, ctl));
|
||||
assert(lines.includes(" ? gone 1.0.0"), lines.join("\n"));
|
||||
assert(lines.includes(" ! (disabled) changed 1.0.0 (aaa)"), lines.join("\n"));
|
||||
assert(lines.includes(" settings: settings.json"), lines.join("\n"));
|
||||
});
|
||||
});
|
||||
|
||||
describe("user show", function() {
|
||||
const show = userCommands.get("show");
|
||||
it("prints stats per instance", async function() {
|
||||
const stats = new lib.PlayerStats();
|
||||
stats.joinCount = 2;
|
||||
const user = new lib.UserDetails("alice");
|
||||
user.instanceStats = new Map([[1, stats], [2, stats]]);
|
||||
user.recalculatePlayerStats();
|
||||
const ctl = mockCtl(new Map([
|
||||
[lib.UserGetRequest, () => user],
|
||||
[lib.InstanceDetailsListRequest, () => [{ id: 1, name: "one" }]],
|
||||
]));
|
||||
const lines = await captureLog(() => show.run({ name: "alice", instanceStats: true }, ctl));
|
||||
assert(lines.includes("Instance one (1):"), lines.join("\n"));
|
||||
assert(lines.includes("Instance <deleted> (2):"), lines.join("\n"));
|
||||
assert(lines.some(line => /joinCount +\| 4/.test(line)), lines.join("\n"));
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,91 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { instanceCommands } from "@clusterio/ctl/dist/node/src/commands_instance.js";
|
||||
import { CommandOutput } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
async function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
await fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
describe("ctl/commands_instance", function() {
|
||||
let instances;
|
||||
let sentTo;
|
||||
const ctl = {
|
||||
output: new CommandOutput(),
|
||||
async send(message) {
|
||||
assert(message instanceof lib.InstanceDetailsListRequest);
|
||||
return instances;
|
||||
},
|
||||
async sendTo(destination, message) {
|
||||
sentTo.push([destination.instanceId, message.constructor.name]);
|
||||
if (destination.instanceId === 2) {
|
||||
throw new lib.CommandError("broken");
|
||||
}
|
||||
},
|
||||
};
|
||||
beforeEach(function() {
|
||||
sentTo = [];
|
||||
instances = [
|
||||
{ id: 1, name: "one", status: "stopped", excludeFromStartAll: false },
|
||||
{ id: 2, name: "two", status: "stopped", excludeFromStartAll: false },
|
||||
{ id: 3, name: "three", status: "stopped", excludeFromStartAll: true },
|
||||
{ id: 4, name: "four", status: "running", excludeFromStartAll: false },
|
||||
];
|
||||
});
|
||||
|
||||
describe("start-all", function() {
|
||||
const startAll = instanceCommands.get("start-all");
|
||||
it("starts stopped instances and reports each one", async function() {
|
||||
ctl.output = new CommandOutput("human");
|
||||
const lines = await captureLog(() => startAll.run({ force: false }, ctl));
|
||||
assert.deepEqual(sentTo, [[1, "InstanceStartRequest"], [2, "InstanceStartRequest"]]);
|
||||
assert(lines.includes("✓ Started one"), lines.join("\n"));
|
||||
assert(lines.some(line => line.startsWith("✗ Failed to start two")), lines.join("\n"));
|
||||
});
|
||||
it("prints an entry per instance in json mode", async function() {
|
||||
ctl.output = new CommandOutput("json");
|
||||
const lines = await captureLog(() => startAll.run({ force: true }, ctl));
|
||||
assert.deepEqual(JSON.parse(lines[0]), [
|
||||
{ id: 1, name: "one" },
|
||||
{ id: 2, name: "two", error: { error: "CommandError", message: "broken" } },
|
||||
{ id: 3, name: "three" },
|
||||
]);
|
||||
});
|
||||
it("reports when there is nothing to start", async function() {
|
||||
instances = [];
|
||||
ctl.output = new CommandOutput("human");
|
||||
assert.deepEqual(await captureLog(() => startAll.run({ force: false }, ctl)), ["No instances to start."]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("stop-all", function() {
|
||||
const stopAll = instanceCommands.get("stop-all");
|
||||
it("stops running instances and reports each one", async function() {
|
||||
instances[1].status = "running";
|
||||
ctl.output = new CommandOutput("human");
|
||||
const lines = await captureLog(() => stopAll.run({}, ctl));
|
||||
assert.deepEqual(sentTo, [[2, "InstanceStopRequest"], [4, "InstanceStopRequest"]]);
|
||||
assert(lines.includes("✓ Stopped four"), lines.join("\n"));
|
||||
assert(lines.some(line => line.startsWith("✗ Failed to stop two")), lines.join("\n"));
|
||||
});
|
||||
it("prints an entry per instance in json mode", async function() {
|
||||
ctl.output = new CommandOutput("json");
|
||||
const lines = await captureLog(() => stopAll.run({}, ctl));
|
||||
assert.deepEqual(JSON.parse(lines[0]), [{ id: 4, name: "four" }]);
|
||||
});
|
||||
it("reports when there is nothing to stop", async function() {
|
||||
instances = [];
|
||||
ctl.output = new CommandOutput("human");
|
||||
assert.deepEqual(await captureLog(() => stopAll.run({}, ctl)), ["No instances to stop."]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,56 @@
|
||||
import assert from "node:assert/strict";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { Ctl } from "@clusterio/ctl/dist/node/ctl.js";
|
||||
import { CommandOutput } from "@clusterio/ctl/dist/node/src/command_ops.js";
|
||||
|
||||
/** Run fn and return the lines it printed with console.log */
|
||||
async function captureLog(fn) {
|
||||
const lines = [];
|
||||
const originalLog = console.log; // eslint-disable-line no-console
|
||||
console.log = (...args) => lines.push(args.join(" ")); // eslint-disable-line no-console
|
||||
try {
|
||||
await fn();
|
||||
} finally {
|
||||
console.log = originalLog; // eslint-disable-line no-console
|
||||
}
|
||||
return lines;
|
||||
}
|
||||
|
||||
describe("ctl/ctl", function() {
|
||||
describe("class Ctl", function() {
|
||||
let ctl;
|
||||
beforeEach(function() {
|
||||
const connector = new lib.VirtualConnector(
|
||||
lib.Address.fromShorthand({ controlId: 1 }),
|
||||
lib.Address.fromShorthand("controller"),
|
||||
);
|
||||
ctl = new Ctl(connector, new lib.CtlConfig("control"));
|
||||
});
|
||||
|
||||
it("prints log events as JSON lines only when streaming the log", async function() {
|
||||
const info = { level: "info", message: "hello" };
|
||||
ctl.output = new CommandOutput("json");
|
||||
const logged = await captureLog(() => ctl.handleLogMessageEvent(new lib.LogMessageEvent({ ...info })));
|
||||
assert(logged.every(line => !line.startsWith("{")), "log event printed as a result");
|
||||
ctl.output.streamingLog = true;
|
||||
assert.deepEqual(
|
||||
await captureLog(() => ctl.handleLogMessageEvent(new lib.LogMessageEvent({ ...info, timestamp: 1 }))),
|
||||
['{"level":"info","message":"hello","timestamp":1}'],
|
||||
);
|
||||
});
|
||||
it("logs log events in human mode", async function() {
|
||||
ctl.output.streamingLog = true;
|
||||
const info = { level: "verbose", message: "hello" };
|
||||
assert.deepEqual(await captureLog(() => ctl.handleLogMessageEvent(new lib.LogMessageEvent(info))), []);
|
||||
});
|
||||
it("prints debug WebSocket messages", async function() {
|
||||
const event = new lib.DebugWsMessageEvent("in", "content");
|
||||
assert.deepEqual(await captureLog(() => ctl.handleDebugWsMessageEvent(event)), ["WS in content"]);
|
||||
ctl.output = new CommandOutput("json");
|
||||
assert.deepEqual(
|
||||
await captureLog(() => ctl.handleDebugWsMessageEvent(event)),
|
||||
['{"direction":"in","content":"content"}'],
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -2064,6 +2064,9 @@ describe("Integration of Clusterio", function() {
|
||||
const roundtrip = lib.ModPack.fromModPackString(result.stdout.trim());
|
||||
roundtrip.id = reference.id;
|
||||
assert.deepEqual(roundtrip, reference);
|
||||
const shown = await execCtlOutput("mod-pack show imported-pack");
|
||||
assert.match(shown, /empty_mod 1\.0\.0/);
|
||||
assert.match(shown, /MyDouble: 12\.25/);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -2119,6 +2122,7 @@ describe("Integration of Clusterio", function() {
|
||||
|
||||
describe("mod show", function() {
|
||||
it("gives details of a mod", async function() {
|
||||
assert.match(await execCtlOutput("mod show empty_mod 1.0.0"), /name: empty_mod/);
|
||||
let result = await execCtlProcess("mod show empty_mod 1.0.0");
|
||||
let hash = await lib.hashFile(path.join("temp", "test", "mods", "empty_mod_1.0.0.zip"));
|
||||
let stat = await fs.stat(path.join("temp", "test", "mods", "empty_mod_1.0.0.zip"));
|
||||
@@ -2317,6 +2321,126 @@ describe("Integration of Clusterio", function() {
|
||||
});
|
||||
});
|
||||
|
||||
describe("config edit", function() {
|
||||
/** Write an editor script that replaces the edited file with content */
|
||||
async function writeEditor(content) {
|
||||
const file = path.resolve("temp", "test", "editor.sh");
|
||||
await fs.writeFile(file, `#!/bin/sh\ncat > "$1" <<'EOF'\n${content}\nEOF\n`, { mode: 0o755 });
|
||||
return file;
|
||||
}
|
||||
before(function() {
|
||||
if (process.platform === "win32") {
|
||||
this.skip();
|
||||
}
|
||||
});
|
||||
|
||||
it("sets controller config fields and reports failed ones", async function() {
|
||||
const config = await getControl().send(new lib.ControllerConfigGetRequest());
|
||||
const name = config["controller.name"];
|
||||
const editor = await writeEditor("controller.name = Edited-Cluster\ncontroller.no_such_field = 1");
|
||||
await execCtl(`controller config edit ${editor}`);
|
||||
const edited = await getControl().send(new lib.ControllerConfigGetRequest());
|
||||
assert.equal(edited["controller.name"], "Edited-Cluster");
|
||||
await execCtl(`controller config set controller.name ${name}`);
|
||||
});
|
||||
it("sets host config fields and reports failed ones", async function() {
|
||||
const config = await getControl().sendTo({ hostId }, new lib.HostConfigGetRequest());
|
||||
const editor = await writeEditor(`host.name = ${config["host.name"]}\nhost.no_such_field = 1`);
|
||||
await execCtl(`host config edit ${hostId} ${editor}`);
|
||||
});
|
||||
it("sets instance config fields and reports failed ones", async function() {
|
||||
const { id } = JSON.parse(await execCtlOutput("--output json instance create config-edit"));
|
||||
try {
|
||||
const editor = await writeEditor("instance.auto_start = true\ninstance.no_such_field = 1");
|
||||
await execCtl(`instance config edit ${id} ${editor}`);
|
||||
const config = await getControl().send(new lib.InstanceConfigGetRequest(id));
|
||||
assert.equal(config["instance.auto_start"], true);
|
||||
} finally {
|
||||
await execCtl(`instance delete ${id}`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("--output json", function() {
|
||||
it("prints lists as an array of objects", async function() {
|
||||
const roles = JSON.parse(await execCtlOutput("--output json role list"));
|
||||
assert.deepEqual(roles.find(role => role.id === 0).permissions, ["core.admin"]);
|
||||
});
|
||||
it("prints single results as an object", async function() {
|
||||
const { id } = JSON.parse(await execCtlOutput("--output json role create json-role"));
|
||||
const roles = await getControl().send(new lib.RoleListRequest());
|
||||
assert.equal(roles.find(role => role.id === id)?.name, "json-role");
|
||||
assert.equal(await execCtlOutput(`--output json role delete ${id}`), '{"success":true}');
|
||||
});
|
||||
it("prints the toJSON format in wire mode", async function() {
|
||||
const [jsonUser] = JSON.parse(await execCtlOutput("--output json user list"));
|
||||
const [wireUser] = JSON.parse(await execCtlOutput("--output wire user list"));
|
||||
assert("roleIds" in jsonUser);
|
||||
assert(!("roleIds" in wireUser));
|
||||
assert.equal(wireUser.name, jsonUser.name);
|
||||
});
|
||||
it("prints a success line for commands without a result", async function() {
|
||||
const { id } = JSON.parse(await execCtlOutput("--output json role create human-role"));
|
||||
assert.equal(await execCtlOutput(`role delete ${id}`), "Command ran successfully");
|
||||
});
|
||||
it("prints whole objects for lists that hide fields in human mode", async function() {
|
||||
const [mod] = JSON.parse(await execCtlOutput("--output json mod list"));
|
||||
assert("sha1" in mod);
|
||||
const [wireMod] = JSON.parse(await execCtlOutput("--output wire mod list"));
|
||||
assert("factorio_version" in wireMod);
|
||||
const [modPack] = JSON.parse(await execCtlOutput("--output wire mod-pack list"));
|
||||
assert("mods" in modPack);
|
||||
const user = JSON.parse(await execCtlOutput("--output wire user show test --instance-stats"));
|
||||
assert.equal(user.name, "test");
|
||||
});
|
||||
it("prints the user and instance stats in human mode", async function() {
|
||||
const output = await execCtlOutput("user show test --instance-stats");
|
||||
assert.match(output, /name +\| test/);
|
||||
});
|
||||
it("prints the result of human mode commands with more options", async function() {
|
||||
assert.match(await execCtlOutput("user list --stats --attributes"), /isAdmin/);
|
||||
const exchange = JSON.parse(await execCtlOutput(
|
||||
`--output json debug parse-exchange-string ${testStrings.default.replace(/\s/g, "")}`
|
||||
));
|
||||
assert.equal(typeof exchange, "object");
|
||||
});
|
||||
it("follows the log without a final result", async function() {
|
||||
try {
|
||||
assert.equal(await execCtlOutput("--output json log follow --controller"), "");
|
||||
} finally {
|
||||
getControl().keepOpen = false;
|
||||
}
|
||||
});
|
||||
it("prints log queries in human mode", async function() {
|
||||
assert.notEqual(await execCtlOutput("log query --controller --limit 1"), "");
|
||||
});
|
||||
it("prints pending host requests in human mode", async function() {
|
||||
assert.notEqual(await execCtlOutput("host pending"), "");
|
||||
});
|
||||
it("prints log queries as an array", async function() {
|
||||
const log = JSON.parse(await execCtlOutput("--output json log query --controller --limit 1"));
|
||||
assert.equal(log.length, 1);
|
||||
assert.equal(typeof log[0].message, "string");
|
||||
});
|
||||
it("prints errors as JSON with a non-zero exit code", async function() {
|
||||
await assert.rejects(
|
||||
execCtlProcess("--output json instance stop no-such-instance"),
|
||||
err => {
|
||||
assert.equal(err.code, 1);
|
||||
assert.deepEqual(
|
||||
JSON.parse(err.stdout),
|
||||
{ error: "CommandError", message: "No instance named no-such-instance" },
|
||||
);
|
||||
return true;
|
||||
},
|
||||
);
|
||||
await assert.rejects(
|
||||
execCtlProcess("--output json user set-admin no-such-user"),
|
||||
err => JSON.parse(err.stdout).error === "NotFoundError",
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("user list", function() {
|
||||
it("prints roles and instances as lists", async function() {
|
||||
const output = await execCtlOutput("user list");
|
||||
|
||||
@@ -10,7 +10,7 @@ import events from "node:events";
|
||||
import * as lib from "@clusterio/lib";
|
||||
import { LineSplitter, logger } from "@clusterio/lib";
|
||||
|
||||
import { selectTargetCommand, initialize as initializeCtl } from "@clusterio/ctl";
|
||||
import { runCommand, initialize as initializeCtl } from "@clusterio/ctl";
|
||||
import { _listFactorioVersions } from "@clusterio/host/dist/node/src/server.js";
|
||||
import { pairHost } from "@clusterio/host";
|
||||
|
||||
@@ -242,8 +242,7 @@ export async function execCtl(command) {
|
||||
}
|
||||
|
||||
control.config = initArgs.ctlConfig;
|
||||
const targetCommand = selectTargetCommand(initArgs.args, initArgs.rootCommands);
|
||||
await targetCommand.run(initArgs.args, control);
|
||||
await runCommand(initArgs.args, initArgs.rootCommands, control);
|
||||
} finally {
|
||||
process.chdir("../..");
|
||||
inExecCtl = false;
|
||||
|
||||
Reference in new issue
Block a user