@resolveio/server-lib 12.5.52 → 12.5.54

package/src/server-app.ts

@@ -0,0 +1,769 @@
+import { createServer, Server } from 'http';
+import * as express from 'express';
+import * as bodyParser from 'body-parser';
+import * as xmlParser from 'express-xml-bodyparser';
+import * as WebSocket from 'ws';
+import * as jwt from 'jsonwebtoken';
+import { v4 as uuidv4 } from 'uuid';
+// import * as SegfaultHandler from 'segfault-handler';
+import * as moment from 'moment';
+
+import { dateReviver, getBinarySize, deepCopy } from './util/common';
+
+import { objectIdHexString } from './managers/mongo.manager';
+import { CronManager } from './managers/cron.manager';
+import { MethodManager } from './managers/method.manager';
+import { SubscriptionManager } from './managers/subscription.manager';
+import { MonitorManager, MonitorManagerFunction } from './managers/monitor.manager';
+
+import { ServerResponseModel } from './models/server-response.model';
+
+import { MethodResponses } from './collections/method-response.collection';
+import { Logs } from './collections/log.collection';
+import { LogMethodLatencies } from './collections/log-method-latency.collection';
+import { Users } from './collections/user.collection';
+
+import { setupHomeRoutes } from './http/home';
+import { setupAuthRoutes } from './http/auth';
+import { setupHealthRoutes } from './http/health';
+import { ResolveIOServer } from './index';
+
+export default class ResolveIOMainServer {
+	private _app: express.Application;
+	private _serverHTTP: Server;
+	private _portHTTP: string | number;
+	private _serverWSS: WebSocket.Server;
+	private _portWSS: number;
+	private _serverConfig;
+	private _clientDir;
+	private _offlineUpdates = [];
+	private _msgQueue = [];
+	private _msgQueueRunning = false;
+	public sesMail = false;
+	private standardProgram = false;
+	private publicProgram = false;
+	private _rebootFlag = false;
+
+	private LOGGER = 'ERROR'; //ERROR / DEBUG
+
+	private _monitorManager: MonitorManager;
+	private _monitorManagerFunction: MonitorManagerFunction;
+	private _subscriptionManager: SubscriptionManager;
+	private _methodManager: MethodManager;
+	private _cronManager: CronManager;
+	private _clientRoutes: string[] = [];
+
+	private _serverStartTime: Date;
+	private _lastErrorMsg: Date = null;
+
+	private _debugMsgRecv = 0;
+	private _debugMsgQueue = 0;
+
+	constructor(mainServer, serverConfig, clientRoutes, clientDir, sesMail, standardProgram, publicProgram = false) {
+		this._serverConfig = serverConfig;
+		this._clientRoutes = clientRoutes;
+		this._clientDir = clientDir;
+		this.sesMail = sesMail;
+		this.standardProgram = standardProgram;
+		this.publicProgram = publicProgram;
+
+		this._serverStartTime = new Date();
+		this._lastErrorMsg = null;
+		this._monitorManager = new MonitorManager(mainServer, serverConfig);
+		this._monitorManagerFunction = new MonitorManagerFunction();
+
+		setInterval(() => {
+			if (this._subscriptionManager.getEnableDebug()) {
+				console.log(new Date(), 'Server App', 'Msg Queue Length', this._msgQueue.length);
+				console.log(new Date(), 'Server App', 'Msg Recv Hits', this._debugMsgRecv);
+				console.log(new Date(), 'Server App', 'Msg Queue Hits', this._debugMsgQueue);
+			}
+
+			this._debugMsgQueue = 0;
+			this._debugMsgRecv = 0;
+		}, 60000);
+
+		process.on('unhandledRejection', async (error, rej) => {
+			console.error(new Date(), 'Unhandled Rejection at Promise', [error, rej]);
+
+			let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+
+			if (error && error['name'] === 'MongoError' && error['message'] === 'not master') {
+				if (diffTimeSec > 60 && !this._lastErrorMsg) {
+					this._lastErrorMsg = new Date();
+
+					setTimeout(() => {
+						this._lastErrorMsg = null;
+					}, 60000);
+
+					await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+				}
+
+				process.exit(1);
+			}
+			else if (error && error['name'] === 'MongoError' && error['message'] === 'not master and slaveOk=false') {
+				if (diffTimeSec > 60 && !this._lastErrorMsg) {
+					this._lastErrorMsg = new Date();
+
+					setTimeout(() => {
+						this._lastErrorMsg = null;
+					}, 60000);
+
+					await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+				}
+
+				process.exit(1);
+			}
+			else if (error) {
+				if (error['name'] !== 'StatusError' && error['message'] !== '') {
+					if (diffTimeSec > 60 && !this._lastErrorMsg) {
+						this._lastErrorMsg = new Date();
+
+						setTimeout(() => {
+							this._lastErrorMsg = null;
+						}, 60000);
+
+						this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+					}
+				}
+			}
+		});
+
+		process.on('uncaughtException', async error => {
+			console.error(error, 'Uncaught Exception thrown');
+
+			let diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+
+			if (diffTimeSec > 60 && !this._lastErrorMsg) {
+				this._lastErrorMsg = new Date();
+
+				setTimeout(() => {
+					this._lastErrorMsg = null;
+				}, 60000);
+				
+				await this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Exception - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+			}
+		});
+
+		//PM2 wants to reboot/restart
+		process.on('SIGINT', () => {
+			this._rebootFlag = true;
+			this._serverHTTP.close();
+			this.safeShutdown();
+		});
+
+		process.on('SIGTERM', () => {
+			this._rebootFlag = true;
+			this._serverHTTP.close();
+			this.safeShutdown();
+		});
+
+		process.on('SIGQUIT', () => {
+			this._rebootFlag = true;
+			this._serverHTTP.close();
+			this.safeShutdown();
+		});
+
+		if (this.LOGGER === 'DEBUG') {
+			console.log('Starting ResolveIO Server');
+		}
+
+		// Start express app
+		this._app = express();
+
+		// Use body parser for http call (login)
+		this._app.use(bodyParser.json({limit: '50mb', reviver: dateReviver}));
+		this._app.use(bodyParser.urlencoded({limit: '50mb', extended: true, parameterLimit: 1000000 }));
+		this._app.use(xmlParser());
+		
+		// Set port
+		this._portHTTP = process.env.PORT_HTTP || serverConfig['PORT_HTTP'] || 8080;
+		this._portWSS = process.env.PORT_WSS || serverConfig['PORT_WSS'] || 8081;
+
+		if (this.LOGGER === 'DEBUG') {
+			console.log('Setup ports');
+		}
+
+		// Create http server and websock server
+		this.createServer();
+
+		if (this.LOGGER === 'DEBUG') {
+			console.log('Create server');
+		}
+		
+		// Set CORS
+		this._app.use(function (req, res, next) {
+
+			// Website you wish to allow to connect
+			// res.setHeader('Access-Control-Allow-Origin', serverConfig['ROOT_URL']);
+			res.setHeader('Access-Control-Allow-Origin', '*');
+		
+			// Request methods you wish to allow
+			// res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
+			res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
+		
+			// Request headers you wish to allow
+			res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
+		
+			// Set to true if you need the website to include cookies in the requests sent
+			// to the API (e.g. in case you use sessions)
+			res.setHeader('Access-Control-Allow-Credentials', 'false');
+		
+			// Pass to next layer of middleware
+			next();
+		});
+
+		if (this.LOGGER === 'DEBUG') {
+			console.log('Setup cors');
+		}
+
+		// Set up http login route
+		setupAuthRoutes(this, this._app, serverConfig);
+		setupHealthRoutes(this._app, serverConfig);
+
+		if (serverConfig['CLIENT_NAME'] === 'ResolveIO' || this.standardProgram) {
+			setupHomeRoutes(this, this._app, serverConfig);
+		}
+
+		if (this.LOGGER === 'DEBUG') {
+			console.log('Setup express routes');
+		}
+	}
+
+	private safeShutdown() {
+		console.log(new Date(), 'Safe Shutdown Command Received');
+		if (
+			!this._monitorManagerFunction.getActiveMonitorFunctions().length && 
+			// (!this._monitorManagerFunction.getLastCompletedMonitorFunction() ||
+			// Date.now() >= this._monitorManagerFunction.getLastCompletedMonitorFunction().endTime.getTime() + 1500) &&
+			!this._msgQueue.length &&
+			!this._msgQueueRunning &&
+			!this._offlineUpdates.length
+		) {
+			ResolveIOServer.getMongoConnection().close(false, () => {
+				console.log(new Date(), 'Safe Exit Complete, Process Exit');
+				process.exit(0);
+			});
+		}
+		else {
+			console.log(new Date(), 
+				'Safe Exit In Progress', 
+				this._monitorManagerFunction.getActiveMonitorFunctions().length, 
+				// this._monitorManagerFunction.getLastCompletedMonitorFunction() ? this._monitorManagerFunction.getLastCompletedMonitorFunction().endTime : '',
+				this._msgQueue.length, 
+				this._msgQueueRunning,
+				this._offlineUpdates.length
+			);
+
+			setImmediate(() => {
+				this.safeShutdown();
+			});
+		}
+	}
+
+	public getWS(id_ws: string) {
+		return Array.from(this._serverWSS.clients).filter(a => a['id_socket'] === id_ws)[0];
+	}
+
+	public getWSList() {
+		let res = [];
+
+		this._serverWSS.clients.forEach((ws: WebSocket) => {
+			res.push(ws['id_socket']);
+		});
+
+		return res;
+	}
+
+	public getWSUserList() {
+		let res = [];
+
+		this._serverWSS.clients.forEach((ws: WebSocket) => {
+			res.push(ws['id_user']);
+		});
+
+		return res;
+	}
+
+	public getHTTPServer() {
+		return this._serverHTTP;
+	}
+
+	public getCronManager() {
+		return this._cronManager;
+	}
+
+	public getMethodManager() {
+		return this._methodManager;
+	}
+
+	public getSubscriptionManager() {
+		return this._subscriptionManager;
+	}
+
+	public getMonitorManager() {
+		return this._monitorManager;
+	}
+
+	public getRebootFlag() {
+		return this._rebootFlag;
+	}
+
+	private createServer(): void {
+		// Start express server
+		this._serverHTTP = createServer(this._app);
+		this._serverHTTP.keepAliveTimeout = 65000;
+		this._serverHTTP.headersTimeout = 66000; // This should be bigger than `keepAliveTimeout + your server's expected response time`
+
+		// Start websocket server
+		// Verify client with token before opening socket
+		this._serverWSS = new WebSocket.Server({ 
+			port: this._portWSS,
+			verifyClient: this.publicProgram ? null : async (info, cb) => {
+				if (this._rebootFlag) {
+					cb(false, 409, 'Unable To Process');
+				}
+				else {
+					if (this.LOGGER === 'DEBUG') {
+						console.log('Verify Client', info, cb);
+					}
+
+					let infoData = (<string>info.req.headers['sec-websocket-protocol']).split(/,/);
+
+					if (info.origin !== this._serverConfig['ROOT_URL'] && info.origin !== this._serverConfig['SEC_ROOT_URL'] && info.origin !== this._serverConfig['RESOLVEIO_URL'] && info.origin !== this._serverConfig['RESOLVEIO_SECONDARY_URL']) {
+						cb(false, 401, 'Unauthorized');
+					}
+					else {
+						let token = infoData[0];
+						if (!token) {
+							cb(false, 401, 'Unauthorized');
+						}
+						else {
+							jwt.verify(token, this._serverConfig['JWT_SECRET'], async (err, decoded) => {
+								if (err) {
+									cb(false, 401, 'Unauthorized');
+								}
+								else {
+									info.req['id_user'] = decoded['id_user'];
+									try {
+										let user = await Users.findById(decoded['id_user']);
+										if (user) {
+											info.req['user'] = user.fullname;
+											info.req['user_readonly'] = user.readonly || false;
+											info.req['doc_user'] = user;
+											cb(true);
+										}
+										else {
+											cb(false);
+										}
+									}
+									catch (err) {
+										cb(false);
+									}
+								}
+							});
+						}
+					}
+				}
+			}
+		});
+
+		// Start MongoDB Connection
+		this.setUpMongo();
+	}
+
+	private setUpMongo() {
+		if (this.LOGGER === 'DEBUG') {
+			console.log('Start Managers');
+		}
+
+		// Start Managers
+		this._subscriptionManager = new SubscriptionManager(this, this._serverWSS, this._serverConfig, this._monitorManagerFunction);
+		this._methodManager = new MethodManager(this, this._serverConfig, this._clientDir, this._monitorManagerFunction);
+		this._cronManager = new CronManager(this);
+
+		if (this.LOGGER === 'DEBUG') {
+			console.log('End Managers');
+		}
+
+		this.listen();
+	}
+
+	// Listen to port for websocket
+	private listen(): void {
+		this._serverHTTP.listen(this._portHTTP, () => {
+			console.log('Running server on port %s', this._portHTTP);
+		});
+
+		this._serverWSS.on('listening', () => {
+			console.log('Running server on port %s', this._portWSS);
+		});
+
+		// On websocket connection (already verified)
+		this._serverWSS.on('connection', (ws, req) => {
+			if (!this.publicProgram) {
+				// Get user from token
+				ws['id_user'] = req['id_user'];
+				ws['user'] = req['user'];
+				ws['user_readonly'] = req['user_readonly'];
+				ws['doc_user'] = req['doc_user'];
+
+				if (ws['user'] !== 'Admin' && this._serverConfig['CLIENT_NAME'] !== 'ResolveIO') {
+					this.getMethodManager().callMethodInternal.call(this.getMethodManager(), 'supportCreateBillingUser', {
+						id_user: ws['id_user'],
+						user: ws['user'],
+						date: new Date(),
+						client: ResolveIOServer.getClientName()
+					});
+				}
+			}
+			
+			let idSocket = '';
+
+			while (!idSocket || Array.from(this._serverWSS.clients).some(a => a['id_socket'] === idSocket)) {
+				idSocket = uuidv4();
+			}
+
+			ws['id_socket'] = idSocket;
+			ws['retryCnt'] = 0;
+
+			this._subscriptionManager.createLoggedInUser(idSocket).then(() => {
+				setTimeout(() => {
+					ws['pingTime'] = new Date();
+					ws.ping(() => {});
+				}, 5000);
+			});
+
+			if (this.LOGGER === 'DEBUG') {
+				console.log('Connection from: ' + req['user']);
+			}
+			
+			// Use for keeping connection alive (ping/pong)
+			ws['isAlive'] = true;
+			ws.on('pong', () => {
+				ws['isAlive'] = true;
+				ws['pongTime'] = new Date();
+				ws['latency'] = moment.duration(moment(ws['pongTime']).diff(ws['pingTime'])).asMilliseconds();
+				this._subscriptionManager.loggedInLatency(ws);
+			});
+
+			// On data received (message)
+			ws.on('message', async (message: string) => {
+				if (this.LOGGER === 'DEBUG') {
+					console.log('Message from: ' + ws['user'], message);
+				}
+
+				this._debugMsgRecv += 1;
+
+				let parseErrorFound = false;
+
+				let socketData = [];
+				
+				try {
+					socketData = JSON.parse(message, dateReviver);
+				}
+				catch(e) {
+					console.log('Error - JSON.parse', message);
+					
+					this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - JSON Parse Error - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([message, e]));
+
+					parseErrorFound = true;
+				}
+
+				if (!parseErrorFound) {
+					if (socketData[0] === 'ping') {
+						if (ws && ws.readyState === ws.OPEN) {
+							ws.send('pong', (error) => {
+								if (error) {
+									console.log('Error on WS: ', error);
+									if (this._subscriptionManager.getEnableDebug()) {
+										console.log(new Date(), 'Server App', 'Error WS Pong');
+									}
+									this.unsubscribeWS(ws);
+								}
+							});
+						}
+		
+						return;
+					}
+
+					let messageRoute = socketData[0];
+
+					if (!this.publicProgram && this._clientRoutes.some(a => messageRoute.includes(a)) && !ws['doc_user'].roles.groups.some(a => a.views.some(b => messageRoute.includes(b))) && !ws['doc_user'].roles.super_admin) {
+						return;
+					}
+
+					let messageDate = socketData[1];
+					let messageId = socketData[2]
+					let type = socketData[3]
+
+					if (type === 'subscription') {
+						let subType = socketData[4];
+						let pub = socketData[5];
+		
+						// Subscribe
+						if (subType === 'sub') {
+							this._subscriptionManager.subscribe(messageRoute, messageDate, ws, messageId, pub, socketData.slice(6));
+						}
+						// Unsubscribe
+						else {
+							this._subscriptionManager.unsubscribe(messageRoute, messageDate, ws, messageId, pub, socketData.slice(6));
+						}
+					}
+					else if (!this.publicProgram && type === 'offline') {
+						let serverRes: ServerResponseModel = {
+							messageId: messageId,
+							hasError: false,
+							data: 'ACK'
+						};
+		
+						if (ws && ws.readyState === ws.OPEN) {
+							ws.send(JSON.stringify(serverRes), (error) => {
+								if (error) {
+									console.log('Error on WS: ', error);
+									if (this._subscriptionManager.getEnableDebug()) {
+										console.log(new Date(), 'Server App', 'Error WS Offline Ack Main');
+									}
+									this.unsubscribeWS(ws);
+								}
+							});
+						}
+
+						this._offlineUpdates.push(ws);
+						let offlineUpdates = socketData[4];
+
+						for (let i = 0; i < offlineUpdates.length; i++) {
+							let update = offlineUpdates[i];
+							let data = update.data;
+
+							let serverResMethod: ServerResponseModel = {
+								messageId: update.data[2],
+								hasError: false,
+								data: 'ACK'
+							};
+			
+							if (ws && ws.readyState === ws.OPEN) {
+								ws.send(JSON.stringify(serverResMethod), (error) => {
+									if (error) {
+										console.log('Error on WS: ', error);
+										if (this._subscriptionManager.getEnableDebug()) {
+											console.log(new Date(), 'Server App', 'Error WS Offline Ack Each');
+										}
+										this.unsubscribeWS(ws);
+									}
+								});
+							}
+
+							let updateRoute = data.shift();
+							let updateDate = data.shift();
+							let updateMessageId = data.shift();
+							let updateType = data.shift();
+							let method = data.shift();
+							let methodLatencyId = objectIdHexString();
+
+							LogMethodLatencies.create({
+								_id: methodLatencyId,
+								__v: 0,
+								date_start: new Date(),
+								date_end: null,
+								latency_ms: 0,
+								method: method
+							});
+			
+							if (method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'getDrivers' && method !== 'processAirdropDistribution') {
+								Logs.insertOne({
+									_id: objectIdHexString(),
+									type: 'client-request',
+									collection: '',
+									id_document: '',
+									payload: getBinarySize(JSON.stringify(data)) < 200000 ? JSON.stringify(data, null, 2) : 'Too Big',
+									method: method,
+									id_user: ws['id_user'] || '',
+									user: ws['user'] || '',
+									messageId: messageId,
+									route: messageRoute
+								});
+							}
+
+							if (this._methodManager._methods[method]) {
+								try {
+									await this._methodManager.callMethodInternal.call(Object.assign({}, this._methodManager, {id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket']}), method, ...data);
+								}
+								catch (err) {
+									console.log(new Date(), 'Offline Error', JSON.stringify(err, null, 2));
+								}
+
+								if (method === 'updateDocumentOffline' || method === 'updateDocumentPropsOffline') {
+									ResolveIOServer.getMongoManager().invalidateQueryCache(data[0]);
+								}
+							}
+							else {
+								console.log('Offline - Could not find method: ' + method);
+							}
+						}
+
+						this._offlineUpdates.splice(this._offlineUpdates.map(a => a['id_socket']).indexOf(ws['id_socket']), 1);
+					}
+					else { //methods
+						this._msgQueue.splice(0, 0, {
+							ws: ws,
+							data: socketData
+						});
+					}
+				}
+			});
+
+			ws.on('close', () => {
+				this.unsubscribeWS(ws);
+				if (this._subscriptionManager.getEnableDebug()) {
+					console.log(new Date(), 'Server App', 'WS Close');
+				}
+			});
+
+			ws.on('error', error => {
+				console.log(new Date(), ws['user'], ws['id_socket'], 'WS Error');
+				
+				this.unsubscribeWS(ws);
+			});
+		});
+
+		// Keep alive timer to ping/pong
+		setInterval(() => {
+			this._serverWSS.clients.forEach((ws: WebSocket) => {
+				if (ws['pingTime'] && Date.now() - ws['pingTime'].getTime() >= 20000) {
+					if (ws['isAlive'] === false) {
+						ws['retryCnt']++;
+
+						if (ws['retryCnt'] >= 3) {
+							this.unsubscribeWS(ws);
+							console.log(new Date(), ws['user'], ws['id_socket'], 'Ping Retry', ws['retryCnt'], ws['pingTime'], ws['pongTime']);
+						}
+						else {
+							ws['pingTime'] = new Date();
+							ws.ping(() => {});
+						}
+					}
+					else {
+						ws['retryCnt'] = 0;
+						ws['isAlive'] = false;
+						ws['pingTime'] = new Date();
+						ws.ping(() => {});
+					}
+				}
+			});
+		}, 20000);
+
+		setInterval(() => {
+			if (!this._msgQueueRunning) {				
+				if (this._msgQueue.length) {
+					this._msgQueueRunning = true;
+					this._debugMsgQueue += 1;
+
+					let msg = this._msgQueue.pop();
+					let data = msg.data;
+					let ws = msg.ws;
+		
+					let messageRoute: string = data.shift();
+					let messageDate: Date = data.shift();
+					let messageId: number = data.shift();
+					let type: string = data.shift();
+		
+					// Method call
+					if (type === 'method') {
+						let method = data.shift();
+
+						if (ws['user_readonly']) {
+							return;
+						}
+
+						let methodLatencyId = objectIdHexString();
+
+						LogMethodLatencies.create({
+							_id: methodLatencyId,
+							__v: 0,
+							date_start: new Date(),
+							date_end: null,
+							latency_ms: 0,
+							method: method
+						});
+		
+						if (method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'getDrivers' && method !== 'processAirdropDistribution') {
+							Logs.insertOne({
+								_id: objectIdHexString(),
+								type: 'client-request',
+								collection: '',
+								id_document: '',
+								payload: getBinarySize(JSON.stringify(data)) < 200000 ? JSON.stringify(data, null, 2) : 'Too Big',
+								method: method,
+								id_user: ws['id_user'] || '',
+								user: ws['user'] || '',
+								messageId: messageId,
+								route: messageRoute
+							});
+						}
+		
+						let serverRes: ServerResponseModel = {
+							messageId: messageId,
+							hasError: false,
+							data: 'ACK'
+						};
+		
+						if (ws && ws.readyState === ws.OPEN) {
+							ws.send(JSON.stringify(serverRes), (error) => {
+								if (error) {
+									console.log('Error on WS: ', error);
+									this.unsubscribeWS(ws);
+								}
+							});
+						}
+		
+						if (this._methodManager._methods[method]) {
+							this._methodManager.callMethod(methodLatencyId, ws, messageDate, messageId, method, ...data);
+						}
+						else {
+							console.log('Could not find method: ' + method);
+						}
+					}
+					else if (type === 'methodResponse') {
+						let method = data.shift();
+		
+						MethodResponses.findOne({$and: [
+							{id_user: ws['id_user']}, 
+							{message_id: messageId},
+							{method: method},
+							{date: messageDate}
+						]}).then(res => {
+							if (res) {
+								if (ws && ws.readyState === ws.OPEN) {
+									ws.send(JSON.stringify(res.response), (error) => {
+										if (error) {
+											console.log('Error on WS: ', error);
+											this.unsubscribeWS(ws);
+										}
+									});
+								}
+							}
+						}, err => {});
+					}
+					
+					this._msgQueueRunning = false;
+				}
+			}
+		}, 25);
+	}
+
+	public unsubscribeWS(ws: WebSocket) {
+		if (this._subscriptionManager.getEnableDebug()) {
+			console.log(new Date(), 'Server App', 'Unsub WS', ws['user'], ws['id_socket']);
+		}
+		this._subscriptionManager.unsubscribeAll(ws);
+	}
+
+	public getApp() {
+		return this._app;
+	}
+
+	public getServerConfig() {
+		return this._serverConfig;
+	}
+}