vantiv.io 1.0.0

package/src/classes/Managers/Networking/MessageHandler.js

@@ -0,0 +1,110 @@
+class MessageHandler {
+    constructor(server) {
+        this.server = server;
+        this.logger = server.logger;
+        this.metrics = server.metrics;
+        this.eventsManager = server.eventsManager;
+
+        this.fireAndForget = server._fireAndForget;
+        this.requestResponse = server._requestResponse;
+        this.keepAliveManager = server.keepAliveManager;
+        this.await = server.await;
+    }
+
+    handle(data) {
+        this.metrics.increment('messagesReceived');
+
+        setImmediate(() => {
+            try {
+                const message = JSON.parse(data.toString());
+                if (this.validateMessageStructure(message)) {
+                    this._processMessage(message);
+                } else {
+                    this.metrics.increment('invalidMessages');
+                    this.logger.warn('MessageHandler', 'Invalid message structure', {
+                        type: message._type,
+                        preview: data.toString().substring(0, 50)
+                    });
+                }
+            } catch (error) {
+                this.metrics.increment('errors');
+                this.logger.error('MessageHandler', 'Failed to parse WebSocket message', {
+                    error: error.message,
+                    dataLength: data.length,
+                    dataPreview: data.toString().substring(0, 100)
+                });
+            }
+        });
+    }
+
+    _processMessage(message) {
+        if (message._type === 'KeepaliveResponse') {
+            this.keepAliveManager.handlePong();
+            return;
+        }
+
+        if (this.fireAndForget && this.fireAndForget._responseHandler(message)) {
+            return;
+        }
+
+        if (this.requestResponse && this.requestResponse._responseHandler(message)) {
+            return;
+        }
+
+
+        this._processAwaitEvents(message);
+
+        this.metrics.increment('eventsProcessed');
+        this.eventsManager.handleEvent(message);
+    }
+
+    _processAwaitEvents(message) {
+        switch (message._type) {
+            case 'ChatEvent':
+                if (!message.whisper) {
+                    this.await._processEvent('chat', message.user, message.message);
+                } else {
+                    this.await._processEvent('whisper', message.user, message.message);
+                }
+                break;
+
+            case 'TipReactionEvent':
+                this.await._processEvent('tip',
+                    message.sender,
+                    message.receiver,
+                    { type: message.item?.type, amount: message.item?.amount }
+                );
+                break;
+
+            case 'UserMovedEvent':
+                this.await._processEvent('movement',
+                    message.user,
+                    message.position,
+                    message.position.entity_id ? message.position : null
+                );
+                break;
+
+            case 'DirectMessageEvent':
+                this.await._processEvent('direct',
+                    message.user,
+                    message.message,
+                    message.conversation
+                );
+                break;
+        }
+    }
+
+    validateMessageStructure(message) {
+        if (!message || typeof message !== 'object') {
+            return false;
+        }
+
+        if (!message._type || typeof message._type !== 'string') {
+            return false;
+        }
+
+        return true;
+    }
+}
+
+module.exports = MessageHandler;

package/src/classes/Managers/Networking/Request.js

