1119 lines
20 KiB
JavaScript
1119 lines
20 KiB
JavaScript
/*
|
|
|
|
Copyright (c) 2020, 2023, The Unified Company.
|
|
|
|
This code is part of Unify.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the ESA Software Community License - Strong Copyleft LICENSE,
|
|
as published by the ESA.
|
|
See the ESA Software Community License - Strong Copyleft LICENSE, for more details.
|
|
|
|
https://unifyjs.org
|
|
|
|
*/
|
|
|
|
import socketMessage from '../unify/socketMessage.js';
|
|
|
|
import uws from '../node_modules/uws/uws.js';
|
|
|
|
import http from 'http';
|
|
|
|
import https from 'https';
|
|
|
|
import socketClient from './socketClient.js';
|
|
|
|
import objectManager from './objectManager.js';
|
|
|
|
import Console from '../server/console.js';
|
|
|
|
import webConsole from '../unify/console.js';
|
|
|
|
import tools from '../unify/tools.js';
|
|
|
|
import deepclone from '../unify/clonedeep.js';
|
|
|
|
import applications from '../configs/applications.js';
|
|
|
|
import unify from '../unify/unify.js';
|
|
|
|
import defaultObject from '../unify/defaultObject.js';
|
|
|
|
import path from 'path';
|
|
|
|
import groupsFlat from './themeGroups.js';
|
|
|
|
import moduleLoader from '../server/moduleLoader.js';
|
|
|
|
import imports from './imports.js';
|
|
|
|
import { RateLimiterMemory, BurstyRateLimiter } from '../node_modules/node-rate-limiter-flexible/index.js';
|
|
|
|
global.isListening = false;
|
|
|
|
|
|
global.cachePromise = new Array();
|
|
|
|
global.cacheResolve = new Array();
|
|
|
|
for (var i = 0; i < 1000000; i++) {
|
|
|
|
global.cachePromise[i] = new Promise(function( resolve ) {
|
|
|
|
global.cacheResolve[i] = resolve;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
export default class socketManager{
|
|
|
|
userID = 0;
|
|
|
|
port = 4437;
|
|
|
|
host = "localhost";
|
|
|
|
cacheTreshold = 100;
|
|
|
|
cacheSize = 50;
|
|
|
|
cachePointer = 0;
|
|
|
|
|
|
|
|
|
|
|
|
cacheDelay = 30;
|
|
|
|
cacheBusy = false;
|
|
|
|
blockedRemoteAddresses = new Array();
|
|
|
|
|
|
clients = new Array();
|
|
|
|
sessionClients = new Array();
|
|
|
|
objectManager = new objectManager();
|
|
|
|
moduleLoader = new moduleLoader();
|
|
|
|
|
|
clientID = 0;
|
|
|
|
socket;
|
|
|
|
core;
|
|
|
|
hotSwapping;
|
|
|
|
applicationID;
|
|
|
|
|
|
applicationURLArray;
|
|
|
|
httpsServer;
|
|
|
|
application;
|
|
|
|
|
|
constructor( port ){
|
|
|
|
if( port ) {
|
|
|
|
this.port = port;
|
|
|
|
}
|
|
|
|
global.socketManager = this;
|
|
|
|
this.initializeLimiter();
|
|
|
|
}
|
|
|
|
async checkRateLimiter( remoteAddress ) {
|
|
|
|
console.log("remoteAddress", remoteAddress);
|
|
|
|
var allow = await this.rateLimiter.consume( remoteAddress, 2 )
|
|
.then(() => {
|
|
|
|
return true;
|
|
|
|
})
|
|
.catch(() => {
|
|
|
|
return false;
|
|
|
|
});
|
|
|
|
if( !allow ) {
|
|
|
|
if( global.mode == "development" ) {
|
|
|
|
console.log("To many connections from same ip. Connection rejected.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return allow;
|
|
|
|
}
|
|
|
|
initializeLimiter() {
|
|
|
|
this.burstyLimiter = new BurstyRateLimiter(
|
|
|
|
new RateLimiterMemory({
|
|
points: 50,
|
|
duration: 1,
|
|
}),
|
|
|
|
new RateLimiterMemory({
|
|
points: 150,
|
|
duration: 3,
|
|
})
|
|
|
|
);
|
|
|
|
this.rateLimiter = new RateLimiterMemory({
|
|
points: 100,
|
|
duration: 1,
|
|
});
|
|
|
|
}
|
|
setApplicationID( applicationID ) {
|
|
|
|
this.applicationID = applicationID;
|
|
|
|
}
|
|
|
|
setApplication( application ) {
|
|
|
|
this.application = application;
|
|
|
|
}
|
|
|
|
create() {
|
|
|
|
this.cacheDelay = ( 10 - global.cacheBuildSpeed ) * 20;
|
|
|
|
if( global.mode == "development" ) {
|
|
|
|
this.cacheTreshold = 1;
|
|
|
|
console.log( "Max number of clients ", global.maxClients, ",But set to", this.cacheTreshold, "Because the server is running in developer mode." );
|
|
|
|
//this.cacheTreshold = global.maxClients;
|
|
|
|
} else {
|
|
|
|
console.log( "Max number of clients ", global.maxClients );
|
|
|
|
this.cacheTreshold = global.maxClients;
|
|
|
|
}
|
|
|
|
|
|
|
|
console.log( "Cache build speed ", global.cacheBuildSpeed, "(" + this.cacheDelay + "ms delay per client)" );
|
|
|
|
|
|
|
|
|
|
if( !global.isListening ) {
|
|
|
|
this.fileUpdater();
|
|
|
|
global.isListening = true;
|
|
|
|
}
|
|
|
|
|
|
var socketManager = this;
|
|
|
|
//var privateKey = fs.readFileSync('./sslCertificates/privkey.pem', 'utf8');
|
|
|
|
//var certificate = fs.readFileSync('./sslCertificates/fullchain.pem', 'utf8');
|
|
|
|
var socket = {
|
|
|
|
compression: 0,
|
|
|
|
maxPayloadLength: 16 * 1024 * 1024,
|
|
|
|
idleTimeout: 60,
|
|
|
|
open: async function( ws, req ) {
|
|
|
|
/*
|
|
ws [
|
|
'__defineGetter__', '__defineSetter__',
|
|
'__lookupGetter__', '__lookupSetter__',
|
|
'close', 'constructor',
|
|
'cork', 'end',
|
|
'getBufferedAmount', 'getRemoteAddress',
|
|
'getRemoteAddressAsText', 'getTopics',
|
|
'getUserData', 'hasOwnProperty',
|
|
'isPrototypeOf', 'isSubscribed',
|
|
'ping', 'propertyIsEnumerable',
|
|
'publish', 'send',
|
|
'sendFirstFragment', 'sendFragment',
|
|
'sendLastFragment', 'subscribe',
|
|
'toLocaleString', 'toString',
|
|
'unsubscribe', 'valueOf'
|
|
]
|
|
*/
|
|
|
|
var buffer = ws.getRemoteAddressAsText();
|
|
|
|
var remoteAddress = new TextDecoder().decode( new Int8Array( buffer ) );
|
|
|
|
var allow = await socketManager.checkRateLimiter( remoteAddress );
|
|
|
|
if( !allow ) {
|
|
|
|
console.log("Connection Rejected.");
|
|
|
|
ws.close();
|
|
|
|
//socketManager.blockedRemoteAddresses.push( remoteAddress );
|
|
|
|
return true;
|
|
|
|
} else {
|
|
|
|
console.log("Connection Accepted.");
|
|
|
|
}
|
|
|
|
ws.socket = socket;
|
|
|
|
|
|
|
|
|
|
socketManager.connection( ws )
|
|
|
|
},
|
|
|
|
message: async function( ws, buf ) {
|
|
|
|
//var message = String.fromCharCode.apply( null, new Int8Array( buf ) );
|
|
/*
|
|
var buffer = ws.getRemoteAddressAsText();
|
|
|
|
var remoteAddress = new TextDecoder().decode( new Int8Array( buffer ) );
|
|
|
|
|
|
if( socketManager.blockedRemoteAddresses.includes( remoteAddress ) ) {
|
|
|
|
ws.close();
|
|
|
|
return true;
|
|
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
var message = new TextDecoder().decode( new Int8Array( buf ) );
|
|
|
|
if( !ws.client ) {
|
|
|
|
//console.log("userID", message, socketManager.userID);
|
|
var client = await socketManager.connectionCallback( ws, message );
|
|
|
|
ws.client = await client;
|
|
|
|
}
|
|
|
|
if( !ws.client ) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
ws.client.message( message, client )
|
|
|
|
},
|
|
|
|
close: ( ws, code, message ) => {
|
|
|
|
//ws.client.destroy()
|
|
|
|
var client = ws.client;
|
|
|
|
if( client ) {
|
|
|
|
client.destroy();
|
|
|
|
}
|
|
/*
|
|
console.log("socket.closed on cluster:", global.clusterID );
|
|
|
|
var socketManager = client.socketManager;
|
|
|
|
var userID = client.userID;
|
|
|
|
console.log("socket closed", userID, Object.keys( socketManager.clients) );
|
|
|
|
|
|
var exists = socketManager.clients[ userID ];
|
|
|
|
if( exists ) {
|
|
|
|
console.log("client still exists, starting timer.");
|
|
|
|
client.destroyTimerCallback = function() {
|
|
|
|
client.destroy();
|
|
|
|
var exists = socketManager.clients[ userID ];
|
|
|
|
console.log("Timer exceeded, Client is removed.", typeof exists);
|
|
|
|
}
|
|
|
|
client.destroyTimer = setTimeout( client.destroyTimerCallback, client.destroyTime );
|
|
|
|
} else {
|
|
|
|
//console.log( "client is destroyed" );
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( !global.ssl ) {
|
|
|
|
var socketServer = uws.App();
|
|
|
|
this.socket = socketServer.ws( '/*', socket ).listen( this.port,function( token ) {
|
|
|
|
if( token ) {
|
|
|
|
console.log(`Listening to port ${socketManager.port}`);
|
|
|
|
} else {
|
|
|
|
console.log(`Failed to listen to port ${port}`);
|
|
|
|
}
|
|
|
|
|
|
});
|
|
|
|
console.log("socket server started on port: " , this.port );
|
|
|
|
} else {
|
|
|
|
|
|
|
|
|
|
var socketServer = uws.SSLApp({
|
|
|
|
key_file_name: './sslCertificates/privkey.pem',
|
|
|
|
cert_file_name: './sslCertificates/fullchain.pem'
|
|
|
|
});
|
|
|
|
|
|
this.socket = socketServer.ws( '/*', socket ).listen( this.port,function( token ) {
|
|
|
|
if( token ) {
|
|
|
|
console.log(`Listening to port ${socketManager.port}`);
|
|
|
|
} else {
|
|
|
|
console.log(`Failed to listen to port ${port}`);
|
|
|
|
}
|
|
|
|
|
|
});
|
|
|
|
console.log("started Secure socket server: ", this.port);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
global.applicationCache = new Array();
|
|
|
|
|
|
this.createCache( this.cacheSize );
|
|
|
|
this.createEventListeners();
|
|
|
|
}
|
|
|
|
async createCache( how_many ) {
|
|
|
|
if( !this.cacheBusy ) {
|
|
|
|
this.cacheBusy = true;
|
|
|
|
var cachedItems = this.cachePointer;
|
|
|
|
var client = new Object();
|
|
|
|
client.classObjects = new Array();
|
|
|
|
client.objects = new Array();
|
|
|
|
|
|
var defaultInstance = new defaultObject();
|
|
|
|
var startTime = Date.now();
|
|
|
|
var allObjects = new Array();
|
|
|
|
var methods = tools.getAllFuncs( defaultInstance );
|
|
|
|
for ( var i = this.cachePointer; i < this.cachePointer + how_many; i++ ) {
|
|
|
|
var cacheObject = new Object();
|
|
|
|
cacheObject.client = new Object();
|
|
|
|
cacheObject.client.classObjects = new Array();
|
|
|
|
cacheObject.client.objects = new Array();
|
|
|
|
//cacheObject.application = structuredClone(beginObject);
|
|
|
|
cacheObject.application = new imports[ this.applicationID ]();
|
|
|
|
|
|
global.core.collectObjects( cacheObject.application, cacheObject.client );
|
|
|
|
var objects = cacheObject.client.objects;
|
|
|
|
for (var k = 0; k < objects.length; k++) {
|
|
|
|
var object = objects[k]
|
|
|
|
for (var j = 0; j < methods.length; j++) {
|
|
|
|
var method = methods[j];
|
|
|
|
const ommit = new Array( '', 'setJoinID', 'reset', 'isOrExtendsClass', 'hasClass', 'getTableName', 'delete', 'appendToSelector', 'agregateDefaultObject', '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', 'valueOf', 'constructor', 'toLocaleString', 'toString' );
|
|
|
|
if( ommit.includes( method ) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if(!object[method]) {
|
|
// this takes most time
|
|
object[method] = defaultInstance[method];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
global.core.prepareObject( object, cacheObject.client );
|
|
|
|
global.core.tableManager.parse( object );
|
|
|
|
|
|
|
|
}
|
|
|
|
await tools.delay( this.cacheDelay );
|
|
|
|
//console.log("create cache", i);
|
|
|
|
global.applicationCache[i] = cacheObject;
|
|
|
|
global.cacheResolve[i]();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
console.log("\n\n\n\n");
|
|
|
|
console.log("cached ", how_many, "client Environments.")
|
|
|
|
console.log("Total cached ", Object.keys(global.applicationCache).length, "client Environments.")
|
|
|
|
console.log("On Cluster ", global.clusterID);
|
|
|
|
console.log("in ", (Date.now() - startTime ) / 1000, "Seconds" );
|
|
|
|
console.log("from ", this.cachePointer, "to", this.cachePointer + how_many);
|
|
|
|
console.log("\n\n");
|
|
|
|
this.cachePointer = this.cachePointer + how_many;
|
|
|
|
this.cacheBusy = false;
|
|
|
|
if( this.cachePointer < this.cacheTreshold ) {
|
|
|
|
this.createCache( this.cacheSize );
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
/*
|
|
createCacheFastest( how_many ) {
|
|
|
|
var cachedItems = global.applicationCache.length;
|
|
|
|
var client = new Object();
|
|
|
|
client.classObjects = new Array();
|
|
|
|
client.objects = new Array();
|
|
|
|
|
|
var beginObject = new imports[ this.applicationID ]();
|
|
|
|
var removedMethods = new Array();
|
|
|
|
var collectionStorage = new Array();
|
|
|
|
var tableStorage = new Array();
|
|
|
|
|
|
|
|
|
|
global.core.getTables( beginObject, tableStorage );
|
|
|
|
global.core.prepareClone( beginObject, removedMethods );
|
|
|
|
global.core.removeCollectionObject( beginObject, false, collectionStorage );
|
|
|
|
|
|
//console.log(beginObject);
|
|
var defaultInstance = new defaultObject();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var startTime = Date.now();
|
|
|
|
var allObjects = new Array();
|
|
|
|
for ( var i = cachedItems; i < cachedItems + how_many; i++ ) {
|
|
|
|
var cacheObject = new Object();
|
|
|
|
cacheObject.client = new Object();
|
|
|
|
cacheObject.client.classObjects = new Array();
|
|
|
|
cacheObject.client.objects = new Array();
|
|
|
|
cacheObject.application = structuredClone(beginObject);
|
|
|
|
|
|
|
|
//cacheObject.application = new imports[ this.applicationID ]();
|
|
|
|
global.core.fastParse( cacheObject.application, cacheObject.client, true );
|
|
|
|
allObjects = [...allObjects, ...cacheObject.client.objects]
|
|
|
|
console.log("create cache", i);
|
|
|
|
global.applicationCache[i] = cacheObject;
|
|
|
|
}
|
|
|
|
//console.log("time taken", (Date.now() - startTime ) / 1000 );
|
|
|
|
|
|
//var startTime = Date.now();
|
|
|
|
|
|
|
|
|
|
//console.log("all objects ", allObjects.length);
|
|
|
|
var methods = tools.getAllFuncs( defaultInstance );
|
|
|
|
|
|
|
|
for ( var i = 0; i < allObjects.length; i++ ) {
|
|
|
|
var object = allObjects[i];
|
|
|
|
//var nodeMethodsString = object.__nodeMethods;
|
|
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
|
|
if( object.type == "table" ) {
|
|
|
|
|
|
|
|
object.table = tableStorage[className]
|
|
|
|
}
|
|
|
|
|
|
var currentRemoved = removedMethods[className];
|
|
|
|
//if(currentRemoved)
|
|
//console.log("reconstructing", className, Object.keys( currentRemoved ).length);
|
|
|
|
if( currentRemoved ) {
|
|
|
|
var keys = Object.keys( currentRemoved );
|
|
|
|
for (var j = 0; j < keys.length; j++) {
|
|
|
|
var removedMethodName = keys[j]
|
|
|
|
var removedMethod = removedMethods[className][removedMethodName]
|
|
|
|
object[ removedMethodName ] = removedMethod;
|
|
|
|
//console.log(className, removedMethodName, removedMethod);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
switch( object.type ) {
|
|
|
|
case "renderCollection":
|
|
|
|
object.object = collectionStorage[ className ]
|
|
|
|
if( object.collections[0] ) {
|
|
|
|
object.collections[0].object = collectionStorage[ className ];
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
case "collection":
|
|
|
|
var className = tools.getClassName( object );
|
|
|
|
if( object.parent ) {
|
|
|
|
var parentClassName = tools.getClassName( object.parent );
|
|
|
|
if(object.parentName) {
|
|
|
|
object.object = collectionStorage[ object.parentName ];
|
|
}
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (var j = 0; j < methods.length; j++) {
|
|
|
|
var method = methods[j];
|
|
|
|
if(!object[method]) {
|
|
|
|
|
|
object[method] = defaultInstance[method];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//console.log(method, defaultInstance[method]);
|
|
|
|
}
|
|
|
|
|
|
global.core.prepareObject( object, false );
|
|
|
|
global.core.tableManager.parse( object );
|
|
|
|
}
|
|
|
|
//console.log(global.applicationCache[0]);
|
|
|
|
console.log("time taken", (Date.now() - startTime ) / 1000 );
|
|
|
|
|
|
console.log("cached " + how_many + " client Environments.");
|
|
|
|
console.log("from ", cachedItems, "to", cachedItems + how_many);
|
|
}
|
|
|
|
*/
|
|
|
|
createEventListeners() {
|
|
|
|
var socketManager = this;
|
|
|
|
//this.socket.on('connection', function( socket ){ socketManager.connection( socket ) });
|
|
|
|
}
|
|
|
|
recycleClient( userID ) {
|
|
|
|
//delete global.applicationCache[ userID ];
|
|
|
|
var client = this.clients[ userID ];
|
|
|
|
|
|
if( client.sessionKey ) {
|
|
|
|
delete this.sessionClients[ client.sessionKey ];
|
|
|
|
}
|
|
|
|
|
|
var cacheObject = global.applicationCache[ userID ];
|
|
|
|
var objects = cacheObject.client.objects;
|
|
|
|
//console.log("global.applicationCache", userID, objects.length );
|
|
|
|
for (var i = 0; i < objects.length; i++) {
|
|
|
|
var object = objects[i];
|
|
|
|
object.value = false;
|
|
|
|
object.id = 0;
|
|
|
|
|
|
if( object.type == "renderCollection" ) {
|
|
|
|
object.empty( cacheObject.client );
|
|
|
|
/*
|
|
|
|
var collection = this.getCollection();
|
|
|
|
if( collection ) {
|
|
|
|
for (var j = 0; j < rows.length; j++) {
|
|
|
|
var row = rows[j];
|
|
|
|
delete this[row.propertyName];
|
|
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
}
|
|
|
|
object.user = false
|
|
|
|
}
|
|
|
|
delete global.applicationCache[ userID ];
|
|
|
|
global.applicationCache.push( cacheObject );
|
|
|
|
this.cachePointer++;
|
|
|
|
console.log("recycled cacheObject", global.applicationCache.length);
|
|
|
|
|
|
delete this.clients[ userID ];
|
|
|
|
|
|
|
|
}
|
|
|
|
removeClient( userID ) {
|
|
|
|
console.log( "RemoveClient with id", userID);
|
|
|
|
console.log( "Clients:", Object.keys( this.clients ) );
|
|
|
|
var clients = this.clients;
|
|
|
|
|
|
|
|
|
|
this.recycleClient( userID );
|
|
|
|
|
|
this.objectManager.removeObjectsByClientID( userID );
|
|
|
|
|
|
console.log( "Clients:", Object.keys( this.clients ) );
|
|
|
|
}
|
|
|
|
getClientBySessionKey( sessionKey ) {
|
|
|
|
var clients = this.clients;
|
|
console.log( "getClientBySessionKey", Object.keys(this.sessionClients), sessionKey);
|
|
|
|
return this.sessionClients[ sessionKey ];
|
|
|
|
}
|
|
|
|
async addClient( id, socket ) {
|
|
|
|
var newClient = new socketClient( this.port );
|
|
|
|
newClient.userID = id;
|
|
|
|
newClient.socket = socket;
|
|
|
|
newClient.socketManager = this;
|
|
|
|
newClient.core = this.core;
|
|
|
|
newClient.application = this.application;
|
|
|
|
await newClient.createSocket( socket );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
this.clients[ id ] = newClient;
|
|
|
|
this.sessionClients[ newClient.sessionKey ] = newClient;
|
|
|
|
// numClients = this.clientID++;
|
|
|
|
|
|
if( id >= this.cachePointer - this.cacheTreshold ) {
|
|
|
|
this.createCache( this.cacheSize );
|
|
|
|
}
|
|
|
|
return newClient;
|
|
|
|
}
|
|
|
|
createInitiationMessage() {
|
|
|
|
var message = new socketMessage();
|
|
|
|
message.id = 0;
|
|
|
|
message.data = "connected";
|
|
|
|
message.type = "promise";
|
|
|
|
return message;
|
|
|
|
}
|
|
|
|
async registerClient( socket, message ) {
|
|
|
|
var userID = this.userID;
|
|
|
|
var client2 = await this.addClient( userID, socket );
|
|
|
|
console.log( "Client connected: ", userID );
|
|
|
|
var object = new Object();
|
|
|
|
//object.sessionKey = client.sessionKey;
|
|
|
|
//var returnMessage = client.createValidMessage( message, object );
|
|
|
|
//client.send( returnMessage );
|
|
|
|
//this.userID++;
|
|
|
|
return client2;
|
|
|
|
}
|
|
|
|
reEstablishConnection( client, socket, message ) {
|
|
|
|
client.socket = socket;
|
|
|
|
if( client.destroyTimerCallback ) {
|
|
|
|
clearTimeout( client.destroyTimer );
|
|
|
|
console.log( "destroyTimerCallback cleared." );
|
|
|
|
}
|
|
|
|
client.createEventListeners();
|
|
|
|
console.log( "Client found, Socket re-established.", client.id );
|
|
|
|
|
|
var object = new Object();
|
|
|
|
object.data = "Connection re-established";
|
|
|
|
object.sessionKey = client.sessionKey;
|
|
|
|
var returnMessage = client.createValidMessage( message, object );
|
|
|
|
client.send( returnMessage );
|
|
|
|
}
|
|
|
|
async reconnectClient( socket, message ) {
|
|
|
|
console.log( "reconnectClient", "Cluster number:", global.clusterID, message.object );
|
|
|
|
var client = this.getClientBySessionKey( message.object );
|
|
|
|
if( client ) {
|
|
|
|
this.reEstablishConnection( client, socket, message );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async connectionCallback( socket, json ){
|
|
|
|
|
|
|
|
var string = tools.serializeString( json );
|
|
|
|
var message = tools.serializeJSON( string );
|
|
|
|
switch( message.type ) {
|
|
|
|
case "registerClient":
|
|
|
|
var client = await this.registerClient( socket, message );
|
|
|
|
this.userID++;
|
|
|
|
return client;
|
|
|
|
break;
|
|
|
|
case "reconnectClient":
|
|
|
|
this.reconnectClient( socket, message );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
connection( socket ) {
|
|
|
|
if( global.consoleLog ) {
|
|
|
|
console.log = global.consoleLog;
|
|
|
|
}
|
|
|
|
var that = this;
|
|
|
|
//socket.on( 'message', async function( json ) { that.connectionCallback( socket, json ); } );
|
|
|
|
var message = this.createInitiationMessage();
|
|
|
|
socket.send( JSON.stringify( message ) );
|
|
|
|
if( global.mode == "development" ) {
|
|
|
|
console.log( "Number connected clients: ", Object.keys( this.clients ).length );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
log( parameter1, parameter2, parameter3 ) {
|
|
|
|
var parameters = webConsole.parseParameters( parameter1, parameter2, parameter3 );
|
|
|
|
this.logClients( parameters );
|
|
|
|
}
|
|
|
|
logClients( parameters ) {
|
|
|
|
for(var c = 0; c<this.clients.length;c++) {
|
|
|
|
var client = this.clients[c];
|
|
|
|
client.logClient( parameters );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
instantiateHotSwapping( hotSwapping ) {
|
|
|
|
if( hotSwapping ) {
|
|
|
|
var that = this;
|
|
|
|
try{
|
|
|
|
var clients = that.clients;
|
|
|
|
this.hotSwapping = new hotSwapping.default( clients );
|
|
|
|
} catch( error ) {
|
|
|
|
console.log("An error was made,", error);
|
|
|
|
that.fileUpdater();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async fileUpdater() {
|
|
|
|
if( process.platform != "android" && global.mode == "development" ) {
|
|
|
|
var hotSwapping = await import( /* webpackIgnore: true */ "./hotSwapping.js" );
|
|
|
|
this.instantiateHotSwapping( hotSwapping );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|