ioredis-om 5.10.2

package/built/cluster/util.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { SrvRecord } from "dns";
+export declare type NodeKey = string;
+export declare type NodeRole = "master" | "slave" | "all";
+export interface RedisOptions {
+    port: number;
+    host: string;
+    username?: string | undefined;
+    password?: string | undefined;
+    [key: string]: any;
+}
+export interface SrvRecordsGroup {
+    totalWeight: number;
+    records: SrvRecord[];
+}
+export interface GroupedSrvRecords {
+    [key: number]: SrvRecordsGroup;
+}
+export declare function getNodeKey(node: RedisOptions): NodeKey;
+export declare function nodeKeyToRedisOptions(nodeKey: NodeKey): RedisOptions;
+export declare function normalizeNodeOptions(nodes: Array<string | number | object>): RedisOptions[];
+export declare function getUniqueHostnamesFromOptions(nodes: RedisOptions[]): string[];
+export declare function groupSrvRecords(records: SrvRecord[]): GroupedSrvRecords;
+export declare function weightSrvRecords(recordsGroup: SrvRecordsGroup): SrvRecord;
+export declare function getConnectionName(component: any, nodeConnectionName: any): string;

package/built/cluster/util.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnectionName = exports.weightSrvRecords = exports.groupSrvRecords = exports.getUniqueHostnamesFromOptions = exports.normalizeNodeOptions = exports.nodeKeyToRedisOptions = exports.getNodeKey = void 0;
+const utils_1 = require("../utils");
+const net_1 = require("net");
+function getNodeKey(node) {
+    node.port = node.port || 6379;
+    node.host = node.host || "127.0.0.1";
+    return node.host + ":" + node.port;
+}
+exports.getNodeKey = getNodeKey;
+function nodeKeyToRedisOptions(nodeKey) {
+    const portIndex = nodeKey.lastIndexOf(":");
+    if (portIndex === -1) {
+        throw new Error(`Invalid node key ${nodeKey}`);
+    }
+    return {
+        host: nodeKey.slice(0, portIndex),
+        port: Number(nodeKey.slice(portIndex + 1)),
+    };
+}
+exports.nodeKeyToRedisOptions = nodeKeyToRedisOptions;
+function normalizeNodeOptions(nodes) {
+    return nodes.map((node) => {
+        const options = {};
+        if (typeof node === "object") {
+            Object.assign(options, node);
+        }
+        else if (typeof node === "string") {
+            Object.assign(options, (0, utils_1.parseURL)(node));
+        }
+        else if (typeof node === "number") {
+            options.port = node;
+        }
+        else {
+            throw new Error("Invalid argument " + node);
+        }
+        if (typeof options.port === "string") {
+            options.port = parseInt(options.port, 10);
+        }
+        // Cluster mode only support db 0
+        delete options.db;
+        if (!options.port) {
+            options.port = 6379;
+        }
+        if (!options.host) {
+            options.host = "127.0.0.1";
+        }
+        return (0, utils_1.resolveTLSProfile)(options);
+    });
+}
+exports.normalizeNodeOptions = normalizeNodeOptions;
+function getUniqueHostnamesFromOptions(nodes) {
+    const uniqueHostsMap = {};
+    nodes.forEach((node) => {
+        uniqueHostsMap[node.host] = true;
+    });
+    return Object.keys(uniqueHostsMap).filter((host) => !(0, net_1.isIP)(host));
+}
+exports.getUniqueHostnamesFromOptions = getUniqueHostnamesFromOptions;
+function groupSrvRecords(records) {
+    const recordsByPriority = {};
+    for (const record of records) {
+        if (!recordsByPriority.hasOwnProperty(record.priority)) {
+            recordsByPriority[record.priority] = {
+                totalWeight: record.weight,
+                records: [record],
+            };
+        }
+        else {
+            recordsByPriority[record.priority].totalWeight += record.weight;
+            recordsByPriority[record.priority].records.push(record);
+        }
+    }
+    return recordsByPriority;
+}
+exports.groupSrvRecords = groupSrvRecords;
+function weightSrvRecords(recordsGroup) {
+    if (recordsGroup.records.length === 1) {
+        recordsGroup.totalWeight = 0;
+        return recordsGroup.records.shift();
+    }
+    // + `recordsGroup.records.length` to support `weight` 0
+    const random = Math.floor(Math.random() * (recordsGroup.totalWeight + recordsGroup.records.length));
+    let total = 0;
+    for (const [i, record] of recordsGroup.records.entries()) {
+        total += 1 + record.weight;
+        if (total > random) {
+            recordsGroup.totalWeight -= record.weight;
+            recordsGroup.records.splice(i, 1);
+            return record;
+        }
+    }
+}
+exports.weightSrvRecords = weightSrvRecords;
+function getConnectionName(component, nodeConnectionName) {
+    const prefix = `ioredis-om-cluster(${component})`;
+    return nodeConnectionName ? `${prefix}:${nodeConnectionName}` : prefix;
+}
+exports.getConnectionName = getConnectionName;

