Restructre clusterctl cli interface

Turn the flat list of commands into a hierarchy of commands, converting
most required parameters into positional parameters and add plugin
loading support for clusterctl.
This commit is contained in:
Hornwitser committed 2020-08-18 18:52:11 +02:00
1 parent 9b870fde64
commit da1cbc16f7
10 files changed
+783 -428

No files matched your search

+189 -306
View File
@@ -14,6 +14,8 @@ const events = require("events");
const link = require("lib/link");
const errors = require("lib/errors");
const config = require("lib/config");
const plugin = require("lib/plugin");
const command = require("lib/command");
/**
@@ -54,141 +56,17 @@ function formatOutputColored(output) {
return time + info + output.message;
}
/**
* Represents a command that can be runned by clusterctl
*/
class Command {
constructor({ definition, handler }) {
this.name = definition[0];
this._definition = definition;
this._handler = handler;
}
register(yargs) {
yargs.command(...this._definition);
}
async run(args, control) {
await this._handler(args, control);
}
}
/**
* Resolve a string to an instance ID
*
* Resolves a string with either an instance name or an id into an integer
* with the instance ID.
*
* @param {module:lib/link.Link} client - link to master server to query instance on.
* @param {string} instanceName - string with name or id of instance.
* @returns {number} instance ID.
* @private
*/
async function resolveInstance(client, instanceName) {
let instanceId;
if (/^-?\d+$/.test(instanceName)) {
instanceId = parseInt(instanceName, 10);
} else {
let response = await link.messages.listInstances.send(client);
for (let instance of response.list) {
if (instance.name === instanceName) {
instanceId = instance.id;
break;
}
}
if (instanceId === undefined) {
throw new errors.CommandError(`No instance named ${instanceName}`);
}
}
return instanceId;
}
/**
* Resolve a string into a slave ID
*
* Resolves a string with either an slave name or an id into an integer with
* the slave ID.
*
* @param {module:lib/link.Link} client - link to master server to query slave on.
* @param {string} slaveName - string with name or id of slave.
* @returns {number} slave ID.
* @private
*/
async function resolveSlave(client, slaveName) {
let slaveId;
if (/^-?\d+$/.test(slaveName)) {
slaveId = parseInt(slaveName, 10);
} else {
let response = await link.messages.listSlaves.send(client);
for (let slave of response.list) {
if (slave.name === slaveName) {
slaveId = slave.id;
break;
}
}
if (slaveId === undefined) {
throw new errors.CommandError(`No slave named ${slaveName}`);
}
}
return slaveId;
}
/**
* Resolve a string into a role object
*
* Resolves a string with either a role name or an id into an object
* representing the role.
*
* @param {module:lib/link.Link} client - link to master server to query role on.
* @param {string} roleName - string with name or id of role.
* @returns {Object} Role info.
* @private
*/
async function resolveRole(client, roleName) {
let response = await link.messages.listRoles.send(client);
let resolvedRole;
if (/^-?\d+$/.test(roleName)) {
let roleId = parseInt(roleName, 10);
for (let role of response.list) {
if (role.id === roleId) {
resolvedRole = role;
break;
}
}
} else {
for (let role of response.list) {
if (role.name === roleName) {
resolvedRole = role;
break;
}
}
}
if (!resolvedRole) {
throw new errors.CommandError(`No role named ${roleName}`);
}
return resolvedRole;
}
let commands = [];
commands.push(new Command({
definition: ["list-slaves", "List slaves connected to the master"],
const slaveCommands = new command.CommandTree({ name: "slave", description: "Slave management" });
slaveCommands.add(new command.Command({
definition: [["list", "l"], "List slaves connected to the master"],
handler: async function(args, control) {
let response = await link.messages.listSlaves.send(control);
console.log(asTable(response.list));
},
}));
commands.push(new Command({
definition: ["generate-slave-token", "Generate token for a slave", (yargs) => {
slaveCommands.add(new command.Command({
definition: ["generate-token", "Generate token for a slave", (yargs) => {
yargs.option("id", { type: "number", nargs: 1, describe: "Slave id", demandOption: true });
}],
handler: async function(args, control) {
@@ -197,8 +75,8 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["create-slave-config", "Create slave config", (yargs) => {
slaveCommands.add(new command.Command({
definition: ["create-config", "Create slave config", (yargs) => {
yargs.option("id", { type: "number", nargs: 1, describe: "Slave id", default: null });
yargs.option("name", { type: "string", nargs: 1, describe: "Slave name", default: null });
yargs.option("generate-token", {
@@ -231,34 +109,23 @@ commands.push(new Command({
}));
commands.push(new Command({
definition: ["list-instances", "List instances known to the master"],
const instanceCommands = new command.CommandTree({
name: "instance", alias: ["i"], description: "Instance management",
});
instanceCommands.add(new command.Command({
definition: [["list", "l"], "List instances known to the master"],
handler: async function(args, control) {
let response = await link.messages.listInstances.send(control);
console.log(asTable(response.list));
},
}));
commands.push(new Command({
definition: ["create-instance", "Create an instance", (yargs) => {
instanceCommands.add(new command.Command({
definition: ["create <name>", "Create an instance", (yargs) => {
// XXX TODO: set any specific options?
yargs.option("name", {
type: "string",
nargs: 1,
describe: "Instance name",
group: "Instance Config:",
});
yargs.option("id", {
type: "number",
nargs: 1,
describe: "Instance ID",
group: "Instance Config:",
});
yargs.option("base", {
type: "boolean",
nargs: 0,
describe: "Specify this is a base config",
group: "Instance Config:",
yargs.positional("name", { describe: "Instance name", type: "string" });
yargs.options({
"id": { type: "number", nargs: 1, describe: "Instance id" },
});
}],
handler: async function(args, control) {
@@ -267,22 +134,21 @@ commands.push(new Command({
if (args.id) {
instanceConfig.set("instance.id", args.id);
}
if (args.name) {
instanceConfig.set("instance.name", args.name);
}
instanceConfig.set("instance.name", args.name);
let serialized_config = instanceConfig.serialize();
let response = await link.messages.createInstance.send(control, { serialized_config });
},
}));
commands.push(new Command({
definition: ["list-instance-config", "List configuration for an instance", (yargs) => {
yargs.option({
"instance": { describe: "Instance to list config for", nargs: 1, type: "string", demandOption: true },
});
const instanceConfigCommands = new command.CommandTree({
name: "config", alias: ["c"], description: "Instance config management",
});
instanceConfigCommands.add(new command.Command({
definition: ["list <instance>", "List configuration for an instance", (yargs) => {
yargs.positional("instance", { describe: "Instance to list config for", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
let response = await link.messages.getInstanceConfig.send(control, { instance_id: instanceId });
for (let group of response.serialized_config.groups) {
@@ -293,16 +159,14 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["set-instance-config", "Set field in instance config", (yargs) => {
yargs.option({
"instance": { describe: "Instance to set config on", nargs: 1, type: "string", demandOption: true },
"field": { describe: "Field to set", nargs: 1, type: "string", demandOption: true },
"value": { describe: "Value to set", nargs: 1, type: "string", demandOption: true },
});
instanceConfigCommands.add(new command.Command({
definition: ["set <instance> <field> <value>", "Set field in instance config", (yargs) => {
yargs.positional("instance", { describe: "Instance to set config on", type: "string" });
yargs.positional("field", { describe: "Field to set", type: "string" });
yargs.positional("value", { describe: "Value to set", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceConfigField.send(control, {
instance_id: instanceId,
field: args.field,
@@ -311,17 +175,15 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["set-instance-config-prop", "Set property of field in instance config", (yargs) => {
yargs.option({
"instance": { describe: "Instance to set config on", nargs: 1, type: "string", demandOption: true },
"field": { describe: "Field to set", nargs: 1, type: "string", demandOption: true },
"prop": { describe: "Property to set", nargs: 1, type: "string", demandOption: true },
"value": { describe: "JSON parsed value to set", nargs: 1, type: "string", demandOption: true },
});
instanceConfigCommands.add(new command.Command({
definition: ["set-prop <instance> <field> <prop> <value>", "Set property of field in instance config", (yargs) => {
yargs.positional("instance", { describe: "Instance to set config on", type: "string" });
yargs.positional("field", { describe: "Field to set", type: "string" });
yargs.positional("prop", { describe: "Property to set", type: "string" });
yargs.positional("value", { describe: "JSON parsed value to set", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceConfigProp.send(control, {
instance_id: instanceId,
field: args.field,
@@ -330,17 +192,16 @@ commands.push(new Command({
});
},
}));
instanceCommands.add(instanceConfigCommands);
commands.push(new Command({
definition: ["assign-instance", "Assign instance to a slave", (yargs) => {
yargs.options({
"instance": { describe: "Instance to assign", nargs: 1, type: "string", demandOption: true },
"slave": { describe: "Slave to assign to", nargs: 1, type: "string", demandOption: true },
});
instanceCommands.add(new command.Command({
definition: ["assign <instance> <slave>", "Assign instance to a slave", (yargs) => {
yargs.positional("instance", { describe: "Instance to assign", type: "string" });
yargs.positional("slave", { describe: "Slave to assign to", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let slaveId = await resolveSlave(control, args.slave);
let instanceId = await command.resolveInstance(control, args.instance);
let slaveId = await command.resolveSlave(control, args.slave);
await link.messages.assignInstanceCommand.send(control, {
instance_id: instanceId,
slave_id: slaveId,
@@ -348,14 +209,12 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["create-save", "Create a new save on an instance", (yargs) => {
yargs.options({
"instance": { describe: "Instance to create on", nargs: 1, type: "string", demandOption: true },
});
instanceCommands.add(new command.Command({
definition: ["create-save <instance>", "Create a new save on an instance", (yargs) => {
yargs.positional("instance", { describe: "Instance to create on", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceOutputSubscriptions.send(control, { instance_ids: [instanceId] });
let response = await link.messages.createSave.send(control, {
instance_id: instanceId,
@@ -363,14 +222,12 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["export-data", "Export item icons and locale from instance", (yargs) => {
yargs.options({
"instance": { describe: "Instance to export from", nargs: 1, type: "string", demandOption: true },
});
instanceCommands.add(new command.Command({
definition: ["export-data <instance>", "Export item icons and locale from instance", (yargs) => {
yargs.positional("instance", { describe: "Instance to export from", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceOutputSubscriptions.send(control, { instance_ids: [instanceId] });
let response = await link.messages.exportData.send(control, {
instance_id: instanceId,
@@ -378,16 +235,16 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["start-instance", "Start instance", (yargs) => {
instanceCommands.add(new command.Command({
definition: ["start <instance>", "Start instance", (yargs) => {
yargs.positional("instance", { describe: "Instance to start", type: "string" });
yargs.options({
"instance": { describe: "Instance to start", nargs: 1, type: "string", demandOption: true },
"save": { describe: "Save load, defaults to latest", nargs: 1, type: "string" },
"keep-open": { describe: "Keep console open", nargs: 0, type: "boolean", default: false },
});
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceOutputSubscriptions.send(control, { instance_ids: [instanceId] });
let response = await link.messages.startInstance.send(control, {
instance_id: instanceId,
@@ -396,16 +253,16 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["load-scenario", "Start instance by loading a scenario", (yargs) => {
instanceCommands.add(new command.Command({
definition: ["load-scenario <instance> <scenario>", "Start instance by loading a scenario", (yargs) => {
yargs.positional("instance", { describe: "Instance to start", type: "string" });
yargs.positional("scenario", { describe: "Scenario to load", type: "string" });
yargs.options({
"instance": { describe: "Instance to start", nargs: 1, type: "string", demandOption: true },
"scenario": { describe: "Scenario to load", nargs: 1, type: "string" },
"keep-open": { describe: "Keep console open", nargs: 0, type: "boolean", default: false },
});
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceOutputSubscriptions.send(control, { instance_ids: [instanceId] });
let response = await link.messages.loadScenario.send(control, {
instance_id: instanceId,
@@ -414,14 +271,12 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["stop-instance", "Stop instance", (yargs) => {
yargs.options({
"instance": { describe: "Instance to stop", nargs: 1, type: "string", demandOption: true },
});
instanceCommands.add(new command.Command({
definition: ["stop <instance>", "Stop instance", (yargs) => {
yargs.positional("instance", { describe: "Instance to stop", type: "string" });
}],
handler: async function(args, control) {
let instanceId = await resolveInstance(control, args.instance);
let instanceId = await command.resolveInstance(control, args.instance);
await link.messages.setInstanceOutputSubscriptions.send(control, { instance_ids: [instanceId] });
let response = await link.messages.stopInstance.send(control, {
instance_id: instanceId,
@@ -429,29 +284,25 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["delete-instance", "Delete instance", (yargs) => {
yargs.options({
"instance": { describe: "Instance to delete", nargs: 1, type: "string", demandOption: true },
});
instanceCommands.add(new command.Command({
definition: ["delete <instance>", "Delete instance", (yargs) => {
yargs.positional("instance", { describe: "Instance to delete", type: "string" });
}],
handler: async function(args, control) {
let response = await link.messages.deleteInstance.send(control, {
instance_id: await resolveInstance(control, args.instance),
instance_id: await command.resolveInstance(control, args.instance),
});
},
}));
commands.push(new Command({
definition: ["send-rcon", "Send RCON command", (yargs) => {
yargs.options({
"instance": { describe: "Instance to sent to", nargs: 1, type: "string", demandOption: true },
"command": { describe: "command to send", nargs: 1, type: "string", demandOption: true },
});
instanceCommands.add(new command.Command({
definition: ["send-rcon <instance> <command>", "Send RCON command", (yargs) => {
yargs.positional("instance", { describe: "Instance to send to", type: "string" });
yargs.positional("command", { describe: "command to send", type: "string" });
}],
handler: async function(args, control) {
let response = await link.messages.sendRcon.send(control, {
instance_id: await resolveInstance(control, args.instance),
instance_id: await command.resolveInstance(control, args.instance),
command: args.command,
});
@@ -460,26 +311,29 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["list-permissions", "List permissions in the cluster"],
const permissionCommands = new command.CommandTree({ name: "permission", description: "Permission inspection" });
permissionCommands.add(new command.Command({
definition: [["list", "l"], "List permissions in the cluster"],
handler: async function(args, control) {
let response = await link.messages.listPermissions.send(control);
console.log(asTable(response.list));
},
}));
commands.push(new Command({
definition: ["list-roles", "List roles in the cluster"],
const roleCommands = new command.CommandTree({ name: "role", description: "Role management" });
roleCommands.add(new command.Command({
definition: [["list", "l"], "List roles in the cluster"],
handler: async function(args, control) {
let response = await link.messages.listRoles.send(control);
console.log(asTable(response.list));
},
}));
commands.push(new Command({
definition: ["create-role", "Create a new role", (yargs) => {
roleCommands.add(new command.Command({
definition: ["create <name>", "Create a new role", (yargs) => {
yargs.positional("name", { describe: "Name of role to create", type: "string" });
yargs.options({
"name": { describe: "Name of role to create", nargs: 1, type: "string", demandOption: true },
"description": { describe: "Description for role", nargs: 1, type: "string", default: "" },
"permissions": { describe: "Permissions role grants", nargs: 1, array: true, type: "string", default: [] },
});
@@ -494,10 +348,10 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["edit-role", "Edit existing role", (yargs) => {
roleCommands.add(new command.Command({
definition: ["edit <role>", "Edit existing role", (yargs) => {
yargs.positional("role", { describe: "Role to edit", type: "string" });
yargs.options({
"role": { describe: "Role to edit", nargs: 1, type: "string", demandOption: true },
"name": { describe: "New name for role", nargs: 1, type: "string" },
"description": { describe: "New description for role", nargs: 1, type: "string" },
"permissions": { describe: "New permissions for role", array: true, type: "string" },
@@ -505,7 +359,7 @@ commands.push(new Command({
});
}],
handler: async function(args, control) {
let role = await resolveRole(control, args.role);
let role = await command.retrieveRole(control, args.role);
if (args.name !== undefined) {
role.name = args.name;
@@ -524,44 +378,39 @@ commands.push(new Command({
},
}));
commands.push(new Command({
definition: ["delete-role", "Delete role", (yargs) => {
yargs.options({
"role": { describe: "Role to delete", nargs: 1, type: "string", demandOption: true },
});
roleCommands.add(new command.Command({
definition: ["delete <role>", "Delete role", (yargs) => {
yargs.positional("role", { describe: "Role to delete", type: "string" });
}],
handler: async function(args, control) {
let role = await resolveRole(control, args.role);
let role = await command.retrieveRole(control, args.role);
await link.messages.deleteRole.send(control, { id: role.id });
},
}));
commands.push(new Command({
definition: ["list-users", "List user in the cluster"],
const userCommands = new command.CommandTree({ name: "user", alias: ["u"], description: "User management" });
userCommands.add(new command.Command({
definition: [["list", "l"], "List user in the cluster"],
handler: async function(args, control) {
let response = await link.messages.listUsers.send(control);
console.log(asTable(response.list));
},
}));
commands.push(new Command({
definition: ["create-user", "Create a user", (yargs) => {
yargs.options({
"name": { describe: "Name of user to create", nargs: 1, type: "string", demandOption: true },
});
userCommands.add(new command.Command({
definition: ["create <name>", "Create a user", (yargs) => {
yargs.positional("name", { describe: "Name of user to create", type: "string" });
}],
handler: async function(args, control) {
await link.messages.createUser.send(control, { name: args.name });
},
}));
commands.push(new Command({
definition: ["edit-user-roles", "Edit user roles", (yargs) => {
yargs.options({
"name": { describe: "Name of user to change roles for", nargs: 1, type: "string", demandOption: true },
"roles": { describe: "roles to assign", array: true, type: "string", demandOption: true },
});
userCommands.add(new command.Command({
definition: ["set-roles <user> [roles...]", "Replace user roles", (yargs) => {
yargs.positional("user", { describe: "Name of user to change roles for", type: "string" });
yargs.positional("roles", { describe: "roles to assign", type: "string" });
}],
handler: async function(args, control) {
let response = await link.messages.listRoles.send(control);
@@ -588,32 +437,28 @@ commands.push(new Command({
}
}
await link.messages.updateUserRoles.send(control, { name: args.name, roles: resolvedRoles });
await link.messages.updateUserRoles.send(control, { name: args.user, roles: resolvedRoles });
},
}));
commands.push(new Command({
definition: ["delete-user", "Delete user", (yargs) => {
yargs.options({
"name": { describe: "Name of user to delete", nargs: 1, type: "string", demandOption: true },
});
userCommands.add(new command.Command({
definition: ["delete <user>", "Delete user", (yargs) => {
yargs.positional("user", { describe: "Name of user to delete", type: "string" });
}],
handler: async function(args, control) {
await link.messages.deleteUser.send(control, { name: args.name });
await link.messages.deleteUser.send(control, { name: args.user });
},
}));
commands.push(new Command({
definition: ["debug-dump-ws", "Dump WebSocket messages sent and received by master", (yargs) => { }],
const debugCommands = new command.CommandTree({ name: "debug", description: "Debugging utilities" });
debugCommands.add(new command.Command({
definition: ["dump-ws", "Dump WebSocket messages sent and received by master", (yargs) => { }],
handler: async function(args, control) {
await link.messages.debugDumpWs.send(control);
return new Promise(() => {});
},
}));
// Convert to mapping from name to command instance
commands = new Map([...commands.map(command => [command.name, command])]);
/**
* Connector for control connection to master server
@@ -639,14 +484,22 @@ class ControlConnector extends link.WebSocketClientConnector {
* Handles running the control
*
* Connects to the master server over WebSocket and sends commands to it.
* @static
*/
class Control extends link.Link {
// I don't like God classes, but the alternative of putting all this state
// into global variables is not much better.
constructor(connector) {
constructor(connector, controlPlugins) {
super("control", "master", connector);
link.attachAllMessages(this);
/**
* Mapping of plugin names to their instance for loaded plugins.
* @type {Map<string, module:lib/plugin.BaseControlPlugin>}
*/
this.plugins = controlPlugins;
for (let controlPlugin of controlPlugins.values()) {
plugin.attachPluginMessages(this, controlPlugin.info, controlPlugin);
}
}
async instanceOutputEventHandler(message) {
@@ -687,18 +540,42 @@ async function startControl() {
})
.command("control-config", "Manage Control config", config.configCommand)
.wrap(yargs.terminalWidth())
.strict()
;
for (let command of commands.values()) {
command.register(yargs);
const rootCommands = new command.CommandTree({ name: "clusterctl", description: "Manage cluster" });
rootCommands.add(slaveCommands);
rootCommands.add(instanceCommands);
rootCommands.add(permissionCommands);
rootCommands.add(roleCommands);
rootCommands.add(userCommands);
rootCommands.add(debugCommands);
console.log("Loading Plugin info");
let pluginInfos = await plugin.loadPluginInfos("plugins");
config.registerPluginConfigGroups(pluginInfos);
config.finalizeConfigs();
let controlPlugins = new Map();
for (let pluginInfo of pluginInfos) {
if (!pluginInfo.controlEntrypoint) {
continue;
}
let { ControlPlugin } = require(`./plugins/${pluginInfo.name}/${pluginInfo.controlEntrypoint}`);
let controlPlugin = new ControlPlugin(pluginInfo);
controlPlugins.set(pluginInfo.name, controlPlugin);
await controlPlugin.init();
await controlPlugin.addCommands(rootCommands);
}
const args = yargs.demandCommand(1, "You need to specify a command to run")
.strict()
.argv
;
for (let [name, command] of rootCommands.subCommands) {
if (name === command.name) {
command.register(yargs);
}
}
config.finalizeConfigs();
const args = yargs.argv;
console.log(`Loading config from ${args.config}`);
let controlConfig = new config.ControlConfig();
@@ -715,12 +592,24 @@ async function startControl() {
}
}
let commandName = args._[0];
if (commandName === "control-config") {
if (args._.length === 0) {
yargs.showHelp();
yargs.exit();
}
// Handle the control-config command before trying to connect.
if (args._[0] === "control-config") {
await config.handleConfigCommand(args, controlConfig, args.config);
return;
}
// Determine which command is being executed.
let commandPath = [...args._];
let targetCommand = rootCommands;
while (commandPath.length && targetCommand instanceof command.CommandTree) {
targetCommand = targetCommand.get(commandPath.shift());
}
// The remaining commands require connecting to the master server.
if (!controlConfig.get("control.master_url") || !controlConfig.get("control.master_token")) {
console.error("Missing URL and/or token to connect with. See README.md for setting up access.");
@@ -733,7 +622,7 @@ async function startControl() {
controlConfig.get("control.reconnect_delay"),
controlConfig.get("control.master_token")
);
let control = new Control(controlConnector);
let control = new Control(controlConnector, controlPlugins);
try {
await controlConnector.connect();
} catch(err) {
@@ -751,42 +640,36 @@ async function startControl() {
});
});
if (commands.has(commandName)) {
let command = commands.get(commandName);
let keepOpen = Boolean(args.keepOpen);
try {
await targetCommand.run(args, control);
let keepOpen = Boolean(args.keepOpen);
try {
await command.run(args, control);
} catch (err) {
keepOpen = false;
if (err instanceof errors.CommandError) {
console.error(`Error running command: ${err.message}`);
process.exitCode = 1;
} catch (err) {
keepOpen = false;
if (err instanceof errors.CommandError) {
console.error(`Error running command: ${err.message}`);
process.exitCode = 1;
} else if (err instanceof errors.RequestError) {
console.error(`Error sending request: ${err.message}`);
process.exitCode = 1;
} else if (err instanceof errors.RequestError) {
console.error(`Error sending request: ${err.message}`);
process.exitCode = 1;
} else {
throw err;
}
} else {
throw err;
}
} finally {
if (!keepOpen) {
await control.shutdown();
}
} finally {
if (!keepOpen) {
await control.shutdown();
}
}
}
module.exports = {
Control,
// for testing only
_formatOutputColored: formatOutputColored,
_resolveInstance: resolveInstance,
_Control: Control,
_commands: commands,
};