ioredis-om 5.10.2

package/built/cluster/ShardedSubscriber.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("./util");
+const utils_1 = require("../utils");
+const Redis_1 = require("../Redis");
+const debug = (0, utils_1.Debug)("cluster:subscriberGroup:shardedSubscriber");
+const SubscriberStatus = {
+    IDLE: "idle",
+    STARTING: "starting",
+    CONNECTED: "connected",
+    STOPPING: "stopping",
+    ENDED: "ended",
+};
+const ALLOWED_STATUS_UPDATES = {
+    [SubscriberStatus.IDLE]: [
+        SubscriberStatus.STARTING,
+        SubscriberStatus.STOPPING,
+        SubscriberStatus.ENDED,
+    ],
+    [SubscriberStatus.STARTING]: [
+        SubscriberStatus.CONNECTED,
+        SubscriberStatus.STOPPING,
+        SubscriberStatus.ENDED,
+    ],
+    [SubscriberStatus.CONNECTED]: [
+        SubscriberStatus.STOPPING,
+        SubscriberStatus.ENDED,
+    ],
+    [SubscriberStatus.STOPPING]: [SubscriberStatus.ENDED],
+    [SubscriberStatus.ENDED]: [],
+};
+class ShardedSubscriber {
+    constructor(emitter, options, redisOptions) {
+        var _a;
+        this.emitter = emitter;
+        this.status = SubscriberStatus.IDLE;
+        this.instance = null;
+        this.connectPromise = null;
+        // Store listener references for cleanup
+        this.messageListeners = new Map();
+        this.onEnd = () => {
+            this.updateStatus(SubscriberStatus.ENDED);
+            this.emitter.emit("-node", this.instance, this.nodeKey);
+        };
+        this.onError = (error) => {
+            this.emitter.emit("nodeError", error, this.nodeKey);
+        };
+        this.onMoved = () => {
+            this.emitter.emit("moved");
+        };
+        this.instance = new Redis_1.default((0, utils_1.defaults)({
+            enableReadyCheck: false,
+            enableOfflineQueue: true,
+            connectionName: (0, util_1.getConnectionName)("ssubscriber", options.connectionName),
+            /**
+             * Disable auto reconnection for subscribers.
+             * The ClusterSubscriberGroup will handle the reconnection.
+             */
+            retryStrategy: null,
+            lazyConnect: true,
+        }, options, redisOptions));
+        this.lazyConnect = (_a = redisOptions === null || redisOptions === void 0 ? void 0 : redisOptions.lazyConnect) !== null && _a !== void 0 ? _a : true;
+        this.nodeKey = (0, util_1.getNodeKey)(options);
+        // Register listeners
+        this.instance.on("end", this.onEnd);
+        this.instance.on("error", this.onError);
+        this.instance.on("moved", this.onMoved);
+        for (const event of ["smessage", "smessageBuffer"]) {
+            const listener = (...args) => {
+                this.emitter.emit(event, ...args);
+            };
+            this.messageListeners.set(event, listener);
+            this.instance.on(event, listener);
+        }
+    }
+    async start() {
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+        if (this.status === SubscriberStatus.STARTING ||
+            this.status === SubscriberStatus.CONNECTED) {
+            return;
+        }
+        if (this.status === SubscriberStatus.ENDED || !this.instance) {
+            throw new Error(`Sharded subscriber ${this.nodeKey} cannot be restarted once ended.`);
+        }
+        this.updateStatus(SubscriberStatus.STARTING);
+        this.connectPromise = this.instance.connect();
+        try {
+            await this.connectPromise;
+            this.updateStatus(SubscriberStatus.CONNECTED);
+        }
+        catch (err) {
+            this.updateStatus(SubscriberStatus.ENDED);
+            throw err;
+        }
+        finally {
+            this.connectPromise = null;
+        }
+    }
+    stop() {
+        this.updateStatus(SubscriberStatus.STOPPING);
+        if (this.instance) {
+            this.instance.disconnect();
+            this.instance.removeAllListeners();
+            this.messageListeners.clear();
+            this.instance = null;
+        }
+        this.updateStatus(SubscriberStatus.ENDED);
+        debug("stopped %s", this.nodeKey);
+    }
+    isStarted() {
+        return [
+            SubscriberStatus.CONNECTED,
+            SubscriberStatus.STARTING,
+        ].includes(this.status);
+    }
+    get subscriberStatus() {
+        return this.status;
+    }
+    isHealthy() {
+        return ((this.status === SubscriberStatus.IDLE ||
+            this.status === SubscriberStatus.CONNECTED ||
+            this.status === SubscriberStatus.STARTING) &&
+            this.instance !== null);
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getNodeKey() {
+        return this.nodeKey;
+    }
+    isLazyConnect() {
+        return this.lazyConnect;
+    }
+    updateStatus(nextStatus) {
+        if (this.status === nextStatus) {
+            return;
+        }
+        if (!ALLOWED_STATUS_UPDATES[this.status].includes(nextStatus)) {
+            debug("Invalid status transition for %s: %s -> %s", this.nodeKey, this.status, nextStatus);
+            return;
+        }
+        this.status = nextStatus;
+    }
+}
+exports.default = ShardedSubscriber;

package/built/cluster/index.d.ts

@@ -0,0 +1,163 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import Command from "../Command";
+import Redis from "../Redis";
+import ScanStream from "../ScanStream";
+import { Transaction } from "../transaction";
+import { Callback, ScanStreamOptions, WriteableStream } from "../types";
+import Commander from "../utils/Commander";
+import { ClusterOptions } from "./ClusterOptions";
+import { NodeKey, NodeRole } from "./util";
+export declare type ClusterNode = string | number | {
+    host?: string | undefined;
+    port?: number | undefined;
+};
+declare type ClusterStatus = "end" | "close" | "wait" | "connecting" | "connect" | "ready" | "reconnecting" | "disconnecting";
+/**
+ * Client for the official Redis Cluster
+ */
+declare class Cluster extends Commander {
+    options: ClusterOptions;
+    slots: NodeKey[][];
+    status: ClusterStatus;
+    /**
+     * @ignore
+     */
+    _groupsIds: {
+        [key: string]: number;
+    };
+    /**
+     * @ignore
+     */
+    _groupsBySlot: number[];
+    /**
+     * @ignore
+     */
+    isCluster: boolean;
+    private startupNodes;
+    private connectionPool;
+    private manuallyClosing;
+    private retryAttempts;
+    private delayQueue;
+    private offlineQueue;
+    private subscriber;
+    private shardedSubscribers;
+    private slotsTimer;
+    private reconnectTimeout;
+    private isRefreshing;
+    private _refreshSlotsCacheCallbacks;
+    private _autoPipelines;
+    private _runningAutoPipelines;
+    private _readyDelayedCallbacks;
+    private subscriberGroupEmitter;
+    /**
+     * Every time Cluster#connect() is called, this value will be
+     * auto-incrementing. The purpose of this value is used for
+     * discarding previous connect attampts when creating a new
+     * connection.
+     */
+    private connectionEpoch;
+    /**
+     * Creates an instance of Cluster.
+     */
+    constructor(startupNodes: ClusterNode[], options?: ClusterOptions);
+    /**
+     * Connect to a cluster
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from every node in the cluster.
+     */
+    disconnect(reconnect?: boolean): void;
+    /**
+     * Quit the cluster gracefully.
+     */
+    quit(callback?: Callback<"OK">): Promise<"OK">;
+    /**
+     * Create a new instance with the same startup nodes and options as the current one.
+     *
+     * @example
+     * ```js
+     * var cluster = new Redis.Cluster([{ host: "127.0.0.1", port: "30001" }]);
+     * var anotherCluster = cluster.duplicate();
+     * ```
+     */
+    duplicate(overrideStartupNodes?: any[], overrideOptions?: {}): Cluster;
+    /**
+     * Get nodes with the specified role
+     */
+    nodes(role?: NodeRole): Redis[];
+    /**
+     * This is needed in order not to install a listener for each auto pipeline
+     *
+     * @ignore
+     */
+    delayUntilReady(callback: Callback): void;
+    /**
+     * Get the number of commands queued in automatic pipelines.
+     *
+     * This is not available (and returns 0) until the cluster is connected and slots information have been received.
+     */
+    get autoPipelineQueueSize(): number;
+    /**
+     * Refresh the slot cache
+     *
+     * @ignore
+     */
+    refreshSlotsCache(callback?: Callback<void>): void;
+    /**
+     * @ignore
+     */
+    sendCommand(command: Command, stream?: WriteableStream, node?: any): unknown;
+    sscanStream(key: string, options?: ScanStreamOptions): ScanStream;
+    sscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
+    hscanStream(key: string, options?: ScanStreamOptions): ScanStream;
+    hscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
+    zscanStream(key: string, options?: ScanStreamOptions): ScanStream;
+    zscanBufferStream(key: string, options?: ScanStreamOptions): ScanStream;
+    /**
+     * @ignore
+     */
+    handleError(error: Error, ttl: {
+        value?: any;
+    }, handlers: any): void;
+    private resetOfflineQueue;
+    private clearNodesRefreshInterval;
+    private resetNodesRefreshInterval;
+    /**
+     * Change cluster instance's status
+     */
+    private setStatus;
+    /**
+     * Called when closed to check whether a reconnection should be made
+     */
+    private handleCloseEvent;
+    /**
+     * Flush offline queue with error.
+     */
+    private flushQueue;
+    private executeOfflineCommands;
+    private natMapper;
+    private getInfoFromNode;
+    private invokeReadyDelayedCallbacks;
+    /**
+     * Check whether Cluster is able to process commands
+     */
+    private readyCheck;
+    private resolveSrv;
+    private dnsLookup;
+    /**
+     * Normalize startup nodes, and resolving hostnames to IPs.
+     *
+     * This process happens every time when #connect() is called since
+     * #startupNodes and DNS records may chanage.
+     */
+    private resolveStartupNodeHostnames;
+    private createScanStream;
+    private createShardedSubscriberGroup;
+}
+interface Cluster extends EventEmitter {
+}
+interface Cluster extends Transaction {
+}
+export default Cluster;