@@ -0,0 +1,329 @@
+const WebSocketConstants = require("highrise-core/src/constants/WebSocketConstants");
+
+class FireAndForgetSender {
+    constructor(websocket) {
+        if (!websocket || typeof websocket.connectionManager.send !== 'function') {
+            throw new Error('WebSocket instance with send method is required');
+        }
+
+        this._ws = websocket;
+        this._pendingOperations = new Map();
+        this._operationId = 0;
+        this._maxRetries = 3;
+        this._retryDelay = 100;
+
+        this._responseHandler = this._responseHandler.bind(this);
+    }
+
+    _responseHandler(message) {
+        try {
+            if (message._type === 'Error' && message.rid) {
+                const operation = this._pendingOperations.get(message.rid);
+                if (operation) {
+                    this._pendingOperations.delete(message.rid);
+
+                    const error = new Error(message.message);
+                    error.do_not_reconnect = message.do_not_reconnect || false;
+                    error.originalData = operation.data;
+
+                    operation.reject(error);
+                    return true;
+                }
+            }
+
+            if (message.rid && this._pendingOperations.has(message.rid)) {
+                const operation = this._pendingOperations.get(message.rid);
+                this._pendingOperations.delete(message.rid);
+                operation.resolve({
+                    success: true,
+                    operationId: message.rid,
+                    response: message
+                });
+                return true;
+            }
+
+        } catch (error) {
+            console.error('Error in response handler:', error);
+        }
+        return false;
+    }
+
+    async send(data, maxRetries = this._maxRetries) {
+        if (!this._ws.isConnected()) {
+            throw new Error('WebSocket is not connected');
+        }
+
+        const operationId = (++this._operationId).toString();
+
+        return new Promise((resolve, reject) => {
+            const operation = {
+                id: operationId,
+                data: this._deepClone(data),
+                attempts: 0,
+                maxRetries: Math.min(maxRetries, 10),
+                timestamp: Date.now(),
+                resolve,
+                reject
+            };
+
+            if (typeof operation.data === 'object' && operation.data !== null) {
+                operation.data.rid = operationId;
+            }
+
+            this._pendingOperations.set(operationId, operation);
+            this._safeSend(operation);
+        });
+    }
+
+    async _safeSend(operation) {
+        try {
+            operation.attempts++;
+            const payload = typeof operation.data === 'string'
+                ? operation.data
+                : JSON.stringify(operation.data);
+
+            this._ws.send(payload);
+
+        } catch (error) {
+            if (operation.attempts < operation.maxRetries) {
+                setTimeout(() => {
+                    this._safeSend(operation);
+                }, this._retryDelay * Math.pow(2, operation.attempts - 1));
+            } else {
+                this._pendingOperations.delete(operation.id);
+                operation.reject(new Error(`Failed after ${operation.attempts} attempts: ${error.message}`));
+            }
+        }
+    }
+
+    _addTimeoutFallback(operationId, timeoutMs = 5000) {
+        return setTimeout(() => {
+            if (this._pendingOperations.has(operationId)) {
+                const operation = this._pendingOperations.get(operationId);
+                this._pendingOperations.delete(operationId);
+
+                console.warn(`Operation ${operationId} timed out after ${timeoutMs}ms`);
+                operation.reject(new Error(`Operation timed out after ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+    }
+
+    _deepClone(obj) {
+        if (obj === null || typeof obj !== 'object') return obj;
+        if (obj instanceof Date) return new Date(obj);
+        if (Array.isArray(obj)) return obj.map(item => this._deepClone(item));
+
+        const cloned = {};
+        Object.keys(obj).forEach(key => {
+            cloned[key] = this._deepClone(obj[key]);
+        });
+        return cloned;
+    }
+
+    getPendingCount() {
+        return this._pendingOperations.size;
+    }
+
+    cancelAll() {
+        this._pendingOperations.clear();
+    }
+
+    setRetryConfig({ maxRetries, retryDelay }) {
+        if (maxRetries !== undefined) {
+            this._maxRetries = Math.max(0, Math.min(maxRetries, 10));
+        }
+        if (retryDelay !== undefined) {
+            this._retryDelay = Math.max(10, Math.min(retryDelay, 5000));
+        }
+    }
+
+    destroy() {
+        this.cancelAll();
+    }
+}
+
+class RequestResponseSender {
+    constructor(websocket, options = {}) {
+        if (!websocket || typeof websocket.connectionManager.send !== 'function') {
+            throw new Error('WebSocket instance with send method is required');
+        }
+
+        this._ws = websocket;
+        this._pendingRequests = new Map();
+        this._requestId = 0;
+        this._defaultTimeout = options.defaultTimeout || WebSocketConstants.DEFAULT_TIMEOUT;
+        this._maxRetries = options.maxRetries || WebSocketConstants.DEFAULT_MAX_RETRIES;
+        this._retryDelay = options.retryDelay || WebSocketConstants.DEFAULT_RETRY_DELAY;
+    }
+
+    _errorHandler(data) {
+        try {
+            const message = JSON.parse(data.toString());
+
+            if (message._type === 'Error' && message.rid) {
+                const requestId = message.rid;
+
+                if (this._pendingRequests.has(requestId)) {
+                    const request = this._pendingRequests.get(requestId);
+                    this._cleanupRequest(requestId);
+                    request.resolvers.reject(new Error(message.message));
+                    return true;
+                }
+                return false;
+            }
+            return false
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async send(data, timeout = this._defaultTimeout, maxRetries = this._maxRetries) {
+        if (!this._ws.isConnected()) {
+            throw new Error('WebSocket is not connected');
+        }
+
+        const requestId = String(++this._requestId);
+        const request = this._createRequest(requestId, data, timeout, maxRetries);
+
+        try {
+            this._pendingRequests.set(requestId, request);
+            return await this._safeSend(request);
+        } catch (error) {
+            this._cleanupRequest(requestId);
+            throw error;
+        }
+    }
+
+    _createRequest(requestId, data, timeout, maxRetries) {
+        const requestData = {
+            ...this._deepClone(data),
+            rid: requestId,
+            timestamp: Date.now()
+        };
+
+        return {
+            id: requestId,
+            data: requestData,
+            attempts: 0,
+            maxRetries: Math.min(maxRetries, 5),
+            timeout: Math.min(Math.max(timeout, 1000), 60000),
+            resolvers: {
+                resolve: null,
+                reject: null
+            },
+            timeoutId: null,
+            timestamp: Date.now()
+        };
+    }
+
+    async _safeSend(request) {
+        return new Promise((resolve, reject) => {
+            request.resolvers = { resolve, reject };
+
+            request.timeoutId = setTimeout(() => {
+                if (this._pendingRequests.has(request.id)) {
+                    this._cleanupRequest(request.id);
+                }
+            }, request.timeout);
+
+            this._executeSend(request);
+        });
+    }
+
+    _executeSend(request) {
+        try {
+            request.attempts++;
+
+            const payload = typeof request.data === 'string'
+                ? request.data
+                : JSON.stringify(request.data);
+
+            this._ws.send(payload);
+
+        } catch (error) {
+            if (request.attempts < request.maxRetries) {
+                const delay = this._retryDelay * Math.pow(2, request.attempts - 1);
+                setTimeout(() => this._executeSend(request), delay);
+            } else {
+                this._cleanupRequest(request.id);
+                request.resolvers.reject(new Error(`Failed after ${request.attempts} attempts: ${error.message}`));
+            }
+        }
+    }
+
+    _responseHandler(message) {
+        try {
+
+            if (message.rid && this._pendingRequests.has(message.rid)) {
+                const request = this._pendingRequests.get(message.rid);
+                this._cleanupRequest(message.rid);
+                request.resolvers.resolve(message);
+                return true;
+            }
+        } catch (error) {
+        }
+        return false;
+    }
+
+    _cleanupRequest(requestId) {
+        const request = this._pendingRequests.get(requestId);
+        if (request) {
+            if (request.timeoutId) {
+                clearTimeout(request.timeoutId);
+            }
+            this._pendingRequests.delete(requestId);
+        }
+    }
+
+    _deepClone(obj) {
+        if (obj === null || typeof obj !== 'object') return obj;
+        if (obj instanceof Date) return new Date(obj);
+        if (obj instanceof Array) return obj.map(item => this._deepClone(item));
+        if (obj instanceof Object) {
+            const cloned = {};
+            Object.keys(obj).forEach(key => {
+                cloned[key] = this._deepClone(obj[key]);
+            });
+            return cloned;
+        }
+    }
+
+    getPendingCount() {
+        return this._pendingRequests.size;
+    }
+
+    cancelRequest(requestId) {
+        const request = this._pendingRequests.get(requestId);
+        if (request) {
+            this._cleanupRequest(requestId);
+            request.resolvers.reject('Request cancelled');
+        }
+    }
+
+    cancelAll() {
+        for (const [requestId, request] of this._pendingRequests) {
+            this._cleanupRequest(requestId);
+            request.resolvers.reject('All requests cancelled');
+        }
+    }
+
+    setConfig({ defaultTimeout, maxRetries, retryDelay }) {
+        if (defaultTimeout !== undefined) {
+            this._defaultTimeout = Math.min(Math.max(defaultTimeout, 1000), 60000);
+        }
+        if (maxRetries !== undefined) {
+            this._maxRetries = Math.max(0, Math.min(maxRetries, 5));
+        }
+        if (retryDelay !== undefined) {
+            this._retryDelay = Math.max(10, Math.min(retryDelay, 5000));
+        }
+    }
+
+    destroy() {
+        this.cancelAll()
+    }
+}
+module.exports = {
+    FireAndForgetSender,
+    RequestResponseSender
+};