Implement new configuration system

Replace current configuration mess with a trimmed down version of the
original vision of #200.  Configs are collection of config groups that
have fields that can be set.  These groups allow organizing the fields
as well as opertunity for plugins to add their own groups.  By default
plugins have an auto generated group with the enabled field.
This commit is contained in:
Hornwitser committed 2020-03-09 20:48:13 +01:00
1 parent 370ee9ed04
commit 5e5149dc93
24 files changed
+2364 -498

No files matched your search

+592
View File
@@ -0,0 +1,592 @@
/**
* @file Configuration classes
* @author Hornwitser
*/
"use strict";
/**
* Invalid Value exception
*
* Exception class for when invalid values are attempted to be set on a
* field.
*/
class InvalidValue extends Error { };
/**
* Invalid Field exception
*
* Exception class for when a group or field that does not exist is
* attempted to be accessed.
*/
class InvalidField extends Error { };
/**
* Split the given string on the first instance of separator
*
* Splits @p string on the first instance of @p separator and returns an
* array consisting of the string up to the separator and the string
* after the separator. Returns an array with the string and an empty
* string if the separator is not present.
*
* @returns {Array} string split on separator.
*/
function splitOn(separator, string) {
let index = string.indexOf(separator);
if (index === -1) {
return [string, ''];
}
return [string.slice(0, index), string.slice(index + separator.length)];
}
/**
* Return a string describing the type of the value passed
*
* Works the same as typeof, excpet that null and array types get their
* own string.
*
* @param value - value to return the type of.
* @returns {string} basic type of the value passed.
*/
function basicType(value) {
if (value === null) { return "null"; }
if (value instanceof Array) { return "array"; }
return typeof value;
}
/**
* Collection of config groups
*
* Represents a collection of ConfigGroup instances that can be
* managed as one.
*/
class Config {
constructor() {
if (!this.constructor._finalized) {
throw new Error(`Cannot instantiate incomplete Config class ${this.constructor.name}`)
}
this._groups = new Map();
this._unknownGroups = new Map();
}
async init() {
for (let [name, GroupClass] of this.constructor._groups) {
if (!this._groups.has(name)) {
let group = new GroupClass();
await group.init();
this._groups.set(name, group);
}
}
this._initialized = true;
}
_validate(serializedConfig) {
if (basicType(serializedConfig) !== "object") {
throw new Error(`Expected object, not ${basicType(serializedConfig)} for config`);
}
if (basicType(serializedConfig.groups) !== "array") {
throw new Error(`Expected groups to be an array, not ${basicType(serializedConfig.groups)}`);
}
}
async load(serializedConfig) {
this._validate(serializedConfig);
for (let serializedGroup of serializedConfig.groups) {
let GroupClass = this.constructor._groups.get(serializedGroup.name);
if (!GroupClass) {
this._unknownGroups.set(serializedGroup.name, serializedGroup);
continue;
}
let group = new GroupClass();
await group.load(serializedGroup);
this._groups.set(GroupClass.groupName, group);
}
await this.init();
}
/**
* Serialize the config to a plain JavaScript object
*/
serialize() {
let groups = [...this._unknownGroups.values()];
for (let group of this._groups.values()) {
groups.push(group.serialize());
}
return { groups };
}
/**
* Update the configuration based on a serialized config
*
* Updates all groups in the config with groups in the serialized
* config passed.
*/
update(serializedConfig) {
this._validate(serializedConfig);
for (let serializedGroup of serializedConfig.groups) {
let group = this._groups.get(serializedGroup.name);
if (group) {
group.update(serializedGroup);
} else {
this._unknownGroups.set(serializedGroup.name, serializedGroup);
}
}
}
/**
* Get the value for a config field
*/
get(name) {
let [group, field] = splitOn('.', name);
return this.group(group).get(field);
}
/**
* Set the value for a config field
*/
set(name, value) {
let [group, field] = splitOn('.', name);
return this.group(group).set(field, value);
}
/**
* Get the config group instance with the given name
*/
group(name) {
if (!this._initialized) {
throw new Error(`${this.constructor.name} instance is uninitialized`)
}
let group = this._groups.get(name);
if (!group) {
throw new InvalidField(`No config group named '${name}'`);
}
return group;
}
static _initSubclass() {
// These properties are initialized here in order to ensure that
// they end up on the sub-class.
if (!this._initialized) {
this._initialized = true;
this._finalized = false;
this._groups = new Map();
}
}
/**
* Mapping of group name to group class
*
* Returns the internal mapping of group names to group classes that
* mave been registered with this config. Note that mutating this
* object will lead to unexpected behaviour.
*
* @returns {Map<string, GroupClass>} config groups
*/
static get groups() {
this._initSubclass();
return this._groups;
}
/**
* Locks this Config class from adding more groups.
*/
static finalize() {
this._initSubclass();
this._finalized = true;
}
/**
* Register a ConfigGroup with this Config
*
* Adds the ConfigGroup to this config as a group that will get
* initialized, loaded and serialized with this config class.
*/
static registerGroup(group) {
this._initSubclass();
if (this._finalized) {
throw new Error("Cannot register group on finalized config");
}
if (!group._finalized) {
throw new Error("Group must be finalized before it can be registered");
}
if (this._groups.has(group.groupName)) {
throw new Error(`${group.groupName} has already been registered`);
}
this._groups.set(group.groupName, group);
}
}
/**
* Collection of related config entries
*/
class ConfigGroup {
/**
* Creates a new config group.
*
* After the creation of the new config group you have to call
* either .init() or .load() on it in order to fully initialize it.
*/
constructor(serializedGroup) {
if (!this.constructor._finalized) {
throw new Error(`Cannot instantiate incomplete ConfigGroup class ${this.constructor.name}`)
}
this._fields = new Map();
this._unknownFields = new Map();
}
/**
* Initialize new config group
*
* Computes and assigns the initial values for all fields of the
* config group.
*/
async init() {
for (let [name, def] of this.constructor._definitions) {
if (this._fields.has(name)) {
continue;
}
let value = null;
if (typeof def.initial_value === "function") {
value = await def.initial_value()
} else if (def.initial_value !== undefined) {
value = def.initial_value;
}
this._fields.set(name, value);
}
}
/**
* Load from serialized group
*
* Loads all the values from the passed serialized version of the
* group and then initializes any possible missing fields from it to
* their default values.
*/
async load(serializedGroup) {
this.update(serializedGroup);
await this.init();
}
/**
* Get value for field
*/
get(name) {
if (!this.constructor._definitions.has(name)) {
throw new InvalidField(`No field named '${name}'`);
}
return this._fields.get(name);
}
/**
* Set value of field
*
* The field must be defined for the config group and the value is
* type checked against the field definition.
*
* @throws {InvalidValue} if value is not allowed for the field.
*/
set(name, value) {
let def = this.constructor._definitions.get(name);
if (!def) {
throw new Error(`No field named '${name}'`);
}
// Empty strings are treates as null
if (value === "") {
value = null;
}
if (def.enum && !def.enum.includes(value)) {
throw new InvalidValue(`Expected one of [${def.enum.join(', ')}], not ${value}`);
}
if (basicType(value) === "string") {
if (def.type === "boolean") {
if (value === "true") { value = true; }
else if (value === "false") { value = false; }
} else if (def.type === "number") {
let numberRegExp = /^[+-]?(Infinity|\d+\.(\d+)?([eE][+-]?\d+)?|\.?\d+([eE][+-]?\d+)?)$/;
if (numberRegExp.test(value.trim())) {
value = Number.parseFloat(value);
}
} else if (def.type === "object" ) {
try {
value = JSON.parse(value);
} catch (err) {
throw new InvalidValue(`Error parsing value for ${name}: ${err.message}`)
}
}
}
if (value === null) {
if (!def.optional) {
throw new InvalidValue(`Field ${name} cannot be null`)
}
} else {
if (basicType(value) !== def.type) {
throw new InvalidValue(`Expected type of ${name} to be ${def.type}, not ${basicType(value)}`);
}
}
this._fields.set(name, value);
}
/**
* Update a config group from a serialized group
*
* Overwrites the values of all the fields in this config group that
* has a valid value in the passed serialized group with that value.
*/
update(serializedGroup) {
if (basicType(serializedGroup) !== "object") {
throw new Error(`Expected object, not ${basicType(serializedGroup)} for ConfigGroup`);
}
if (serializedGroup.name !== this.constructor.groupName) {
throw new Error(`Expected group name ${this.constructor.groupName}, not ${serializedGroup.name}`);
}
if (basicType(serializedGroup.fields) !== "object") {
throw new Error(`Expected fields to be an object, not ${basicType(serializedGroup.fields)}`);
}
for (let [name, value] of Object.entries(serializedGroup.fields)) {
let def = this.constructor._definitions.get(name);
if (!def) {
this._unknownFields.set(name, value);
continue;
}
if (def.optional) {
if (value !== null && basicType(value) !== def.type) {
continue;
}
} else {
if (basicType(value) !== def.type) {
continue;
}
}
if (def.enum && !def.enum.includes(value)) {
continue;
}
this._fields.set(name, value);
}
}
/**
* Serialize the config to a plain JavaScript object
*/
serialize() {
let fields = {};
for (let [name, value] of this._fields) {
fields[name] = value;
}
for (let [name, value] of this._unknownFields) {
fields[name] = value;
}
return {
name: this.constructor.groupName,
fields,
};
}
static _initSubclass() {
// These properties are initialized here in order to ensure that
// they end up on the sub-class.
if (!this._initialized) {
this._initialized = true;
this._definitions = new Map();
}
}
/**
* Mapping of config name to field meta data
*
* Returns the internal meta data for the fields of this class.
* Note that mutating this object will lead to unexpected behaviour.
*
* @returns {Map<string, Object>} field meta data
*/
static get definitions() {
this._initSubclass();
return this._definitions;
}
/**
* Define a new configuration field
*
* The following properties are supported:
* - type:
* string declaring the type of the config value, supports
* boolean, string, number and object.
* - name:
* Name of the configuration field. Should follow the
* lower_case_underscore style.
* - title:
* Text used to identify the config field in user interfaces.
* - description:
* Text used to describe the config field in user interfaces.
* - enum (optional):
* Array of all values that are acceptible. Useful for making
* enumerated values.
* - optional (optional):
* True if this field can be set to null. Defaults to false.
* - initial_value (optional):
* Value this config field should take in a newly initialized
* config. This can also be an async function returning the
* value to use.
*/
static define(item) {
if (this._finalized) {
throw new Error(`Cannot define field for ConfigGroup class ${this.name} after it has been finalized`)
}
if (basicType(this.groupName) !== "string") {
throw new Error(`Expected ConfigGroup class ${this.name} to have the groupName property set to a string`)
}
this._initSubclass();
let itemKeys = Object.keys(item);
// Check for required properties
["name", "type"].forEach(prop => {
if (!itemKeys.includes(prop)) {
throw new Error(`${prop} is required when defining an field`);
}
})
// Validate properties
let validTypes = ["boolean", "string", "number", "object"];
Object.keys(item).forEach(key => {
let value = item[key];
let valueType = basicType(value);
switch (key) {
case "type":
if (!validTypes.includes(value)) {
throw new Error(`${value} is not a valid type`);
}
break;
case "enum":
if (valueType !== "array") {
throw new Error("enum must be an array");
}
break;
case "name":
if (valueType !== "string") {
throw new Error("name must be a string");
}
break;
case "title":
if (valueType !== "string") {
throw new Error("title must be a string");
}
break;
case "description":
if (valueType !== "string") {
throw new Error("description must be a string");
}
break;
case "optional":
if (valueType !== "boolean") {
throw new Error("optional must be a boolean");
}
break;
case "initial_value":
if (valueType !== item.type && valueType !== "function") {
throw new Error("initial_value must match the type or be a function");
}
break;
default:
throw new Error(`Unknown property ${key}`);
}
});
if (this._definitions.has(item.name)) {
throw new Error(`Config field ${item.name} has already been defined`);
}
let computed = Object.assign({
optional: false,
fullName: `${this.groupName}.${item.name}`,
}, item)
if (!computed.optional && computed.initial_value === undefined) {
throw new Error(`Non-optional field ${item.name} needs an initial_value`);
}
this._definitions.set(item.name, computed);
}
/**
* Locks this ConfigGroup class from adding more definitons.
*/
static finalize() {
if (basicType(this.groupName) !== "string") {
throw new Error(`Expected ConfigGroup class ${this.name} to have the groupName property set to a string`)
}
this._initSubclass();
this._finalized = true;
}
}
/**
* Config group for plugins
*
* Grouping that includes per plugin fields clusterio uses to manage
* plugins. This is currently only the enabled field. It is otherwise
* identical to the ConfigGroup class.
*/
class PluginConfigGroup extends ConfigGroup {
static _initSubclass() {
if (!this._initialized) {
super._initSubclass();
this.define({
name: "enabled",
description: "Enable plugin",
type: "boolean",
initial_value: true,
});
}
}
}
module.exports = {
InvalidField,
InvalidValue,
Config,
ConfigGroup,
PluginConfigGroup,
}
+318
View File
@@ -0,0 +1,318 @@
/**
* @file Core definitions for the configuration system
* @author Hornwitser
*/
"use strict";
const util = require("util");
const crypto = require("crypto");
const path = require("path");
const fs = require("fs-extra");
const classes = require("./classes");
class MasterGroup extends classes.ConfigGroup { }
MasterGroup.groupName = "master"
MasterGroup.define({
name: "database_directory",
title: "Database directory",
description: "Directory where item and configuration data is stored.",
type: "string",
initial_value: "database",
});
MasterGroup.define({
name: "factorio_directory",
description: "Path to directory to look for factorio installs",
type: "string",
initial_value: "factorio"
});
MasterGroup.define({
name: "http_port",
title: "HTTP Port",
description: "Port to listen for HTTP connections on, set to null to not listen for HTTP connections.",
type: "number",
optional: true
});
MasterGroup.define({
name: "https_port",
title: "HTTPS Port",
description: "Port to listen for HTTPS connection on, set to null to not listen for HTTPS connections.",
type: "number",
optional: true,
initial_value: 8443,
});
MasterGroup.define({
name: "tls_certificate",
title: "TLS Certificate",
description: "Path to the certificate to use for HTTPS.",
type: "string",
optional: true,
initial_value: "database/certificates/cert.crt",
});
MasterGroup.define({
name: "tls_private_key",
title: "TLS Private Key",
description: "Path to the private key to use for HTTPS.",
type: "string",
optional: true,
initial_value: "database/certificates/cert.key",
});
MasterGroup.define({
name: "auth_secret",
title: "Master Authentication Secret",
description:
"Secret used to generate and verify authentication tokens."
+" Should be a long string of random letters and numbers."
+" Do not share this.",
type: "string",
initial_value: async function() {
console.log("Generating new master authentication secret");
let asyncRandomBytes = util.promisify(crypto.randomBytes);
let bytes = await asyncRandomBytes(256);
return bytes.toString("base64");
},
});
MasterGroup.finalize();
class MasterConfig extends classes.Config { }
MasterConfig.registerGroup(MasterGroup);
class SlaveGroup extends classes.ConfigGroup {}
SlaveGroup.groupName = "slave";
SlaveGroup.define({
name: "name",
description: "Name of the slave",
type: "string",
initial_value: "New Slave",
});
SlaveGroup.define({
name: "id",
description: "ID of the slave",
type: "number",
initial_value: () => Math.random() * 2**31 | 0,
});
SlaveGroup.define({
name: "factorio_directory",
description: "Path to directory to look for factorio installs",
type: "string",
initial_value: "factorio"
});
SlaveGroup.define({
name: "instances_directory",
description: "Path to directory to store instances in.",
type: "string",
initial_value: "instances",
});
SlaveGroup.define({
name: "master_url",
description: "URL to connect to the master server at",
type: "string",
initial_value: "https://localhost:8443/",
});
SlaveGroup.define({
name: "master_token",
description: "Token to authenticate to master server with.",
type: "string",
initial_value: "enter token here",
});
SlaveGroup.define({
name: "public_address",
description: "Public facing address players should connect to in order to join instances on this slave",
type: "string",
initial_value: "localhost",
});
SlaveGroup.finalize();
class SlaveConfig extends classes.Config { }
SlaveConfig.registerGroup(SlaveGroup);
class InstanceGroup extends classes.ConfigGroup { }
InstanceGroup.groupName = "instance"
InstanceGroup.define({
name: "name",
type: "string",
initial_value: "New Instance",
});
InstanceGroup.define({
name: "id",
description: "ID of the slave",
type: "number",
initial_value: () => Math.random() * 2**31 | 0,
});
InstanceGroup.define({
name: "assigned_slave",
type: "number",
optional: true,
});
InstanceGroup.finalize();
class FactorioGroup extends classes.ConfigGroup { }
FactorioGroup.groupName = "factorio";
FactorioGroup.define({
name: "game_port",
description: "UDP port to run game on, uses a random port if null",
type: "number",
optional: true,
});
FactorioGroup.define({
name: "rcon_port",
description: "TCP port to run RCON on, uses a random port if null",
type: "number",
optional: true,
});
FactorioGroup.define({
name: "rcon_password",
description: "Password for RCON, randomly generated if null",
type: "string",
optional: true,
});
FactorioGroup.define({
name: "settings",
description: "Settings overridden in server-settings.json",
type: "object",
initial_value: {
"tags": ["clusterio"],
"auto_pause": false,
},
});
FactorioGroup.finalize();
class InstanceConfig extends classes.Config { }
InstanceConfig.registerGroup(InstanceGroup);
InstanceConfig.registerGroup(FactorioGroup);
function validateGroup(pluginInfo, groupName) {
if (!pluginInfo[groupName] instanceof classes.PluginConfigGroup) {
throw new Error(
`Expected ${groupName} for ${pluginInfo.name} to be an instance of PluginConfigGroup`
);
}
if (pluginInfo[groupName].groupName !== pluginInfo.name) {
throw new Error(
`Expected ${groupName} for ${pluginInfo.name} to be named after the plugin`
);
}
}
/**
* Registers the config groups for the provided plugin infos
*/
function registerPluginConfigGroups(pluginInfos) {
for (let pluginInfo of pluginInfos) {
if (pluginInfo.MasterConfigGroup) {
validateGroup(pluginInfo, "MasterConfigGroup");
MasterConfig.registerGroup(pluginInfo.MasterConfigGroup);
} else {
class MasterConfigGroup extends classes.PluginConfigGroup { }
MasterConfigGroup.groupName = pluginInfo.name;
MasterConfigGroup.finalize();
MasterConfig.registerGroup(MasterConfigGroup);
}
if (pluginInfo.instanceEntrypoint) {
if (pluginInfo.InstanceConfigGroup) {
validateGroup(pluginInfo, "InstanceConfigGroup");
InstanceConfig.registerGroup(pluginInfo.InstanceConfigGroup);
} else {
class InstanceConfigGroup extends classes.PluginConfigGroup { }
InstanceConfigGroup.groupName = pluginInfo.name;
InstanceConfigGroup.finalize();
InstanceConfig.registerGroup(InstanceConfigGroup);
}
}
}
}
/**
* Lock configs from adding more groups and make them usable
*/
function finalizeConfigs() {
MasterConfig.finalize();
SlaveConfig.finalize();
InstanceConfig.finalize();
}
/**
* Yargs config command
*
* Can be passed to yargs.command to implement a config command. Use
* handleConfigCommand to do the requested action.
*/
function configCommand(yargs) {
yargs
.command("set <field> [value]", "Set config field")
.command("show <field>", "Show value of the given config field")
.command("list", "List all configuration fields and their values")
.demandCommand(1, "You need to specify a command to run")
.strict()
;
}
/**
* Handle yargs command
*
* Handle the actions that are made available by configCommand.
*/
async function handleConfigCommand(args, instance, configPath) {
let command = args._[1];
if (command === "list") {
for (let GroupClass of instance.constructor.groups.values()) {
for (let def of GroupClass.definitions.values()) {
let value = instance.get(def.fullName);
console.log(`${def.fullName} ${JSON.stringify(value)}`);
}
}
} else if (command === "show") {
try {
console.log(instance.get(args.field));
} catch (err) {
if (err instanceof classes.InvalidField) {
console.error(err.message);
} else {
throw err;
}
}
} else if (command === "set") {
if (args.value === undefined) {
args.value = null;
}
try {
instance.set(args.field, args.value);
await fs.outputFile(configPath, JSON.stringify(instance.serialize(), null, 4));
} catch (err) {
if (err instanceof classes.InvalidField || err instanceof classes.InvalidValue) {
console.error(err.message);
} else {
throw err;
}
}
}
}
module.exports = {
MasterGroup,
SlaveGroup,
InstanceGroup,
FactorioGroup,
MasterConfig,
SlaveConfig,
InstanceConfig,
registerPluginConfigGroups,
finalizeConfigs,
configCommand,
handleConfigCommand,
}
+9
View File
@@ -0,0 +1,9 @@
/**
* @file Configuration System
* @author Hornwitser
*/
module.exports = {
...require("./classes"),
...require("./definitions"),
}
+2 -3
View File
@@ -809,11 +809,10 @@ class FactorioServer extends events.EventEmitter {
*
* Loads server-settings.example.json from the data dir.
*
* @param {string} dataDir - The data directory for Factorio
* @returns {object} the parsed server-settings.
*/
static async exampleSettings(dataDir) {
return JSON.parse(await fs.readFile(path.join(dataDir, "server-settings.example.json"), "utf-8"));
async exampleSettings(dataDir) {
return JSON.parse(await fs.readFile(this.dataPath("server-settings.example.json"), "utf-8"));
}
async _writeConfigIni() {
+43 -29
View File
@@ -199,11 +199,11 @@ messages.listInstances = new Request({
type: "array",
items: {
additionalProperties: false,
required: ["name", "id", "slave_id"],
required: ["name", "id", "assigned_slave"],
properties: {
"name": { type: "string" },
"id": { type: "integer" },
"slave_id": { type: "integer" },
"assigned_slave": { type: ["null", "integer"] },
},
},
},
@@ -221,44 +221,59 @@ messages.setInstanceOutputSubscriptions = new Request({
},
});
messages.createInstanceCommand = new Request({
messages.createInstance = new Request({
type: 'create_instance',
links: ['control-master'],
requestProperties: {
"name": { type: "string" },
"serialized_config": { type: "object" },
},
});
messages.getInstanceConfig = new Request({
type: "get_instance_config",
links: ["control-master"],
requestProperties: {
"instance_id": { type: "integer" },
},
responseProperties: {
"serialized_config": { type: "object" },
},
});
messages.setInstanceConfigField = new Request({
type: "set_instance_config_field",
links: ["control-master"],
requestProperties: {
"instance_id": { type: "integer" },
"field": { type: "string" },
"value": { type: "string" },
},
});
messages.assignInstanceCommand = new Request({
type: 'assign_instance_command',
links: ['control-master'],
requestProperties: {
"instance_id": { type: "integer" },
"slave_id": { type: "integer" },
},
});
messages.createInstance = new Request({
type: 'create_instance',
messages.assignInstance = new Request({
type: 'assign_instance',
links: ['master-slave'],
requestProperties: {
"id": { type: "integer" },
"options": {
additionalProperties: false,
required: [
"name", "description", "visibility", "username", "token", "game_password",
"verify_user_identity", "allow_commands", "auto_pause",
],
properties: {
"name": { type: "string" },
"description": { type: "string" },
"visibility": { type: "object" },
"username": { type: "string" },
"token": { type: "string" },
"game_password": { type: "string" },
"verify_user_identity": { type: "boolean" },
"allow_commands": { type: "string" },
"auto_pause": { type: "boolean" },
},
},
"serialized_config": { type: "object" },
},
});
forwardTo: 'instance',
})
messages.startInstance = new Request({
type: 'start_instance',
links: ['control-master', 'master-slave', 'slave-instance'],
requestProperties: {
"instance_id": { type: "integer" },
},
forwardTo: 'instance',
});
@@ -447,10 +462,9 @@ messages.updateInstances = new Event({
items: {
type: "object",
additionalProperties: false,
required: ["id", "name"],
required: ["serialized_config"],
properties: {
"id": { type: "integer" },
"name": { type: "string" },
"serialized_config": { type: "object" },
},
},
},
+11 -3
View File
@@ -106,7 +106,16 @@ class BaseMasterPlugin {
async onExit() { }
}
async function getPluginInfos(baseDir) {
/**
* Load plugin information
*
* Searches through the plugin directory and loads each plugin's info
* module. Once loaded the info modules will not be reloaded should this
* function be called again.
*
* @returns {Map<string, Object>} mapping of plugin name to info module.
*/
async function loadPluginInfos(baseDir) {
let plugins = [];
for (let pluginDir of await fs.readdir(baseDir)) {
let pluginInfo;
@@ -129,7 +138,6 @@ async function getPluginInfos(baseDir) {
);
}
pluginInfo.enabled = !await fs.exists(path.join(baseDir, pluginDir, "DISABLED"));
plugins.push(pluginInfo);
}
return plugins;
@@ -155,6 +163,6 @@ module.exports = {
BaseInstancePlugin,
BaseMasterPlugin,
getPluginInfos,
loadPluginInfos,
attachPluginMessages,
};