redux-cluster 1.9.2 → 2.0.0

package/dist/cjs/network/client.d.ts

@@ -0,0 +1,23 @@
+import { ReduxClusterStore, ClientSettings } from "../types";
+export declare class ClusterClient {
+    private store;
+    private settings;
+    login?: string;
+    password?: string;
+    private client;
+    private listenOptions;
+    private shouldReconnect;
+    private reconnectTimeout?;
+    constructor(store: ReduxClusterStore, settings?: ClientSettings);
+    private setupCredentials;
+    private setupConnection;
+    private getListenOptions;
+    private setupEventHandlers;
+    private handleConnection;
+    private handleDisconnection;
+    private setupPipeline;
+    private handleServerMessage;
+    private connectToServer;
+    disconnect(): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/cjs/network/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/network/client.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAe,MAAM,UAAU,CAAC;AAG1E,qBAAa,aAAa;IAUtB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAVX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAEzB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,aAAa,CAAM;IAC3B,OAAO,CAAC,eAAe,CAAiB;IACxC,OAAO,CAAC,gBAAgB,CAAC,CAAiB;gBAGhC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,GAAE,cAAmB;IAOvC,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,gBAAgB;IA6CxB,OAAO,CAAC,mBAAmB;IAgB3B,OAAO,CAAC,aAAa;IA2DrB,OAAO,CAAC,mBAAmB;IA4C3B,OAAO,CAAC,eAAe;IAIhB,UAAU,IAAI,IAAI;CAmB1B"}

package/dist/cjs/network/client.js

@@ -0,0 +1,251 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClusterClient = void 0;
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const zlib = __importStar(require("zlib"));
+const stream = __importStar(require("stream"));
+const types_1 = require("../types");
+const crypto_1 = require("../utils/crypto");
+class ClusterClient {
+    constructor(store, settings = {}) {
+        this.store = store;
+        this.settings = settings;
+        this.shouldReconnect = true;
+        this.setupCredentials();
+        this.setupConnection();
+        this.connectToServer();
+    }
+    setupCredentials() {
+        if (typeof this.settings.login === "string") {
+            this.login = (0, crypto_1.hasher)(`REDUX_CLUSTER${this.settings.login}`);
+        }
+        if (typeof this.settings.password === "string") {
+            this.password = (0, crypto_1.hasher)(`REDUX_CLUSTER${this.settings.password}`);
+        }
+    }
+    setupConnection() {
+        this.listenOptions = this.getListenOptions();
+        this.client = new net.Socket();
+        this.setupEventHandlers();
+        this.setupPipeline();
+    }
+    getListenOptions() {
+        const defaultOptions = { port: 10001 };
+        if (typeof this.settings.path === "string") {
+            switch (os.platform()) {
+                case "win32":
+                    return { path: path.join("\\\\?\\pipe", this.settings.path) };
+                default:
+                    return { path: path.join(this.settings.path) };
+            }
+        }
+        const options = { ...defaultOptions };
+        if (typeof this.settings.host === "string") {
+            options.host = this.settings.host;
+        }
+        if (typeof this.settings.port === "number") {
+            options.port = this.settings.port;
+        }
+        return options;
+    }
+    setupEventHandlers() {
+        this.client.on("connect", () => {
+            this.handleConnection();
+        });
+        this.client.on("close", () => {
+            this.handleDisconnection();
+        });
+        this.client.on("error", (err) => {
+            this.store.stderr(`ReduxCluster.createClient client error: ${err.message}`);
+        });
+    }
+    handleConnection() {
+        this.store.connected = true;
+        this.store.sendtoall({
+            _msg: types_1.MessageType.CONN_STATUS,
+            _hash: this.store.RCHash,
+            _connected: true,
+        });
+        // Override write method for object mode + compression
+        this.client.writeNEW = this.client.write;
+        this.client.write = (data) => {
+            try {
+                const compressed = zlib.gzipSync(Buffer.from(JSON.stringify(data)));
+                return this.client.writeNEW(compressed);
+            }
+            catch (err) {
+                this.store.stderr(`ReduxCluster.createClient write error: ${err.message}`);
+                return false;
+            }
+        };
+        // Save original dispatch for local state updates
+        if (typeof this.store.dispatchNEW !== "function") {
+            this.store.dispatchNEW = this.store.dispatch;
+        }
+        // Override dispatch to send actions to server
+        this.store.dispatch = (action) => {
+            this.client.write({
+                _msg: types_1.MessageType.MSG_TO_MASTER,
+                _hash: this.store.RCHash,
+                _action: action,
+            });
+        };
+        // Authenticate with server
+        this.client.write({
+            _msg: types_1.MessageType.SOCKET_AUTH,
+            _hash: this.store.RCHash,
+            _login: this.login,
+            _password: this.password,
+        });
+    }
+    handleDisconnection() {
+        this.store.connected = false;
+        this.store.sendtoall({
+            _msg: types_1.MessageType.CONN_STATUS,
+            _hash: this.store.RCHash,
+            _connected: false,
+        });
+        // Reconnect after 250ms only if reconnection is enabled
+        if (this.shouldReconnect) {
+            this.reconnectTimeout = setTimeout(() => {
+                new ClusterClient(this.store, this.settings);
+            }, 250);
+        }
+    }
+    setupPipeline() {
+        // Create processing pipeline
+        const mbstring = new stream.Transform({
+            transform(buffer, encoding, callback) {
+                this.push(buffer);
+                callback();
+            },
+        });
+        mbstring.setEncoding("utf8");
+        const gunzipper = zlib.createGunzip();
+        // Simple JSON parser
+        const parser = new stream.Transform({
+            objectMode: true,
+            transform(chunk, encoding, callback) {
+                try {
+                    const data = JSON.parse(chunk.toString());
+                    this.push(data);
+                    callback();
+                }
+                catch {
+                    callback(); // Invalid JSON, ignore but continue
+                }
+            },
+        });
+        const eventHandler = new stream.Writable({
+            objectMode: true,
+            write: (data, encoding, callback) => {
+                this.handleServerMessage(data);
+                callback();
+            },
+        });
+        // Setup error handlers
+        [gunzipper, mbstring, parser, eventHandler].forEach((streamObj) => {
+            streamObj.on("error", (err) => {
+                this.store.stderr(`ReduxCluster.createClient stream error: ${err.message}`);
+            });
+        });
+        // Connect pipeline
+        this.client.pipe(gunzipper).pipe(mbstring).pipe(parser).pipe(eventHandler);
+    }
+    handleServerMessage(data) {
+        if (this.client.destroyed || data._hash !== this.store.RCHash) {
+            return;
+        }
+        switch (data._msg) {
+            case types_1.MessageType.MSG_TO_WORKER:
+                // Always use dispatchNEW (original dispatch) for local state updates
+                // because the regular dispatch is overridden to send to server
+                if (this.store.dispatchNEW) {
+                    // Mark SYNC actions as internal
+                    let actionToDispatch = data._action;
+                    if (actionToDispatch.type === "REDUX_CLUSTER_SYNC") {
+                        actionToDispatch = { ...actionToDispatch, _internal: true };
+                    }
+                    this.store.dispatchNEW(actionToDispatch);
+                }
+                else {
+                    this.store.stderr("dispatchNEW method not available");
+                }
+                break;
+            case types_1.MessageType.SOCKET_AUTH_STATE:
+                if (data._value === true) {
+                    // Authentication successful, request initial state
+                    this.client.write({
+                        _msg: types_1.MessageType.START,
+                        _hash: this.store.RCHash,
+                    });
+                }
+                else {
+                    // Authentication failed
+                    const error = data._banned
+                        ? new Error("your ip is locked for 3 hours")
+                        : new Error("authorization failed");
+                    this.client.destroy(error);
+                }
+                break;
+            default:
+                // Ignore unknown message types
+                break;
+        }
+    }
+    connectToServer() {
+        this.client.connect(this.listenOptions);
+    }
+    disconnect() {
+        this.shouldReconnect = false;
+        // Clear reconnection timeout if it exists
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = undefined;
+        }
+        // Remove all event listeners
+        if (this.client) {
+            this.client.removeAllListeners();
+            // Destroy the socket
+            if (!this.client.destroyed) {
+                this.client.destroy();
+            }
+        }
+    }
+}
+exports.ClusterClient = ClusterClient;

