mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-12 23:04:52 +09:00
872 lines
23 KiB
JavaScript
872 lines
23 KiB
JavaScript
// Message definitions for links
|
|
"use strict";
|
|
const schema = require("lib/schema");
|
|
const errors = require("lib/errors");
|
|
|
|
/**
|
|
* Represents a message that can be sent over the link
|
|
*
|
|
* @memberof module:lib/link
|
|
*/
|
|
class Message {
|
|
/**
|
|
* Name of the plugin this message belongs to, or null.
|
|
* @returns {?string} - plugin name or null if not from a plugin.
|
|
*/
|
|
get plugin() {
|
|
if (this._plugin === undefined) {
|
|
let index = this.type.indexOf(":");
|
|
this._plugin = index === -1 ? null : this.type.slice(0, index);
|
|
}
|
|
|
|
return this._plugin;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Represents a request sent over the link
|
|
*
|
|
* A request-response message that can be innitated by either party of the
|
|
* link.
|
|
*
|
|
* @extends module:lib/link.Message
|
|
* @memberof module:lib/link
|
|
*/
|
|
class Request extends Message {
|
|
|
|
/**
|
|
* Creates a request
|
|
*
|
|
* @param {string} type -
|
|
* message type used. Will have suffix '_request' for the request
|
|
* message and suffix '_response' for the response message.
|
|
* @param {Array<string>} links -
|
|
* Links this request is valid on. Takes an array of strings
|
|
* containing "<source>-<target>" specifications.
|
|
* @param {?string} permission -
|
|
* Permission required to send this request. Only applies to
|
|
* requests sent from control to master.
|
|
* @param {?string} forwardTo -
|
|
* Optional target to forward this request to. 'instance' add
|
|
* instance_id into the requestProperties and forward to the given
|
|
* instance. 'master' forwards it to the master server.
|
|
* @param {Object<string, Object>} requestProperties -
|
|
* Mapping of property values to JSON schema specifications for the
|
|
* properties that are valid in the data payload of this requst.
|
|
* @param {Object<string, Object>} responseProperties -
|
|
* Mapping of property values to JSON schema specifications for the
|
|
* properties that are valid in the data payload of the response to
|
|
* this requst.
|
|
*/
|
|
constructor({
|
|
type, permission, links, forwardTo = null, requestProperties = {}, responseProperties = {},
|
|
}) {
|
|
super();
|
|
this.type = type;
|
|
this.links = links;
|
|
this.permission = permission || null;
|
|
this.forwardTo = forwardTo;
|
|
|
|
this.requestType = type + "_request";
|
|
this.responseType = type + "_response";
|
|
|
|
if (permission === undefined && links.includes("control-master")) {
|
|
throw new Error(`permission is required for ${this.type} request over control-master links`);
|
|
}
|
|
if (permission && !links.includes("control-master")) {
|
|
throw new Error(`permission is not allowed on ${this.type} request as it is not over control-master link`);
|
|
}
|
|
|
|
if (forwardTo === "instance") {
|
|
requestProperties = {
|
|
"instance_id": { type: "integer" },
|
|
...requestProperties,
|
|
};
|
|
|
|
} else if (forwardTo !== "master" && forwardTo !== null) {
|
|
throw new Error(`Invalid forwardTo value ${forwardTo}`);
|
|
}
|
|
|
|
this._requestValidator = schema.compile({
|
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
properties: {
|
|
"type": { const: this.requestType },
|
|
"data": {
|
|
additionalProperties: false,
|
|
required: Object.keys(requestProperties),
|
|
properties: requestProperties,
|
|
},
|
|
},
|
|
});
|
|
|
|
this._responseValidator = schema.compile({
|
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
properties: {
|
|
"type": { const: this.responseType },
|
|
"data": {
|
|
anyOf: [
|
|
{
|
|
additionalProperties: false,
|
|
required: ["seq", ...Object.keys(responseProperties)],
|
|
properties: {
|
|
"seq": { type: "integer" },
|
|
...responseProperties,
|
|
},
|
|
},
|
|
{
|
|
additionalProperties: false,
|
|
required: ["seq", "error"],
|
|
properties: {
|
|
"seq": { type: "integer" },
|
|
"error": { type: "string" },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Attach to a link
|
|
*
|
|
* Set a the validator for the response on the given link if it's a
|
|
* source and sets the handler for the request if it is a target.
|
|
*
|
|
* If forwardTo was set to 'instance' the `forwardRequestToInstance`
|
|
* method on the link is used as the default handler.
|
|
*
|
|
* If forwardTo was set to 'master' the `forwardRequesToMaster` method
|
|
* on the link is used as the default handler.
|
|
*
|
|
* Does nothing if the link is neither a source nor a target for this
|
|
* request.
|
|
*
|
|
* @param {Link} link - The link to attach to.
|
|
* @param {Function} handler -
|
|
* Async function to invoke with link set as this to handle the
|
|
* request request. Only used on the target side.
|
|
* @throws {Error} if the handler is needed and not defined.
|
|
*/
|
|
attach(link, handler) {
|
|
// Source side.
|
|
if (this.links.includes(`${link.source}-${link.target}`)) {
|
|
link.setValidator(this.responseType, this._responseValidator);
|
|
}
|
|
|
|
// Target side. Note: Source and target is reversed here.
|
|
if (this.links.includes(`${link.target}-${link.source}`)) {
|
|
|
|
// Use forwarder if handler is not present.
|
|
if (!handler) {
|
|
if (this.forwardTo === "instance") {
|
|
handler = link.forwardRequestToInstance;
|
|
} else if (this.forwardTo === "master") {
|
|
handler = link.forwardRequestToMaster;
|
|
}
|
|
}
|
|
|
|
if (!handler) {
|
|
throw new Error(`Missing handler for ${this.requestType} on ${link.source}-${link.target} link`);
|
|
}
|
|
|
|
// Check permission if this is a handler for a control connection on the master
|
|
if (this.permission !== null && `${link.source}-${link.target}` === "master-control") {
|
|
let origHandler = handler;
|
|
handler = async function(message, request) {
|
|
this.user.checkPermission(request.permission);
|
|
return await origHandler.call(this, message, request);
|
|
};
|
|
}
|
|
|
|
link.setHandler(this.requestType, message => {
|
|
handler.call(link, message, this).then(response => {
|
|
if (response === undefined) {
|
|
// XXX Should we allow implicit responses like this?
|
|
response = {};
|
|
}
|
|
|
|
if (!this._responseValidator({ seq: 0, type: this.responseType, response })) {
|
|
console.error(this._responseValidator.errors);
|
|
throw new Error(`Validation failed responding to ${this.requestType}`);
|
|
}
|
|
|
|
link.connector.send(this.responseType, { ...response, seq: message.seq });
|
|
|
|
}).catch(err => {
|
|
if (!(err instanceof errors.RequestError)) {
|
|
console.error(`Unexpected error while responding to ${this.requestType}`, err);
|
|
}
|
|
link.connector.send(this.responseType, { seq: message.seq, error: err.message });
|
|
});
|
|
}, this._requestValidator);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send request over the given link
|
|
*
|
|
* Sends the given data over the link as the request payload and waits
|
|
* for the response.
|
|
*
|
|
* @param {module:lib/link.Link} link - Link to send request over.
|
|
* @param {Object} data - Data to send with the request.
|
|
* @returns {object} response data
|
|
*/
|
|
async send(link, data = {}) {
|
|
// XXX validate link target/source?
|
|
if (!this._requestValidator({ seq: 0, type: this.requestType, data })) {
|
|
console.error(this._requestValidator.errors);
|
|
throw new Error(`Validation failed sending ${this.requestType}`);
|
|
}
|
|
let seq = link.connector.send(this.requestType, data);
|
|
let responseMessage = await link.waitFor(this.responseType, { seq });
|
|
if (responseMessage.data.error) {
|
|
throw new errors.RequestError(responseMessage.data.error);
|
|
}
|
|
return responseMessage.data;
|
|
}
|
|
}
|
|
|
|
|
|
let messages = {};
|
|
|
|
// Connection requests
|
|
let wsLinks = ["master-control", "control-master", "master-slave", "slave-master"];
|
|
messages.prepareDisconnect = new Request({
|
|
type: "prepare_disconnect",
|
|
links: wsLinks,
|
|
permission: null,
|
|
});
|
|
|
|
messages.prepareMasterDisconnect = new Request({
|
|
type: "prepare_master_disconnect",
|
|
links: ["slave-instance"],
|
|
});
|
|
|
|
messages.ping = new Request({
|
|
type: "ping",
|
|
links: wsLinks,
|
|
permission: null,
|
|
});
|
|
|
|
messages.debugDumpWs = new Request({
|
|
type: "debug_dump_ws",
|
|
links: ["control-master"],
|
|
permission: "core.debug.dump_ws",
|
|
});
|
|
|
|
|
|
// Management requests
|
|
messages.listSlaves = new Request({
|
|
type: "list_slaves",
|
|
links: ["control-master"],
|
|
permission: "core.slave.list",
|
|
responseProperties: {
|
|
"list": {
|
|
type: "array",
|
|
items: {
|
|
additionalProperties: false,
|
|
required: ["agent", "version", "name", "id", "connected"],
|
|
properties: {
|
|
"agent": { type: "string" },
|
|
"version": { type: "string" },
|
|
"name": { type: "string" },
|
|
"id": { type: "integer" },
|
|
"connected": { type: "boolean" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.listInstances = new Request({
|
|
type: "list_instances",
|
|
links: ["control-master"],
|
|
permission: "core.instance.list",
|
|
responseProperties: {
|
|
"list": {
|
|
type: "array",
|
|
items: {
|
|
additionalProperties: false,
|
|
required: ["name", "id", "assigned_slave"],
|
|
properties: {
|
|
"name": { type: "string" },
|
|
"id": { type: "integer" },
|
|
"assigned_slave": { type: ["null", "integer"] },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.generateSlaveToken = new Request({
|
|
type: "generate_slave_token",
|
|
links: ["control-master"],
|
|
permission: "core.slave.generate_token",
|
|
requestProperties: {
|
|
"slave_id": { type: "integer" },
|
|
},
|
|
responseProperties: {
|
|
"token": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.createSlaveConfig = new Request({
|
|
type: "create_slave_config",
|
|
links: ["control-master"],
|
|
permission: "core.slave.create_config",
|
|
requestProperties: {
|
|
"id": { type: ["integer", "null"] },
|
|
"name": { type: ["string", "null"] },
|
|
"generate_token": { type: "boolean" },
|
|
},
|
|
responseProperties: {
|
|
"serialized_config": { type: "object" },
|
|
},
|
|
});
|
|
|
|
messages.setInstanceOutputSubscriptions = new Request({
|
|
type: "set_instance_output_subscriptions",
|
|
links: ["control-master"],
|
|
permission: "core.instance.follow_log",
|
|
requestProperties: {
|
|
"instance_ids": {
|
|
type: "array",
|
|
items: { type: "integer" },
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.createInstance = new Request({
|
|
type: "create_instance",
|
|
links: ["control-master"],
|
|
permission: "core.instance.create",
|
|
requestProperties: {
|
|
"serialized_config": { type: "object" },
|
|
},
|
|
});
|
|
|
|
messages.getInstanceConfig = new Request({
|
|
type: "get_instance_config",
|
|
links: ["control-master"],
|
|
permission: "core.instance.get_config",
|
|
requestProperties: {
|
|
"instance_id": { type: "integer" },
|
|
},
|
|
responseProperties: {
|
|
"serialized_config": { type: "object" },
|
|
},
|
|
});
|
|
|
|
messages.setInstanceConfigField = new Request({
|
|
type: "set_instance_config_field",
|
|
links: ["control-master"],
|
|
permission: "core.instance.update_config",
|
|
requestProperties: {
|
|
"instance_id": { type: "integer" },
|
|
"field": { type: "string" },
|
|
"value": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.setInstanceConfigProp = new Request({
|
|
type: "set_instance_config_prop",
|
|
links: ["control-master"],
|
|
permission: "core.instance.update_config",
|
|
requestProperties: {
|
|
"instance_id": { type: "integer" },
|
|
"field": { type: "string" },
|
|
"prop": { type: "string" },
|
|
"value": {},
|
|
},
|
|
});
|
|
|
|
messages.assignInstanceCommand = new Request({
|
|
type: "assign_instance_command",
|
|
links: ["control-master"],
|
|
permission: "core.instance.assign",
|
|
requestProperties: {
|
|
"instance_id": { type: "integer" },
|
|
"slave_id": { type: "integer" },
|
|
},
|
|
});
|
|
|
|
messages.assignInstance = new Request({
|
|
type: "assign_instance",
|
|
links: ["master-slave"],
|
|
requestProperties: {
|
|
"serialized_config": { type: "object" },
|
|
},
|
|
forwardTo: "instance",
|
|
});
|
|
|
|
messages.startInstance = new Request({
|
|
type: "start_instance",
|
|
links: ["control-master", "master-slave", "slave-instance"],
|
|
permission: "core.instance.start",
|
|
requestProperties: {
|
|
"save": { type: ["string", "null"] },
|
|
},
|
|
forwardTo: "instance",
|
|
});
|
|
|
|
messages.createSave = new Request({
|
|
type: "create_save",
|
|
links: ["control-master", "master-slave", "slave-instance"],
|
|
permission: "core.instance.create_save",
|
|
forwardTo: "instance",
|
|
});
|
|
|
|
messages.exportData = new Request({
|
|
type: "export_data",
|
|
links: ["control-master", "master-slave", "slave-instance"],
|
|
permission: "core.instance.export_data",
|
|
forwardTo: "instance",
|
|
});
|
|
|
|
messages.stopInstance = new Request({
|
|
type: "stop_instance",
|
|
links: ["control-master", "master-slave", "slave-instance"],
|
|
permission: "core.instance.stop",
|
|
forwardTo: "instance",
|
|
});
|
|
|
|
messages.deleteInstance = new Request({
|
|
type: "delete_instance",
|
|
links: ["control-master", "master-slave"],
|
|
permission: "core.instance.delete",
|
|
forwardTo: "instance",
|
|
});
|
|
|
|
messages.sendRcon = new Request({
|
|
type: "send_rcon",
|
|
links: ["control-master", "master-slave", "slave-instance"],
|
|
permission: "core.instance.send_rcon",
|
|
forwardTo: "instance",
|
|
requestProperties: {
|
|
"command": { type: "string" },
|
|
},
|
|
responseProperties: {
|
|
"result": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.listPermissions = new Request({
|
|
type: "list_permissions",
|
|
links: ["control-master"],
|
|
permission: "core.permission.list",
|
|
responseProperties: {
|
|
"list": {
|
|
type: "array",
|
|
items: {
|
|
additionalProperties: false,
|
|
required: ["name", "title", "description"],
|
|
properties: {
|
|
"name": { type: "string" },
|
|
"title": { type: "string" },
|
|
"description": { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.listRoles = new Request({
|
|
type: "list_roles",
|
|
links: ["control-master"],
|
|
permission: "core.role.list",
|
|
responseProperties: {
|
|
"list": {
|
|
type: "array",
|
|
items: {
|
|
additionalProperties: false,
|
|
required: ["id", "name", "description", "permissions"],
|
|
properties: {
|
|
"id": { type: "integer" },
|
|
"name": { type: "string" },
|
|
"description": { type: "string" },
|
|
"permissions": { type: "array", items: { type: "string" }},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.createRole = new Request({
|
|
type: "create_role",
|
|
links: ["control-master"],
|
|
permission: "core.role.create",
|
|
requestProperties: {
|
|
"name": { type: "string" },
|
|
"description": { type: "string" },
|
|
"permissions": { type: "array", items: { type: "string" }},
|
|
},
|
|
responseProperties: {
|
|
"id": { type: "integer" },
|
|
},
|
|
});
|
|
|
|
messages.updateRole = new Request({
|
|
type: "update_role",
|
|
links: ["control-master"],
|
|
permission: "core.role.update",
|
|
requestProperties: {
|
|
"id": { type: "integer" },
|
|
"name": { type: "string" },
|
|
"description": { type: "string" },
|
|
"permissions": { type: "array", items: { type: "string" }},
|
|
},
|
|
});
|
|
|
|
messages.grantDefaultRolePermissions = new Request({
|
|
type: "grant_default_role_permissions",
|
|
links: ["control-master"],
|
|
permission: "core.role.update",
|
|
requestProperties: {
|
|
"id": { type: "integer" },
|
|
},
|
|
});
|
|
|
|
messages.deleteRole = new Request({
|
|
type: "delete_role",
|
|
links: ["control-master"],
|
|
permission: "core.role.delete",
|
|
requestProperties: {
|
|
"id": { type: "integer" },
|
|
},
|
|
});
|
|
|
|
messages.listUsers = new Request({
|
|
type: "list_users",
|
|
links: ["control-master"],
|
|
permission: "core.user.list",
|
|
responseProperties: {
|
|
"list": {
|
|
type: "array",
|
|
items: {
|
|
additionalProperties: false,
|
|
required: ["name", "roles", "instances"],
|
|
properties: {
|
|
"name": { type: "string" },
|
|
"roles": { type: "array", items: { type: "integer" }},
|
|
"instances": { type: "array", items: { type: "integer" }},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.createUser = new Request({
|
|
type: "create_user",
|
|
links: ["control-master"],
|
|
permission: "core.user.create",
|
|
requestProperties: {
|
|
"name": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.updateUserRoles = new Request({
|
|
type: "update_user_roles",
|
|
links: ["control-master"],
|
|
permission: "core.user.update_roles",
|
|
requestProperties: {
|
|
"name": { type: "string" },
|
|
"roles": { type: "array", items: { type: "integer" }},
|
|
},
|
|
});
|
|
|
|
messages.deleteUser = new Request({
|
|
type: "delete_user",
|
|
links: ["control-master"],
|
|
permission: "core.user.delete",
|
|
requestProperties: {
|
|
"name": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.getMetrics = new Request({
|
|
type: "statistics_exporter:get_metrics",
|
|
links: ["master-slave", "slave-instance"],
|
|
responseProperties: {
|
|
"results": { type: "array" },
|
|
},
|
|
});
|
|
|
|
|
|
/**
|
|
* Represents an event sent over the link
|
|
*
|
|
* A one way message without any response or recipt confirmation that
|
|
* can be innitiated by either party of the link.
|
|
*
|
|
* @extends module:lib/link.Message
|
|
* @memberof module:lib/link
|
|
*/
|
|
class Event extends Message {
|
|
|
|
/**
|
|
* Creates an event
|
|
*
|
|
* @param {string} type -
|
|
* message type used. Will have suffix '_event' appended to it for
|
|
* the messages sent through this event.
|
|
* @param {Array<string>} links -
|
|
* Links this event is valid on. Takes an array of strings
|
|
* containing "<source>-<target>" specifications.
|
|
* @param {?string} forwardTo -
|
|
* Optional target to forward this request to. Supported values are
|
|
* 'master' and 'instance'. If set to 'instance' an instance_id
|
|
* property is implicity added to eventProperties.
|
|
* @param {?string} broadcastTo -
|
|
* Optional target to broadcast this event to. Only 'instance' is
|
|
* currently supported. An event will only be broadcast towards
|
|
* links that are downstream, so sending an event set to instance
|
|
* broadcast that's sent to a slave will only be broadcast to that
|
|
* slave's instances.
|
|
* @param {Object<string, Object>} eventProperties -
|
|
* Mapping of property values to JSON schema specifications for the
|
|
* properties that are valid in the data payload of this event.
|
|
*/
|
|
constructor({ type, links, forwardTo = null, broadcastTo = null, eventProperties = {} }) {
|
|
super();
|
|
this.type = type;
|
|
this.links = links;
|
|
this.forwardTo = forwardTo;
|
|
this.broadcastTo = broadcastTo;
|
|
|
|
if (forwardTo === "instance") {
|
|
eventProperties = {
|
|
"instance_id": { type: "integer" },
|
|
...eventProperties,
|
|
};
|
|
|
|
} else if (forwardTo !== "master" && forwardTo !== null) {
|
|
throw new Error(`Invalid forwardTo value ${forwardTo}`);
|
|
}
|
|
|
|
if (broadcastTo !== "instance" && broadcastTo !== null) {
|
|
throw new Error(`Invalid broadcastTo value ${broadcastTo}`);
|
|
}
|
|
|
|
this.eventType = type + "_event";
|
|
this._eventValidator = schema.compile({
|
|
$schema: "http://json-schema.org/draft-07/schema#",
|
|
properties: {
|
|
"type": { const: this.eventType },
|
|
"data": {
|
|
additionalProperties: false,
|
|
required: Object.keys(eventProperties),
|
|
properties: eventProperties,
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Attach to a link
|
|
*
|
|
* Set a the handler for the event on the given link if it's a target
|
|
* for the event.
|
|
*
|
|
* If forwardTo was set to 'master' the `forwardEventToMaster` method on
|
|
* the link is used as the default handler. If it was set to 'instance'
|
|
* the `forwardEventToInstance` method on the link is used by default.
|
|
*
|
|
* If broadcastTo was set to 'instance' the `broadcastEventToInstance`
|
|
* method on the link is invoked before the handler.
|
|
*
|
|
* Does nothing if the link is not a target for this event.
|
|
*
|
|
* @param {Link} link - The link to attach to.
|
|
* @param {Function} handler -
|
|
* Async function to invoke with link set as this to handle the
|
|
* event. Only used on the target side.
|
|
* @throws {Error} if the handler is needed and not defined.
|
|
*/
|
|
attach(link, handler) {
|
|
// Target side. Note: Source and target is reversed here.
|
|
if (this.links.includes(`${link.target}-${link.source}`)) {
|
|
// Use forwarder if handler is not present.
|
|
if (!handler) {
|
|
if (this.forwardTo === "instance") {
|
|
handler = link.forwardEventToInstance;
|
|
} else if (this.forwardTo === "master") {
|
|
handler = link.forwardEventToMaster;
|
|
}
|
|
}
|
|
|
|
if (
|
|
this.broadcastTo === "instance"
|
|
&& [
|
|
"instance-slave", "slave-master", "control-master", "master-slave",
|
|
].includes(`${link.target}-${link.source}`)
|
|
) {
|
|
if (!handler) {
|
|
handler = link.broadcastEventToInstance;
|
|
} else {
|
|
let originalHandler = handler;
|
|
handler = async (message, event) => {
|
|
await link.broadcastEventToInstance(message, event);
|
|
await originalHandler.call(link, message, event);
|
|
};
|
|
}
|
|
}
|
|
|
|
if (!handler) {
|
|
throw new Error(`Missing handler for ${this.eventType} on ${link.source}-${link.target} link`);
|
|
}
|
|
|
|
link.setHandler(this.eventType, message => {
|
|
// XXX Should event handlers even be allowed to be async?
|
|
handler.call(link, message, this).catch(err => {
|
|
console.error(`Unexpected error while handling ${this.eventType}`, err);
|
|
});
|
|
}, this._eventValidator);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send event over the given link
|
|
*
|
|
* Sends the given event data over the link.
|
|
*
|
|
* @param {module:lib/link.Link} link - Link to send event over.
|
|
* @param {Object} data - Data to send with the event.
|
|
*/
|
|
send(link, data = {}) {
|
|
if (!this._eventValidator({ seq: 0, type: this.eventType, data })) {
|
|
console.error(this._eventValidator.errors);
|
|
throw new Error(`Validation failed sending ${this.eventType}`);
|
|
}
|
|
|
|
link.connector.send(this.eventType, data);
|
|
}
|
|
}
|
|
|
|
messages.debugWsMessage = new Event({
|
|
type: "debug_ws_message",
|
|
links: ["master-control"],
|
|
eventProperties: {
|
|
"direction": { type: "string" },
|
|
"content": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.instanceInitialized = new Event({
|
|
type: "instance_initialized",
|
|
links: ["instance-slave", "slave-master"],
|
|
eventProperties: {
|
|
"instance_id": { type: "integer" },
|
|
"plugins": {
|
|
type: "object",
|
|
additionalProperties: { type: "string" },
|
|
},
|
|
},
|
|
});
|
|
messages.instanceStarted = new Event({
|
|
type: "instance_started",
|
|
links: ["instance-slave", "slave-master"],
|
|
eventProperties: {
|
|
"instance_id": { type: "integer" },
|
|
},
|
|
});
|
|
messages.instanceStopped = new Event({
|
|
type: "instance_stopped",
|
|
links: ["instance-slave", "slave-master"],
|
|
eventProperties: {
|
|
"instance_id": { type: "integer" },
|
|
},
|
|
});
|
|
|
|
messages.updateInstances = new Event({
|
|
type: "update_instances",
|
|
links: ["slave-master"],
|
|
eventProperties: {
|
|
"instances": {
|
|
type: "array",
|
|
items: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["serialized_config", "status"],
|
|
properties: {
|
|
"serialized_config": { type: "object" },
|
|
"status": { enum: ["stopped", "initialized", "running"] },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.instanceOutput = new Event({
|
|
type: "instance_output",
|
|
links: ["instance-slave", "slave-master", "master-control"],
|
|
forwardTo: "master",
|
|
eventProperties: {
|
|
"instance_id": { type: "integer" },
|
|
"output": {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["source", "received", "format", "type", "message"],
|
|
properties: {
|
|
"source": { type: "string" },
|
|
"received": { type: "number" },
|
|
"format": { type: "string" },
|
|
"time": { type: "string" },
|
|
"level": { type: "string" },
|
|
"file": { type: "string" },
|
|
"type": { type: "string" },
|
|
"action": { type: "string" },
|
|
"message": { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
messages.masterConnectionEvent = new Event({
|
|
type: "master_connection_event",
|
|
links: ["slave-instance"],
|
|
eventProperties: {
|
|
"event": { type: "string" },
|
|
},
|
|
});
|
|
|
|
messages.playerEvent = new Event({
|
|
type: "player_event",
|
|
links: ["instance-slave", "slave-master"],
|
|
forwardTo: "master",
|
|
eventProperties: {
|
|
"instance_id": { type: "integer" },
|
|
"type": { type: "string", enum: ["join", "leave"] },
|
|
"name": { type: "string" },
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Attaches all requests and events to the given link
|
|
*
|
|
* Loops through all builtin messages defined and attaches all of them
|
|
* to the link. The handler used for the messageis looked up on the
|
|
* link instance as the concatenation of the name of the message, the
|
|
* name of message class, and 'Handler'.
|
|
*
|
|
* @param {module:lib/link.Link} link - Link to attach messages to.
|
|
* @memberof module:lib/link
|
|
*/
|
|
function attachAllMessages(link) {
|
|
for (let [name, message] of Object.entries(messages)) {
|
|
message.attach(link, link[name + message.constructor.name + "Handler"]);
|
|
}
|
|
}
|
|
|
|
|
|
module.exports = {
|
|
Message,
|
|
Request,
|
|
Event,
|
|
|
|
attachAllMessages,
|
|
|
|
messages,
|
|
};
|