package/built/connectors/AbstractConnector.d.ts

@@ -0,0 +1,12 @@
+import { NetStream } from "../types";
+export declare type ErrorEmitter = (type: string, err: Error) => void;
+export default abstract class AbstractConnector {
+    firstError?: Error;
+    protected connecting: boolean;
+    protected stream: NetStream;
+    private disconnectTimeout;
+    constructor(disconnectTimeout: number);
+    check(info: any): boolean;
+    disconnect(): void;
+    abstract connect(_: ErrorEmitter): Promise<NetStream>;
+}

package/built/connectors/AbstractConnector.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const debug = (0, utils_1.Debug)("AbstractConnector");
+class AbstractConnector {
+    constructor(disconnectTimeout) {
+        this.connecting = false;
+        this.disconnectTimeout = disconnectTimeout;
+    }
+    check(info) {
+        return true;
+    }
+    disconnect() {
+        this.connecting = false;
+        if (this.stream) {
+            const stream = this.stream; // Make sure callbacks refer to the same instance
+            const timeout = setTimeout(() => {
+                debug("stream %s:%s still open, destroying it", stream.remoteAddress, stream.remotePort);
+                stream.destroy();
+            }, this.disconnectTimeout);
+            stream.on("close", () => clearTimeout(timeout));
+            stream.end();
+        }
+    }
+}
+exports.default = AbstractConnector;

package/built/connectors/ConnectorConstructor.d.ts

@@ -0,0 +1,5 @@
+import AbstractConnector from "./AbstractConnector";
+interface ConnectorConstructor {
+    new (options: unknown): AbstractConnector;
+}
+export default ConnectorConstructor;

package/built/connectors/ConnectorConstructor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/built/connectors/SentinelConnector/FailoverDetector.d.ts

@@ -0,0 +1,11 @@
+import SentinelConnector from "./index";
+import { Sentinel } from "./types";
+export declare class FailoverDetector {
+    private connector;
+    private sentinels;
+    private isDisconnected;
+    constructor(connector: SentinelConnector, sentinels: Sentinel[]);
+    cleanup(): void;
+    subscribe(): Promise<void>;
+    private disconnect;
+}