package/dist/cjs/network/server.d.ts

@@ -0,0 +1,39 @@
+import { ServerSettings, ReduxClusterStore, ClusterMessage, ClusterSocket } from "../types";
+export declare class ClusterServer {
+    private store;
+    private settings;
+    readonly uid: string;
+    readonly sockets: Record<string, ClusterSocket>;
+    readonly database: Record<string, string>;
+    readonly ip2ban: Record<string, {
+        time: number;
+        count: number;
+    }>;
+    private readonly ip2banTimeout;
+    private readonly ip2banGC;
+    private server;
+    private unsubscribe?;
+    private shouldAutoRestart;
+    constructor(store: ReduxClusterStore, settings?: ServerSettings);
+    private setupDatabase;
+    private setupBanSystem;
+    private cleanupBannedIPs;
+    private setupServer;
+    private getListenOptions;
+    private startListening;
+    private handleNewConnection;
+    private isIPBanned;
+    private rejectConnection;
+    private setupSocket;
+    private setupSocketPipeline;
+    private handleSocketMessage;
+    private handleAuthentication;
+    private recordFailedLogin;
+    private closeSocket;
+    private setupStoreIntegration;
+    sendtoall(message?: ClusterMessage): void;
+    ip2banGCStop(): void;
+    private cleanup;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=server.d.ts.map

package/dist/cjs/network/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/network/server.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,cAAc,EAEd,aAAa,EACd,MAAM,UAAU,CAAC;AAGlB,qBAAa,aAAa;IAatB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAblB,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,SAAgB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAM;IAC5D,SAAgB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM;IACtD,SAAgB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAM;IAE7E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAY;IAC1C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiB;IAC1C,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,iBAAiB,CAAiB;gBAGhC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,GAAE,cAAmB;IAavC,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,WAAW;IA8CnB,OAAO,CAAC,gBAAgB;IAuBxB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,mBAAmB;IAmB3B,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,gBAAgB;IAyBxB,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,mBAAmB;IA2D3B,OAAO,CAAC,mBAAmB;IA0C3B,OAAO,CAAC,oBAAoB;IAyD5B,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,qBAAqB;IActB,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAezC,YAAY,IAAI,IAAI;IAI3B,OAAO,CAAC,OAAO;IAQR,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAiD9B"}