Refactor connector logic

Refine the state flow used in the connector abstractions to better
handle close while connecting and resuming.  The new logic is to close
the connection immediately in these two states instead of continuing
trying to connect and then giving up some point later.

For the connectors the handshake state is split into connecting
and resuming, new is replaced by closed, and the closing state is turned
into a boolean flag as it's possible that closing is desired while
connecting, connected or resuming.  The connecting state is not present
in the server connector because there's nothing for the server to do in
that connector state.

The timeout logic is completely removed, once a connection attempt is
started for the client it will continue to attempt to connect, attempt
to resume dropped connections and attempt reconnects until either an
authentication error occurs or the client explicitly requests to close
the connection.

A new session timeout is added to control how long to attempt to resume
the connection until it's considered dead and invalidated.  This allows
stale connections to give up earlier, and swallow up less data while in
the dropped but not yet invalidated state.

For the client side sending messages while it's connecting has been
changed to throw an error instead of queuing up the message and
(possibly) sending it after the connection is established.  Code
shouldn't try to send messages without knowing if the connection it's
trying to send them over is active or not.
This commit is contained in:
Hornwitser committed 2021-08-30 20:20:49 +02:00
1 parent 3e617a81cf
commit de48d807f1
26 files changed
+2042 -821

No files matched your search