package/built/connectors/SentinelConnector/FailoverDetector.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailoverDetector = void 0;
+const utils_1 = require("../../utils");
+const debug = (0, utils_1.Debug)("FailoverDetector");
+const CHANNEL_NAME = "+switch-master";
+class FailoverDetector {
+    // sentinels can't be used for regular commands after this
+    constructor(connector, sentinels) {
+        this.isDisconnected = false;
+        this.connector = connector;
+        this.sentinels = sentinels;
+    }
+    cleanup() {
+        this.isDisconnected = true;
+        for (const sentinel of this.sentinels) {
+            sentinel.client.disconnect();
+        }
+    }
+    async subscribe() {
+        debug("Starting FailoverDetector");
+        const promises = [];
+        for (const sentinel of this.sentinels) {
+            const promise = sentinel.client.subscribe(CHANNEL_NAME).catch((err) => {
+                debug("Failed to subscribe to failover messages on sentinel %s:%s (%s)", sentinel.address.host || "127.0.0.1", sentinel.address.port || 26739, err.message);
+            });
+            promises.push(promise);
+            sentinel.client.on("message", (channel) => {
+                if (!this.isDisconnected && channel === CHANNEL_NAME) {
+                    this.disconnect();
+                }
+            });
+        }
+        await Promise.all(promises);
+    }
+    disconnect() {
+        // Avoid disconnecting more than once per failover.
+        // A new FailoverDetector will be created after reconnecting.
+        this.isDisconnected = true;
+        debug("Failover detected, disconnecting");
+        // Will call this.cleanup()
+        this.connector.disconnect();
+    }
+}
+exports.FailoverDetector = FailoverDetector;

package/built/connectors/SentinelConnector/SentinelIterator.d.ts

@@ -0,0 +1,13 @@
+import { SentinelAddress } from "./types";
+export default class SentinelIterator implements Iterator<Partial<SentinelAddress>> {
+    private cursor;
+    private sentinels;
+    constructor(sentinels: Array<Partial<SentinelAddress>>);
+    next(): {
+        done: boolean;
+        value: Partial<SentinelAddress>;
+    };
+    reset(moveCurrentEndpointToFirst: boolean): void;
+    add(sentinel: SentinelAddress): boolean;
+    toString(): string;
+}

package/built/connectors/SentinelConnector/SentinelIterator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isSentinelEql(a, b) {
+    return ((a.host || "127.0.0.1") === (b.host || "127.0.0.1") &&
+        (a.port || 26379) === (b.port || 26379));
+}
+class SentinelIterator {
+    constructor(sentinels) {
+        this.cursor = 0;
+        this.sentinels = sentinels.slice(0);
+    }
+    next() {
+        const done = this.cursor >= this.sentinels.length;
+        return { done, value: done ? undefined : this.sentinels[this.cursor++] };
+    }
+    reset(moveCurrentEndpointToFirst) {
+        if (moveCurrentEndpointToFirst &&
+            this.sentinels.length > 1 &&
+            this.cursor !== 1) {
+            this.sentinels.unshift(...this.sentinels.splice(this.cursor - 1));
+        }
+        this.cursor = 0;
+    }
+    add(sentinel) {
+        for (let i = 0; i < this.sentinels.length; i++) {
+            if (isSentinelEql(sentinel, this.sentinels[i])) {
+                return false;
+            }
+        }
+        this.sentinels.push(sentinel);
+        return true;
+    }
+    toString() {
+        return `${JSON.stringify(this.sentinels)} @${this.cursor}`;
+    }
+}
+exports.default = SentinelIterator;

