diff --git a/docs/managing-a-cluster.md b/docs/managing-a-cluster.md index c973228c..2cd6508b 100644 --- a/docs/managing-a-cluster.md +++ b/docs/managing-a-cluster.md @@ -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 ` on the controller, which creates the necessary `config-ctl.json` for managing the cluster as the given user. +## Output Format + + ctl> --output json + +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": "", "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 diff --git a/docs/writing-plugins.md b/docs/writing-plugins.md index 3f1d300a..7318a864 100644 --- a/docs/writing-plugins.md +++ b/docs/writing-plugins.md @@ -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": "", "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 diff --git a/packages/ctl/README.md b/packages/ctl/README.md index 4206032f..cf9fc7be 100644 --- a/packages/ctl/README.md +++ b/packages/ctl/README.md @@ -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 ` 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 ` diff --git a/packages/ctl/ctl.ts b/packages/ctl/ctl.ts index d6456cf5..a737b6ef 100755 --- a/packages/ctl/ctl.ts +++ b/packages/ctl/ctl.ts @@ -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; }); } diff --git a/packages/ctl/index.ts b/packages/ctl/index.ts index fe5bb9da..e4e69703 100644 --- a/packages/ctl/index.ts +++ b/packages/ctl/index.ts @@ -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) { diff --git a/packages/ctl/src/command_ops.ts b/packages/ctl/src/command_ops.ts index 88e9a7e3..54c9373f 100644 --- a/packages/ctl/src/command_ops.ts +++ b/packages/ctl/src/command_ops.ts @@ -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(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")); + } + } +} diff --git a/packages/ctl/src/commands_controller.ts b/packages/ctl/src/commands_controller.ts index 781e1503..d92fb47a 100644 --- a/packages/ctl/src/commands_controller.ts +++ b/packages/ctl/src/commands_controller.ts @@ -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"); }, })); diff --git a/packages/ctl/src/commands_debug.ts b/packages/ctl/src/commands_debug.ts index c3dce44e..4fca9c69 100644 --- a/packages/ctl/src/commands_debug.ts +++ b/packages/ctl/src/commands_debug.ts @@ -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))); }, })); diff --git a/packages/ctl/src/commands_host.ts b/packages/ctl/src/commands_host.ts index 041a81a8..8d3adeb7 100644 --- a/packages/ctl/src/commands_host.ts +++ b/packages/ctl/src/commands_host.ts @@ -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); diff --git a/packages/ctl/src/commands_instance.ts b/packages/ctl/src/commands_instance.ts index ff57d1af..a88b3b42 100644 --- a/packages/ctl/src/commands_instance.ts +++ b/packages/ctl/src/commands_instance.ts @@ -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 ?? {} : {}; - 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)); }, })); diff --git a/packages/ctl/src/commands_log.ts b/packages/ctl/src/commands_log.ts index 967f2393..312a79c8 100644 --- a/packages/ctl/src/commands_log.ts +++ b/packages/ctl/src/commands_log.ts @@ -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); - } }, })); diff --git a/packages/ctl/src/commands_mod.ts b/packages/ctl/src/commands_mod.ts index 3eda61d0..f81b9abf 100644 --- a/packages/ctl/src/commands_mod.ts +++ b/packages/ctl/src/commands_mod.ts @@ -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}`)); }, })); diff --git a/packages/ctl/src/commands_mod_pack.ts b/packages/ctl/src/commands_mod_pack.ts index 690b6e9e..6f71c0a2 100644 --- a/packages/ctl/src/commands_mod_pack.ts +++ b/packages/ctl/src/commands_mod_pack.ts @@ -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) { + 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 ", "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)); }, })); diff --git a/packages/ctl/src/commands_note.ts b/packages/ctl/src/commands_note.ts index b31ea531..abe8d64a 100644 --- a/packages/ctl/src/commands_note.ts +++ b/packages/ctl/src/commands_note.ts @@ -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)); }, })); diff --git a/packages/ctl/src/commands_permission.ts b/packages/ctl/src/commands_permission.ts index 6e6dc691..d9b79d2d 100644 --- a/packages/ctl/src/commands_permission.ts +++ b/packages/ctl/src/commands_permission.ts @@ -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())); }, })); diff --git a/packages/ctl/src/commands_role.ts b/packages/ctl/src/commands_role.ts index 80893d8f..d957051e 100644 --- a/packages/ctl/src/commands_role.ts +++ b/packages/ctl/src/commands_role.ts @@ -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}`)); }, })); diff --git a/packages/ctl/src/commands_user.ts b/packages/ctl/src/commands_user.ts index 14235c99..525a45d7 100644 --- a/packages/ctl/src/commands_user.ts +++ b/packages/ctl/src/commands_user.ts @@ -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 ", "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 ""; + 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 ?? ""; 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}`), + ); }, })); diff --git a/packages/ctl/src/config_ops.ts b/packages/ctl/src/config_ops.ts index 6a876cd4..45c6c831 100644 --- a/packages/ctl/src/config_ops.ts +++ b/packages/ctl/src/config_ops.ts @@ -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.`); + } + }); +} diff --git a/plugins/player_sync/ctl.ts b/plugins/player_sync/ctl.ts index c0028faf..8932d953 100644 --- a/plugins/player_sync/ctl.ts +++ b/plugins/player_sync/ctl.ts @@ -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}`), + ); }, })); diff --git a/plugins/player_sync/test/plugin.js b/plugins/player_sync/test/plugin.js index 7284404d..49a64735 100644 --- a/plugins/player_sync/test/plugin.js +++ b/plugins/player_sync/test/plugin.js @@ -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" }); diff --git a/test/ctl/command_ops.test.js b/test/ctl/command_ops.test.js new file mode 100644 index 00000000..6814ceb9 --- /dev/null +++ b/test/ctl/command_ops.test.js @@ -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"]); + }); + }); +}); diff --git a/test/ctl/commands.test.js b/test/ctl/commands.test.js new file mode 100644 index 00000000..86bdf56b --- /dev/null +++ b/test/ctl/commands.test.js @@ -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 (2):"), lines.join("\n")); + assert(lines.some(line => /joinCount +\| 4/.test(line)), lines.join("\n")); + }); + }); +}); diff --git a/test/ctl/commands_instance.test.js b/test/ctl/commands_instance.test.js new file mode 100644 index 00000000..040503e3 --- /dev/null +++ b/test/ctl/commands_instance.test.js @@ -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."]); + }); + }); +}); diff --git a/test/ctl/ctl.test.js b/test/ctl/ctl.test.js new file mode 100644 index 00000000..4e2d9b56 --- /dev/null +++ b/test/ctl/ctl.test.js @@ -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"}'], + ); + }); + }); +}); diff --git a/test/integration/clusterio.js b/test/integration/clusterio.js index 5ac99976..1c68a5d2 100644 --- a/test/integration/clusterio.js +++ b/test/integration/clusterio.js @@ -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"); diff --git a/test/integration/index.js b/test/integration/index.js index 2f3fbadd..c6aa7e15 100644 --- a/test/integration/index.js +++ b/test/integration/index.js @@ -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;