+5 -7
View File
@@ -866,13 +866,13 @@ debugCommands.add(new libCommand.Command({
* @private
*/
class ControlConnector extends libLink.WebSocketClientConnector {
constructor(url, reconnectDelay, tlsCa, token) {
super(url, reconnectDelay, tlsCa);
constructor(url, maxReconnectDelay, tlsCa, token) {
super(url, maxReconnectDelay, tlsCa);
this._token = token;
}
register() {
logger.verbose("SOCKET | registering control");
logger.verbose("Connector | registering control");
this.sendHandshake("register_control", {
token: this._token,
agent: "clusterioctl",
@@ -946,8 +946,6 @@ class Control extends libLink.Link {
}
async shutdown() {
this.connector.setTimeout(30);
try {
await libLink.messages.prepareDisconnect.send(this);
} catch (err) {
@@ -956,7 +954,7 @@ class Control extends libLink.Link {
}
}
await this.connector.close(1001, "Control Quit");
await this.connector.close(1000, "Control Quit");
}
}
@@ -1120,7 +1118,7 @@ async function startControl() {
let controlConnector = new ControlConnector(
controlConfig.get("control.master_url"),
controlConfig.get("control.reconnect_delay"),
controlConfig.get("control.max_reconnect_delay"),
tlsCa,
controlConfig.get("control.master_token")
);
+11 -11
View File
@@ -85,14 +85,14 @@ MasterGroup.define({
title: "Heartbeat Interval",
description: "Interval heartbeats are sent out on WebSocket connections",
type: "number",
initial_value: 45,
initial_value: 15,
});
MasterGroup.define({
name: "connector_shutdown_timeout",
title: "Connector Shutdown Timeout",
description: "Timeout in seconds for connectors to properly disconnect on shutdown",
name: "session_timeout",
title: "Session Timeout",
description: "Time in seconds before giving up resuming a dropped WebSocket session.",
type: "number",
initial_value: 30,
initial_value: 60,
});
MasterGroup.define({
name: "metrics_timeout",
@@ -184,11 +184,11 @@ SlaveGroup.define({
initial_value: "localhost",
});
SlaveGroup.define({
name: "reconnect_delay",
title: "Reconnect Delay",
name: "max_reconnect_delay",
title: "Max Reconnect Delay",
description: "Maximum delay to wait before attempting to reconnect WebSocket",
type: "number",
initial_value: 5,
initial_value: 60,
});
SlaveGroup.finalize();
@@ -358,11 +358,11 @@ ControlGroup.define({
optional: true,
});
ControlGroup.define({
name: "reconnect_delay",
title: "Reconnect Delay",
name: "max_reconnect_delay",
title: "Max Reconnect Delay",
description: "Maximum delay to wait before attempting to reconnect WebSocket",
type: "number",
initial_value: 2,
initial_value: 60,
});
ControlGroup.finalize();
+161 -103
View File
@@ -6,6 +6,7 @@ const WebSocket = require("isomorphic-ws");
const libSchema = require("../schema");
const libErrors = require("../errors");
const { logger } = require("../logging");
const ExponentialBackoff = require("../ExponentialBackoff");
/**
@@ -15,9 +16,14 @@ const { logger } = require("../logging");
* @memberof module:lib/link
*/
class WebSocketBaseConnector extends events.EventEmitter {
constructor() {
constructor(sessionTimeout) {
super();
this._sessionTimeout = sessionTimeout;
// One of closed, connecting (client only), connected and resuming.
this._state = "closed";
this._closing = false;
this._socket = null;
this._seq = 1;
this._lastHeartbeat = null;
@@ -27,6 +33,26 @@ class WebSocketBaseConnector extends events.EventEmitter {
this._sendBuffer = [];
}
_reset() {
this._state = "closed";
this._closing = false;
this._socket = null;
this._seq = 1;
this._lastHeartbeat = null;
this._heartbeatId = null;
this._heartbeatInterval = null;
this._lastReceivedSeq = null;
this._sendBuffer.length = 0;
}
_check(...expectedStates) {
if (!expectedStates.includes(this._state)) {
throw new Error(
`Expected state ${expectedStates} but state is ${this._state}`
);
}
}
_dropSendBufferSeq(seq) {
if (seq === null) {
return;
@@ -44,12 +70,10 @@ class WebSocketBaseConnector extends events.EventEmitter {
}
_doHeartbeat() {
this._check(["connected", "closing"]);
this._check("connected");
if (Date.now() - this._lastHeartbeat > 2000 * this._heartbeatInterval) {
logger.verbose("SOCKET | closing after heartbeat timed out");
logger.verbose("Connector | closing after heartbeat timed out");
this._socket.close(1008, "Heartbeat timeout");
clearInterval(this._heartbeatId);
this._heartbeatId = null;
} else {
this._socket.send(JSON.stringify({
@@ -62,7 +86,7 @@ class WebSocketBaseConnector extends events.EventEmitter {
_processHeartbeat(message) {
if (!libSchema.heartbeat(message)) {
logger.warn("SOCKET | closing after received invalid heartbeat");
logger.warn("Connector | closing after received invalid heartbeat");
this._socket.close(1002, "Invalid heartbeat");
return;
}
@@ -91,6 +115,7 @@ class WebSocketBaseConnector extends events.EventEmitter {
if (this._heartbeatId) {
clearInterval(this._heartbeatId);
this._heartbeatId = null;
this._lastHeartbeat = null;
}
}
@@ -102,14 +127,14 @@ class WebSocketBaseConnector extends events.EventEmitter {
* @returns {number} the sequence number of the message sent
*/
send(type, data) {
if (!["handshake", "connected", "closing"].includes(this._state)) {
if (!["connected", "resuming"].includes(this._state)) {
throw new libErrors.SessionLost("No session");
}
let seq = this._seq;
this._seq += 1;
let message = { seq, type, data };
this._sendBuffer.push(message);
if (["connected", "closing"].includes(this._state)) {
if (this._state === "connected") {
this._socket.send(JSON.stringify(message));
}
return seq;
@@ -118,11 +143,11 @@ class WebSocketBaseConnector extends events.EventEmitter {
/**
* Set connection state to closing
*
* Signal the connection is about tho close and that once the close
* Signal the connection is about to close and that once the close
* frame is received it should be considered finished.
*/
setClosing() {
this._state = "closing";
throw new Error("Abstract function");
}
/**
@@ -136,7 +161,7 @@ class WebSocketBaseConnector extends events.EventEmitter {
* True if the connection is closing down or closed
*/
get closing() {
return ["closing", "closed"].includes(this._state);
return this._closing || this._state === "closed";
}
}
@@ -147,41 +172,32 @@ class WebSocketBaseConnector extends events.EventEmitter {
* @memberof module:lib/link
*/
class WebSocketClientConnector extends WebSocketBaseConnector {
constructor(url, reconnectDelay, tlsCa = null) {
super();
constructor(url, maxReconnectDelay, tlsCa = null) {
super(null);
this._url = url;
this._backoff = new ExponentialBackoff({ max: maxReconnectDelay });
this._tlsCa = tlsCa;
// The following states are used in the client connector
// new: Not connected
// handshake: Attempting to (re)connect to server.
// closed: Not connected
// connecting: Attempting to connect to server.
// resuming: Attempting to resume an existing connection to the server.
// connected: Connection is online
// closing: Connection is in the process of being closed.
this._state = "new";
this._reconnectId = null;
this._sessionToken = null;
this._connected = false;
this._reconnectDelay = reconnectDelay;
this._timeout = 15 * 60;
this._startedReconnect = null;
this._startedResuming = null;
}
_check(expectedStates) {
if (!expectedStates.includes(this._state)) {
throw new Error(
`Expected state ${expectedStates} but state is ${this._state}`
);
}
}
setTimeout(timeout) {
this._timeout = timeout;
if (this._reconnectId && this._timeout < this._reconnectDelay / 2) {
clearTimeout(this._reconnectId);
this.reconnect();
}
_reset() {
clearTimeout(this._reconnectId);
this._reconnectId = null;
this._lastReceivedSeq = null;
this._sessionToken = null;
this._sessionTimeout = null;
this._sendBuffer.length = 0;
this._startedResuming = null;
super._reset();
}
/**
@@ -194,7 +210,7 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
* @param {Object} data - Data to send with message.
*/
sendHandshake(type, data) {
this._check(["handshake"]);
this._check("connecting", "resuming");
this._socket.send(JSON.stringify({ seq: null, type, data }));
}
@@ -207,34 +223,53 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
* @param {string} reason - WebSocket close reason.
*/
async close(code, reason) {
if (this._state === "new") {
if (this._state === "closed") {
return;
}
if (this._reconnectId) {
clearTimeout(this._reconnectId);
this._reconnectId = null;
this._lastReceivedSeq = null;
this._sessionToken = null;
this._sendBuffer.length = 0;
this._state = "new";
this._connected = false;
this._closing = true;
if (this._state === "connected" || this._socket) {
this._socket.close(code, reason);
await events.once(this, "close");
} else {
this._reset();
this.emit("close");
}
}
/**
* Notify the connection is expected to close
*
* Sets the internal flag to signal not to attempt to resume the
* connection if the server closes it. This will close the connection
* if it's currently attempting to connect or resume.
*/
setClosing() {
if (this._state === "closed") {
return;
}
this.stopHeartbeat();
this._state = "closing";
this._socket.close(code, reason);
await events.once(this, "close");
this._closing = true;
if (this._state === "connected") {
return;
}
if (this._socket) {
this._socket.close(1000, "Connector closing");
} else {
this._reset();
this.emit("close");
}
}
/**
* Connect to the master server
*/
async connect() {
this._check(["new"]);
this._state = "handshake";
this._check("closed");
this._state = "connecting";
this._doConnect();
@@ -242,12 +277,12 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
await events.once(this, "connect");
}
async _doConnect() {
_doConnect() {
let url = new URL(this._url);
url.pathname += "api/socket";
// Open WebSocket to master
logger.verbose(`SOCKET | connecting to ${url}`);
logger.verbose(`Connector | connecting to ${url}`);
// eslint-disable-next-line node/no-process-env
if (process.env.APP_ENV === "browser") {
@@ -266,69 +301,89 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
* Attempt re-establishing the connecting again
*/
reconnect() {
if (this._socket) {
throw new Error("Cannot reconnect while socket is open");
}
if (this._reconnectId !== null) {
return;
logger.error("Unexpected double call to reconnect");
}
if (this._startedReconnect === null) {
this._startedReconnect = Date.now();
let delay = this._backoff.delay();
if (
this._state === "resuming"
&& this._startedResuming + this._sessionTimeout * 1000 < Date.now() + delay
) {
logger.error("Connector | Session timed out trying to resume");
this._reset();
this._state = "connecting";
this.emit("invalidate");
}
if (this._startedReconnect + this._timeout * 1000 < Date.now()) {
logger.error("SOCKET | Timed out trying to reconnect");
this._heartbeatInterval = null;
this._lastReceivedSeq = null;
this._sessionToken = null;
this._sendBuffer.length = 0;
this._state = "new";
this._connected = false;
this.emit("close");
return;
}
let delay = Math.random() * this._reconnectDelay;
logger.verbose(
`SOCKET | waiting ${delay.toLocaleString("en", { maximumFractionDigits: 2 })} seconds for reconnect`
`Connector | waiting ${(Math.round(delay / 10) / 100)} seconds for reconnect`
);
this._reconnectId = setTimeout(() => {
this._reconnectId = null;
this._doConnect();
}, delay * 1000);
}, delay);
this._reconnectTime = Date.now() + delay;
}
_attachSocketHandlers() {
this._socket.onclose = event => {
logger.verbose(`SOCKET | Close (code: ${event.code}, reason: ${event.reason})`);
const previousState = this._state;
// Authentication failed
if (event.code === 4003) {
this.emit("error", new libErrors.AuthenticationFailed(event.reason));
this._state = "closing";
this._closing = true;
}
if (this._state === "closing") {
this._lastReceivedSeq = null;
this._sessionToken = null;
this._sendBuffer.length = 0;
this._state = "new";
this._connected = false;
this.emit("close");
this._socket = null;
if (this._state === "connected") {
this.stopHeartbeat();
if (this._closing) {
this._reset();
this.emit("close");
} else {
this._state = "resuming";
this._startedResuming = Date.now();
this.reconnect();
this.emit("drop");
}
} else {
this._state = "handshake";
this.reconnect();
if (this._connected) {
this._connected = false;
this.emit("drop");
// eslint-disable-next-line no-lonely-if
if (this._closing) {
this._reset();
this.emit("close");
} else {
this.reconnect();
}
}
this.stopHeartbeat();
// Log must be sent after state change is complete
let message = `Connector | Close (code: ${event.code}, reason: ${event.reason})`;
if (previousState === "connected" && event.code !== 1000) {
logger.info(message);
} else {
logger.verbose(message);
}
};
this._socket.onerror = event => {
// It's assumed that close is always called by ws
let code = !event.error ? "" : `, code: ${event.error.code}`;
logger.error(`SOCKET | Error: ${event.message || "unknown error"}${code}`);
let message = `Connector | Socket error: ${event.message || "unknown error"}${code}`;
if (this._state === "connected") {
logger.error(message);
} else {
// Don't log as error if not actually connected, prevents
// log spam during reconnecting attempts.
logger.verbose(message);
}
if (event.error) {
// Abort connection if certificate validation failed
if ([
@@ -337,22 +392,22 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
"ERR_TLS_CERT_ALTNAME_INVALID",
].includes(event.error.code)) {
this.emit("error", new libErrors.AuthenticationFailed(event.error.message));
this._state = "closing";
this._closing = true;
}
}
};
this._socket.onopen = () => {
logger.verbose("SOCKET | Open");
logger.verbose("Connector | Open");
};
// Handle messages
this._socket.onmessage = event => {
let message = JSON.parse(event.data);
if (this._state === "handshake") {
if (["connecting", "resuming"].includes(this._state)) {
this._processHandshake(message);
} else if (["connected", "closing"].includes(this._state)) {
} else if (this._state === "connected") {
if (message.seq !== null) {
this._lastReceivedSeq = message.seq;
}
@@ -372,17 +427,17 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
_processHandshake(message) {
if (!libSchema.serverHandshake(message)) {
logger.verbose("SOCKET | closing after received invalid handshake");
logger.warn("Connector | closing after received invalid handshake");
this._socket.close(1002, "Invalid handshake");
return;
}
let { seq, type, data } = message;
if (type === "hello") {
logger.verbose(`SOCKET | received hello from master version ${data.version}`);
logger.verbose(`Connector | received hello from master version ${data.version}`);
this.emit("hello", data);
if (this._sessionToken) {
logger.verbose("SOCKET | Attempting resume");
logger.verbose("Connector | Attempting resume");
this.sendHandshake("resume", {
session_token: this._sessionToken,
last_seq: this._lastReceivedSeq,
@@ -392,36 +447,39 @@ class WebSocketClientConnector extends WebSocketBaseConnector {
}
} else if (type === "ready") {
logger.verbose("SOCKET | received ready from master");
logger.verbose("Connector | received ready from master");
this._state = "connected";
this._sessionToken = data.session_token;
this._sessionTimeout = data.session_timeout;
this._heartbeatInterval = data.heartbeat_interval;
this.startHeartbeat();
for (let bufferedMessage of this._sendBuffer) {
this._socket.send(JSON.stringify(bufferedMessage));
}
this._startedReconnect = null;
this._connected = true;
this.emit("connect", data);
} else if (type === "continue") {
logger.verbose("SOCKET | resuming existing session");
logger.info("Connector | resuming existing session");
this._state = "connected";
this._heartbeatInterval = data.heartbeat_interval;
this._sessionTimeout = data.session_timeout;
this.startHeartbeat();
this._dropSendBufferSeq(data.last_seq);
for (let bufferedMessage of this._sendBuffer) {
this._socket.send(JSON.stringify(bufferedMessage));
}
this._startedReconnect = null;
this._connected = true;
this._startedResuming = null;
this.emit("resume");
} else if (type === "invalidate") {
this._heartbeatInterval = null;
logger.warn("Connector | session invalidated by master");
this._state = "connecting";
this._seq = 1;
this._lastReceivedSeq = null;
this._sessionToken = null;
this._sessionTimeout = null;
this._sendBuffer.length = 0;
this._startedResuming = null;
this.emit("invalidate");
this.register();
}
+4 -2
View File
@@ -98,9 +98,10 @@ const serverHandshake = ajv.compile({
"type": { const: "ready" },
"data": {
additionalProperties: false,
required: ["session_token", "heartbeat_interval"],
required: ["session_token", "session_timeout", "heartbeat_interval"],
properties: {
"session_token": { type: "string" },
"session_timeout": { type: "number" },
"heartbeat_interval": { type: "number" },
"account": {
additionalProperties: false,
@@ -118,9 +119,10 @@ const serverHandshake = ajv.compile({
"type": { const: "continue" },
"data": {
additionalProperties: false,
required: ["last_seq", "heartbeat_interval"],
required: ["last_seq", "session_timeout", "heartbeat_interval"],
properties: {
"last_seq": { type: ["integer", "null"] },
"session_timeout": { type: "number" },
"heartbeat_interval": { type: "number" },
},
},
+9 -5
View File
@@ -2,6 +2,7 @@
const jwt = require("jsonwebtoken");
const WebSocket = require("ws");
const libErrors = require("@clusterio/lib/errors");
const { logger } = require("@clusterio/lib/logging");
const libPrometheus = require("@clusterio/lib/prometheus");
const libSchema = require("@clusterio/lib/schema");
@@ -64,12 +65,10 @@ class WsServer {
let disconnectTasks = [];
for (let controlConnection of this.controlConnections) {
controlConnection.connector.setTimeout(this.master.config.get("master.connector_shutdown_timeout"));
disconnectTasks.push(controlConnection.disconnect(1001, "Server Quit"));
}
for (let slaveConnection of this.slaveConnections.values()) {
slaveConnection.connector.setTimeout(this.master.config.get("master.connector_shutdown_timeout"));
disconnectTasks.push(slaveConnection.disconnect(1001, "Server Quit"));
}
@@ -254,8 +253,9 @@ ${err.stack}`
{ aud: this.sessionAud, sid: sessionId },
Buffer.from(this.master.config.get("master.auth_secret"), "base64"),
);
let sessionTimeout = this.master.config.get("master.session_timeout");
let heartbeatInterval = this.master.config.get("master.heartbeat_interval");
let connector = new WsServerConnector(socket, sessionId, heartbeatInterval);
let connector = new WsServerConnector(sessionId, sessionTimeout, heartbeatInterval);
this.activeConnectors.set(sessionId, connector);
connector.on("close", () => {
this.activeConnectors.delete(connector);
@@ -276,6 +276,8 @@ ${err.stack}`
if (this.slaveConnections.get(data.id) === connection) {
this.slaveConnections.delete(data.id);
this.master.slaveUpdated(this.master.slaves.get(data.id));
} else {
logger.warn("Unlisted SlaveConnection closed");
}
});
this.slaveConnections.set(data.id, connection);
@@ -286,9 +288,11 @@ ${err.stack}`
logger.verbose(`WsServer | registered control from ${req.socket.remoteAddress}`);
let connection = new ControlConnection(data, connector, this.master, user);
connector.on("close", () => {
let index = this.controlConnections.indexOf(this);
let index = this.controlConnections.indexOf(connection);
if (index !== -1) {
this.controlConnections.splice(index, 1);
} else {
logger.warn("Unlisted ControlConnection closed");
}
});
this.controlConnections.push(connection);
@@ -297,7 +301,7 @@ ${err.stack}`
};
}
connector.ready(sessionToken, additionalReadyData);
connector.ready(socket, sessionToken, additionalReadyData);
}
}
+54 -50
View File
@@ -12,28 +12,24 @@ const { logger } = require("@clusterio/lib/logging");
* @alias module:master/src/WsServerConnector
*/
class WsServerConnector extends libLink.WebSocketBaseConnector {
constructor(socket, sessionId, heartbeatInterval) {
super();
constructor(sessionId, sessionTimeout, heartbeatInterval) {
super(sessionTimeout);
this._socket = socket;
this._socket = null;
this._sessionId = sessionId;
this._heartbeatInterval = heartbeatInterval;
this._timeoutId = null;
// The following states are used in the server connector
// handshake: Waiting for client to (re)connect.
// closed: Connection is closed
// connected: Connection is online
// closing: Connection is in the process of being closed.
// closed: Connection has been closed
this._state = "handshake";
this._timeout = 15 * 60;
// resuming: Waiting for client to resume.
}
_check(expectedStates) {
if (!expectedStates.includes(this._state)) {
throw new Error(
`Expected state ${expectedStates} but state is ${this._state}`
);
}
_reset() {
clearTimeout(this._timeoutId);
this._timeoutId = null;
super._reset();
}
/**
@@ -41,17 +37,20 @@ class WsServerConnector extends libLink.WebSocketBaseConnector {
*
* Sends the ready message over the socket to initiate the session.
*
* @param {Object} socket - WebSocket connection to client.
* @param {string} sessionToken -
* the session token to send to the client.
* @param {Object=} additionalData -
* extra properties to send along the ready message.
*/
ready(sessionToken, additionalData) {
ready(socket, sessionToken, additionalData) {
this._socket = socket;
this._socket.send(JSON.stringify({
seq: null,
type: "ready",
data: {
session_token: sessionToken,
session_timeout: this._sessionTimeout,
heartbeat_interval: this._heartbeatInterval,
...additionalData,
},
@@ -77,7 +76,7 @@ class WsServerConnector extends libLink.WebSocketBaseConnector {
// stale connection. If this is the case the connector will have to
// wait for the previous socket to close down before it can continue
// from a new socket, or there will be overlapping events from both.
if (["connected", "closing"].includes(this._state)) {
if (this._state === "connected") {
this._socket.close(4003, "Session Hijacked");
// Correctly waiting for the connector to close and then
@@ -102,6 +101,7 @@ class WsServerConnector extends libLink.WebSocketBaseConnector {
type: "continue",
data: {
last_seq: this._lastReceivedSeq,
session_timeout: this._sessionTimeout,
heartbeat_interval: this._heartbeatInterval,
},
}));
@@ -115,63 +115,44 @@ class WsServerConnector extends libLink.WebSocketBaseConnector {
this.emit("resume");
}
setTimeout(timeout) {
if (this._timeoutId) {
clearTimeout(this._timeoutId);
}
this._timeoutId = setTimeout(() => { this._timedOut(); }, timeout * 1000);
this._timeout = timeout;
}
_timedOut() {
logger.verbose("SOCKET | Connection timed out");
this._timeoutId = null;
this._lastReceivedSeq = null;
this._sendBuffer.length = 0;
this._state = "closed";
logger.verbose("Connector | Connection timed out");
this._reset();
this.emit("close");
this.emit("invalidate");
}
_attachSocketHandlers() {
this.startHeartbeat();
this._socket.on("close", (code, reason) => {
logger.verbose(`SOCKET | Close (code: ${code}, reason: ${reason})`);
if (this._state === "closing") {
this._lastReceivedSeq = null;
this._sendBuffer.length = 0;
this._state = "closed";
logger.verbose(`Connector | Close (code: ${code}, reason: ${reason})`);
this.stopHeartbeat();
if (this._closing) {
this._reset();
this.emit("close");
if (this._timeoutId) {
clearTimeout(this._timeoutId);
this._timeoutId = null;
}
} else {
this._state = "handshake";
this._state = "resuming";
this.emit("drop");
this._timeoutId = setTimeout(() => { this._timedOut(); }, this._timeout * 1000);
this._timeoutId = setTimeout(() => { this._timedOut(); }, this._sessionTimeout * 1000);
}
this.stopHeartbeat();
});
this._socket.on("error", err => {
// It's assumed that close is always called by ws
logger.verbose("SOCKET | Error:", err);
logger.verbose("Connector | Error:", err);
});
this._socket.on("open", () => {
logger.verbose("SOCKET | Open");
logger.verbose("Connector | Open");
});
this._socket.on("ping", data => {
logger.verbose(`SOCKET | Ping (data: ${data}`);
logger.verbose(`Connector | Ping (data: ${data}`);
});
this._socket.on("pong", data => {
logger.verbose(`SOCKET | Pong (data: ${data}`);
logger.verbose(`Connector | Pong (data: ${data}`);
});
// Handle messages
@@ -208,11 +189,34 @@ class WsServerConnector extends libLink.WebSocketBaseConnector {
return;
}
this.stopHeartbeat();
this._state = "closing";
if (this._state === "resuming") {
this._reset();
this.emit("close");
return;
}
this._closing = true;
this._socket.close(code, reason);
await events.once(this, "close");
}
/**
* Notify the connection is expected to close
*
* Sets the internal flag to signal not to wait for the client to
* reconnect and resume the connection if the client closes it. This
* will close the connection if it's currently waiting for the client to
* resume it.
*/
setClosing() {
if (this._state === "resuming") {
this._reset();
this.emit("close");
return;
}
this._closing = true;
}
}
module.exports = WsServerConnector;
+4 -4
View File
@@ -972,7 +972,7 @@ class SlaveConnector extends libLink.WebSocketClientConnector {
constructor(slaveConfig, tlsCa, pluginInfos) {
super(
slaveConfig.get("slave.master_url"),
slaveConfig.get("slave.reconnect_delay"),
slaveConfig.get("slave.max_reconnect_delay"),
tlsCa
);
this.slaveConfig = slaveConfig;
@@ -980,7 +980,7 @@ class SlaveConnector extends libLink.WebSocketClientConnector {
}
register() {
logger.info("SOCKET | registering slave");
logger.info("Connector | registering slave");
let plugins = {};
for (let pluginInfo of this.pluginInfos) {
plugins[pluginInfo.name] = pluginInfo.version;
@@ -1598,7 +1598,6 @@ class Slave extends libLink.Link {
return;
}
this._shuttingDown = true;
this.connector.setTimeout(30);
try {
await libLink.messages.prepareDisconnect.send(this);
@@ -1612,7 +1611,7 @@ class Slave extends libLink.Link {
for (let instanceId of this.instanceConnections.keys()) {
await this.stopInstance(instanceId);
}
await this.connector.close(1001, "Slave Shutdown");
await this.connector.close(1000, "Slave Shutdown");
// Clear silly interval in pidfile library.
pidusage.clear();
@@ -1862,6 +1861,7 @@ async function startSlave() {
});
await slaveConnector.connect();
logger.info("Started slave");
}
module.exports = {
+1 -2
View File
@@ -85,8 +85,7 @@ export default async function bootstrap() {
let wsUrl = new URL(window.webRoot, document.location);
wsUrl.protocol = wsUrl.protocol.replace("http", "ws");
let controlConnector = new ControlConnector(wsUrl, 10);
controlConnector.setTimeout(15);
let controlConnector = new ControlConnector(wsUrl, 120);
let control = new Control(controlConnector, plugins);
ReactDOM.render(<App control={control}/>, document.getElementById("root"));
+3 -3
View File
@@ -8,8 +8,8 @@ import packageJson from "../../package.json";
* @private
*/
export class ControlConnector extends libLink.WebSocketClientConnector {
constructor(url, reconnectDelay) {
super(url, reconnectDelay);
constructor(url, maxReconnectDelay) {
super(url, maxReconnectDelay);
this.token = null;
}
@@ -18,7 +18,7 @@ export class ControlConnector extends libLink.WebSocketClientConnector {
throw new Error("Token not set");
}
logger.verbose("SOCKET | registering control");
logger.verbose("Connector | registering control");
this.sendHandshake("register_control", {
token: this.token,
agent: "Clusterio Web UI",