package/built/connectors/SentinelConnector/index.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { NatMap } from "../../cluster/ClusterOptions";
+import { ConnectionOptions } from "tls";
+import SentinelIterator from "./SentinelIterator";
+import { SentinelAddress } from "./types";
+import AbstractConnector, { ErrorEmitter } from "../AbstractConnector";
+import { NetStream } from "../../types";
+interface AddressFromResponse {
+    port: string;
+    ip: string;
+    flags?: string | undefined;
+}
+declare type PreferredSlaves = ((slaves: AddressFromResponse[]) => AddressFromResponse | null) | Array<{
+    port: string;
+    ip: string;
+    prio?: number | undefined;
+}> | {
+    port: string;
+    ip: string;
+    prio?: number | undefined;
+};
+export { SentinelAddress, SentinelIterator };
+export interface SentinelConnectionOptions {
+    /**
+     * Master group name of the Sentinel
+     */
+    name?: string | undefined;
+    /**
+     * @default "master"
+     */
+    role?: "master" | "slave" | undefined;
+    tls?: ConnectionOptions | undefined;
+    sentinelUsername?: string | undefined;
+    sentinelPassword?: string | undefined;
+    sentinels?: Array<Partial<SentinelAddress>> | undefined;
+    sentinelRetryStrategy?: ((retryAttempts: number) => number | void | null) | undefined;
+    sentinelReconnectStrategy?: ((retryAttempts: number) => number | void | null) | undefined;
+    preferredSlaves?: PreferredSlaves | undefined;
+    connectTimeout?: number | undefined;
+    disconnectTimeout?: number | undefined;
+    sentinelCommandTimeout?: number | undefined;
+    enableTLSForSentinelMode?: boolean | undefined;
+    sentinelTLS?: ConnectionOptions | undefined;
+    natMap?: NatMap | undefined;
+    updateSentinels?: boolean | undefined;
+    /**
+     * @default 10
+     */
+    sentinelMaxConnections?: number | undefined;
+    failoverDetector?: boolean | undefined;
+}
+export default class SentinelConnector extends AbstractConnector {
+    protected options: SentinelConnectionOptions;
+    emitter: EventEmitter | null;
+    protected sentinelIterator: SentinelIterator;
+    private retryAttempts;
+    private failoverDetector;
+    constructor(options: SentinelConnectionOptions);
+    check(info: {
+        role?: string;
+    }): boolean;
+    disconnect(): void;
+    connect(eventEmitter: ErrorEmitter): Promise<NetStream>;
+    private updateSentinels;
+    private resolveMaster;
+    private resolveSlave;
+    private sentinelNatResolve;
+    private connectToSentinel;
+    private resolve;
+    private initFailoverDetector;
+}

package/built/connectors/SentinelConnector/index.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SentinelIterator = void 0;
+const net_1 = require("net");
+const utils_1 = require("../../utils");
+const tls_1 = require("tls");
+const SentinelIterator_1 = require("./SentinelIterator");
+exports.SentinelIterator = SentinelIterator_1.default;
+const AbstractConnector_1 = require("../AbstractConnector");
+const Redis_1 = require("../../Redis");
+const FailoverDetector_1 = require("./FailoverDetector");
+const debug = (0, utils_1.Debug)("SentinelConnector");
+class SentinelConnector extends AbstractConnector_1.default {
+    constructor(options) {
+        super(options.disconnectTimeout);
+        this.options = options;
+        this.emitter = null;
+        this.failoverDetector = null;
+        if (!this.options.sentinels.length) {
+            throw new Error("Requires at least one sentinel to connect to.");
+        }
+        if (!this.options.name) {
+            throw new Error("Requires the name of master.");
+        }
+        this.sentinelIterator = new SentinelIterator_1.default(this.options.sentinels);
+    }
+    check(info) {
+        const roleMatches = !info.role || this.options.role === info.role;
+        if (!roleMatches) {
+            debug("role invalid, expected %s, but got %s", this.options.role, info.role);
+            // Start from the next item.
+            // Note that `reset` will move the cursor to the previous element,
+            // so we advance two steps here.
+            this.sentinelIterator.next();
+            this.sentinelIterator.next();
+            this.sentinelIterator.reset(true);
+        }
+        return roleMatches;
+    }
+    disconnect() {
+        super.disconnect();
+        if (this.failoverDetector) {
+            this.failoverDetector.cleanup();
+        }
+    }
+    connect(eventEmitter) {
+        this.connecting = true;
+        this.retryAttempts = 0;
+        let lastError;
+        const connectToNext = async () => {
+            const endpoint = this.sentinelIterator.next();
+            if (endpoint.done) {
+                this.sentinelIterator.reset(false);
+                const retryDelay = typeof this.options.sentinelRetryStrategy === "function"
+                    ? this.options.sentinelRetryStrategy(++this.retryAttempts)
+                    : null;
+                let errorMsg = typeof retryDelay !== "number"
+                    ? "All sentinels are unreachable and retry is disabled."
+                    : `All sentinels are unreachable. Retrying from scratch after ${retryDelay}ms.`;
+                if (lastError) {
+                    errorMsg += ` Last error: ${lastError.message}`;
+                }
+                debug(errorMsg);
+                const error = new Error(errorMsg);
+                if (typeof retryDelay === "number") {
+                    eventEmitter("error", error);
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                    return connectToNext();
+                }
+                else {
+                    throw error;
+                }
+            }
+            let resolved = null;
+            let err = null;
+            try {
+                resolved = await this.resolve(endpoint.value);
+            }
+            catch (error) {
+                err = error;
+            }
+            if (!this.connecting) {
+                throw new Error(utils_1.CONNECTION_CLOSED_ERROR_MSG);
+            }
+            const endpointAddress = endpoint.value.host + ":" + endpoint.value.port;
+            if (resolved) {
+                debug("resolved: %s:%s from sentinel %s", resolved.host, resolved.port, endpointAddress);
+                if (this.options.enableTLSForSentinelMode && this.options.tls) {
+                    Object.assign(resolved, this.options.tls);
+                    this.stream = (0, tls_1.connect)(resolved);
+                    this.stream.once("secureConnect", this.initFailoverDetector.bind(this));
+                }
+                else {
+                    this.stream = (0, net_1.createConnection)(resolved);
+                    this.stream.once("connect", this.initFailoverDetector.bind(this));
+                }
+                this.stream.once("error", (err) => {
+                    this.firstError = err;
+                });
+                return this.stream;
+            }
+            else {
+                const errorMsg = err
+                    ? "failed to connect to sentinel " +
+                        endpointAddress +
+                        " because " +
+                        err.message
+                    : "connected to sentinel " +
+                        endpointAddress +
+                        " successfully, but got an invalid reply: " +
+                        resolved;
+                debug(errorMsg);
+                eventEmitter("sentinelError", new Error(errorMsg));
+                if (err) {
+                    lastError = err;
+                }
+                return connectToNext();
+            }
+        };
+        return connectToNext();
+    }
+    async updateSentinels(client) {
+        if (!this.options.updateSentinels) {
+            return;
+        }
+        const result = await client.sentinel("sentinels", this.options.name);
+        if (!Array.isArray(result)) {
+            return;
+        }
+        result
+            .map(utils_1.packObject)
+            .forEach((sentinel) => {
+            const flags = sentinel.flags ? sentinel.flags.split(",") : [];
+            if (flags.indexOf("disconnected") === -1 &&
+                sentinel.ip &&
+                sentinel.port) {
+                const endpoint = this.sentinelNatResolve(addressResponseToAddress(sentinel));
+                if (this.sentinelIterator.add(endpoint)) {
+                    debug("adding sentinel %s:%s", endpoint.host, endpoint.port);
+                }
+            }
+        });
+        debug("Updated internal sentinels: %s", this.sentinelIterator);
+    }
+    async resolveMaster(client) {
+        const result = await client.sentinel("get-master-addr-by-name", this.options.name);
+        await this.updateSentinels(client);
+        return this.sentinelNatResolve(Array.isArray(result)
+            ? { host: result[0], port: Number(result[1]) }
+            : null);
+    }
+    async resolveSlave(client) {
+        const result = await client.sentinel("slaves", this.options.name);
+        if (!Array.isArray(result)) {
+            return null;
+        }
+        const availableSlaves = result
+            .map(utils_1.packObject)
+            .filter((slave) => slave.flags && !slave.flags.match(/(disconnected|s_down|o_down)/));
+        return this.sentinelNatResolve(selectPreferredSentinel(availableSlaves, this.options.preferredSlaves));
+    }
+    sentinelNatResolve(item) {
+        if (!item || !this.options.natMap)
+            return item;
+        const key = `${item.host}:${item.port}`;
+        let result = item;
+        if (typeof this.options.natMap === "function") {
+            result = this.options.natMap(key) || item;
+        }
+        else if (typeof this.options.natMap === "object") {
+            result = this.options.natMap[key] || item;
+        }
+        return result;
+    }
+    connectToSentinel(endpoint, options) {
+        const redis = new Redis_1.default({
+            port: endpoint.port || 26379,
+            host: endpoint.host,
+            username: this.options.sentinelUsername || null,
+            password: this.options.sentinelPassword || null,
+            family: endpoint.family ||
+                // @ts-expect-error
+                ("path" in this.options && this.options.path
+                    ? undefined
+                    : // @ts-expect-error
+                        this.options.family),
+            tls: this.options.sentinelTLS,
+            retryStrategy: null,
+            enableReadyCheck: false,
+            connectTimeout: this.options.connectTimeout,
+            commandTimeout: this.options.sentinelCommandTimeout,
+            ...options,
+        });
+        // @ts-expect-error
+        return redis;
+    }
+    async resolve(endpoint) {
+        const client = this.connectToSentinel(endpoint);
+        // ignore the errors since resolve* methods will handle them
+        client.on("error", noop);
+        try {
+            if (this.options.role === "slave") {
+                return await this.resolveSlave(client);
+            }
+            else {
+                return await this.resolveMaster(client);
+            }
+        }
+        finally {
+            client.disconnect();
+        }
+    }
+    async initFailoverDetector() {
+        var _a;
+        if (!this.options.failoverDetector) {
+            return;
+        }
+        // Move the current sentinel to the first position
+        this.sentinelIterator.reset(true);
+        const sentinels = [];
+        // In case of a large amount of sentinels, limit the number of concurrent connections
+        while (sentinels.length < this.options.sentinelMaxConnections) {
+            const { done, value } = this.sentinelIterator.next();
+            if (done) {
+                break;
+            }
+            const client = this.connectToSentinel(value, {
+                lazyConnect: true,
+                retryStrategy: this.options.sentinelReconnectStrategy,
+            });
+            client.on("reconnecting", () => {
+                var _a;
+                // Tests listen to this event
+                (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit("sentinelReconnecting");
+            });
+            sentinels.push({ address: value, client });
+        }
+        this.sentinelIterator.reset(false);
+        if (this.failoverDetector) {
+            // Clean up previous detector
+            this.failoverDetector.cleanup();
+        }
+        this.failoverDetector = new FailoverDetector_1.FailoverDetector(this, sentinels);
+        await this.failoverDetector.subscribe();
+        // Tests listen to this event
+        (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.emit("failoverSubscribed");
+    }
+}
+exports.default = SentinelConnector;
+function selectPreferredSentinel(availableSlaves, preferredSlaves) {
+    if (availableSlaves.length === 0) {
+        return null;
+    }
+    let selectedSlave;
+    if (typeof preferredSlaves === "function") {
+        selectedSlave = preferredSlaves(availableSlaves);
+    }
+    else if (preferredSlaves !== null && typeof preferredSlaves === "object") {
+        const preferredSlavesArray = Array.isArray(preferredSlaves)
+            ? preferredSlaves
+            : [preferredSlaves];
+        // sort by priority
+        preferredSlavesArray.sort((a, b) => {
+            // default the priority to 1
+            if (!a.prio) {
+                a.prio = 1;
+            }
+            if (!b.prio) {
+                b.prio = 1;
+            }
+            // lowest priority first
+            if (a.prio < b.prio) {
+                return -1;
+            }
+            if (a.prio > b.prio) {
+                return 1;
+            }
+            return 0;
+        });
+        // loop over preferred slaves and return the first match
+        for (let p = 0; p < preferredSlavesArray.length; p++) {
+            for (let a = 0; a < availableSlaves.length; a++) {
+                const slave = availableSlaves[a];
+                if (slave.ip === preferredSlavesArray[p].ip) {
+                    if (slave.port === preferredSlavesArray[p].port) {
+                        selectedSlave = slave;
+                        break;
+                    }
+                }
+            }
+            if (selectedSlave) {
+                break;
+            }
+        }
+    }
+    // if none of the preferred slaves are available, a random available slave is returned
+    if (!selectedSlave) {
+        selectedSlave = (0, utils_1.sample)(availableSlaves);
+    }
+    return addressResponseToAddress(selectedSlave);
+}
+function addressResponseToAddress(input) {
+    return { host: input.ip, port: Number(input.port) };
+}
+function noop() { }