228 lines
7.9 KiB
TypeScript
228 lines
7.9 KiB
TypeScript
/// <reference types="node" />
|
|
/// <reference types="node" />
|
|
import { SrvRecord } from "dns";
|
|
import { RedisOptions, RetryStrategy } from "../redis/RedisOptions";
|
|
import { ReplyMappingMode } from "../types";
|
|
import { CommanderOptions } from "../utils/Commander";
|
|
import { NodeRole } from "./util";
|
|
import type { HimportFieldset } from "../himport/types";
|
|
export type DNSResolveSrvFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void) => void;
|
|
export type DNSLookupFunction = (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void) => void;
|
|
export type NatMapFunction = (key: string) => {
|
|
host: string;
|
|
port: number;
|
|
} | null;
|
|
export type NatMap = {
|
|
[key: string]: {
|
|
host: string;
|
|
port: number;
|
|
};
|
|
} | NatMapFunction;
|
|
export type ClusterNodeRetryStrategy = RetryStrategy;
|
|
/**
|
|
* Options for Cluster constructor
|
|
*/
|
|
export interface ClusterOptions extends CommanderOptions {
|
|
/**
|
|
* See "Quick Start" section.
|
|
*
|
|
* @default (times) => Math.min(100 + times * 2, 2000)
|
|
*/
|
|
clusterRetryStrategy?: ((times: number, reason?: Error) => number | void | null) | null | undefined;
|
|
/**
|
|
* See Redis class.
|
|
*
|
|
* @default true
|
|
*/
|
|
enableOfflineQueue?: boolean | undefined;
|
|
/**
|
|
* When enabled, ioredis only emits "ready" event when `CLUSTER INFO`
|
|
* command reporting the cluster is ready for handling commands.
|
|
*
|
|
* @default true
|
|
*/
|
|
enableReadyCheck?: boolean | undefined;
|
|
/**
|
|
* Scale reads to the node with the specified role.
|
|
*
|
|
* @default "master"
|
|
*/
|
|
scaleReads?: NodeRole | Function | undefined;
|
|
/**
|
|
* When a MOVED or ASK error is received, client will redirect the
|
|
* command to another node.
|
|
* This option limits the max redirections allowed to send a command.
|
|
*
|
|
* @default 16
|
|
*/
|
|
maxRedirections?: number | undefined;
|
|
/**
|
|
* When an error is received when sending a command (e.g.
|
|
* "Connection is closed." when the target Redis node is down), client will retry
|
|
* if `retryDelayOnFailover` is valid delay time (in ms).
|
|
*
|
|
* @default 100
|
|
*/
|
|
retryDelayOnFailover?: number | undefined;
|
|
/**
|
|
* When a CLUSTERDOWN error is received, client will retry
|
|
* if `retryDelayOnClusterDown` is valid delay time (in ms).
|
|
*
|
|
* @default 100
|
|
*/
|
|
retryDelayOnClusterDown?: number | undefined;
|
|
/**
|
|
* When a TRYAGAIN error is received, client will retry
|
|
* if `retryDelayOnTryAgain` is valid delay time (in ms).
|
|
*
|
|
* @default 100
|
|
*/
|
|
retryDelayOnTryAgain?: number | undefined;
|
|
/**
|
|
* By default, this value is 0, which means when a `MOVED` error is received,
|
|
* the client will resend the command instantly to the node returned together with
|
|
* the `MOVED` error. However, sometimes it takes time for a cluster to become
|
|
* state stabilized after a failover, so adding a delay before resending can
|
|
* prevent a ping pong effect.
|
|
*
|
|
* @default 0
|
|
*/
|
|
retryDelayOnMoved?: number | undefined;
|
|
/**
|
|
* The milliseconds before a timeout occurs while refreshing
|
|
* slots from the cluster.
|
|
*
|
|
* @default 1000
|
|
*/
|
|
slotsRefreshTimeout?: number | undefined;
|
|
/**
|
|
* The milliseconds between every automatic slots refresh.
|
|
*
|
|
* @default 5000
|
|
*/
|
|
slotsRefreshInterval?: number | undefined;
|
|
/**
|
|
* Use sharded subscribers instead of a single subscriber.
|
|
*
|
|
* If sharded subscribers are used, then one additional subscriber connection per master node
|
|
* is established. If you don't plan to use SPUBLISH/SSUBSCRIBE, then this should be disabled.
|
|
*
|
|
* @default false
|
|
*/
|
|
shardedSubscribers?: boolean | undefined;
|
|
/**
|
|
* When a cluster node connection is closed, this function will be called
|
|
* to determine the retry delay (in ms). Returning `null` or a non-number
|
|
* disables reconnection for that node.
|
|
*
|
|
* By default this is `null`, meaning cluster nodes will NOT automatically
|
|
* reconnect — the cluster relies on `MOVED` errors to refresh topology.
|
|
* Set this to enable reconnection, e.g. for replica nodes that restart
|
|
* without any slot changes.
|
|
*
|
|
* @example
|
|
* clusterNodeRetryStrategy: (times) => Math.min(times * 100, 3000)
|
|
*
|
|
* @default null
|
|
*/
|
|
clusterNodeRetryStrategy?: ClusterNodeRetryStrategy;
|
|
/**
|
|
* Passed to the constructor of `Redis`
|
|
*
|
|
* @default null
|
|
*/
|
|
redisOptions?: Omit<RedisOptions, "port" | "host" | "path" | "sentinels" | "retryStrategy" | "enableOfflineQueue" | "readOnly" | "himportFieldsets"> | undefined;
|
|
/**
|
|
* By default, When a new Cluster instance is created,
|
|
* it will connect to the Redis cluster automatically.
|
|
* If you want to keep the instance disconnected until the first command is called,
|
|
* set this option to `true`.
|
|
*
|
|
* @default false
|
|
*/
|
|
lazyConnect?: boolean | undefined;
|
|
/**
|
|
* Discover nodes using SRV records
|
|
*
|
|
* @default false
|
|
*/
|
|
useSRVRecords?: boolean | undefined;
|
|
/**
|
|
* SRV records will be resolved via this function.
|
|
*
|
|
* You may provide a custom `resolveSrv` function when you want to customize
|
|
* the cache behavior of the default function.
|
|
*
|
|
* @default require('dns').resolveSrv
|
|
*/
|
|
resolveSrv?: DNSResolveSrvFunction | undefined;
|
|
/**
|
|
* Hostnames will be resolved to IP addresses via this function.
|
|
* This is needed when the addresses of startup nodes are hostnames instead
|
|
* of IPs.
|
|
*
|
|
* You may provide a custom `lookup` function when you want to customize
|
|
* the cache behavior of the default function.
|
|
*
|
|
* @default require('dns').lookup
|
|
*/
|
|
dnsLookup?: DNSLookupFunction | undefined;
|
|
natMap?: NatMap | undefined;
|
|
/**
|
|
* See Redis class.
|
|
*
|
|
* @default false
|
|
*/
|
|
enableAutoPipelining?: boolean | undefined;
|
|
/**
|
|
* See Redis class.
|
|
*
|
|
* @default []
|
|
*/
|
|
autoPipeliningIgnoredCommands?: string[] | undefined;
|
|
/**
|
|
* Custom LUA commands
|
|
*/
|
|
scripts?: Record<string, {
|
|
lua: string;
|
|
numberOfKeys?: number;
|
|
readOnly?: boolean;
|
|
}> | undefined;
|
|
/**
|
|
* Managed-fieldset support is experimental and requires Redis 8.10 or newer.
|
|
*
|
|
* Long-lived HIMPORT fieldsets managed across all current and future master
|
|
* connections for the lifetime of this Cluster client.
|
|
* Configure this option at the top level, not under `redisOptions`.
|
|
*
|
|
* When a managed `HIMPORT SET` needs fieldset preparation or recovery,
|
|
* later commands issued on this Cluster client may be sent before that SET
|
|
* resumes. Await the SET before issuing commands that depend on its write.
|
|
*
|
|
* Explicit pipelines containing a managed `HIMPORT SET` wait for required
|
|
* fieldset preparation on the selected master before the batch is sent.
|
|
*
|
|
* Background preparation failures do not prevent the connection from
|
|
* becoming ready and are reported through the `node error` event. A
|
|
* dependent managed `HIMPORT SET` retries preparation and rejects if
|
|
* recovery fails.
|
|
*
|
|
* Direct `HIMPORT PREPARE`, `DISCARD`, and `DISCARDALL` calls fan out to all
|
|
* current masters. Within an explicit pipeline, these commands remain
|
|
* connection-affine and are not managed.
|
|
*
|
|
* Use explicit HIMPORT commands on a separate unconfigured client for
|
|
* bounded, manually managed batches.
|
|
*
|
|
* @default undefined
|
|
* @experimental
|
|
*/
|
|
himportFieldsets?: readonly HimportFieldset[] | undefined;
|
|
}
|
|
export type ClusterOptionsWithReplyMapping<Mapping extends ReplyMappingMode> = ClusterOptions & {
|
|
redisOptions?: ClusterOptions["redisOptions"] & {
|
|
replyMapping?: Mapping;
|
|
};
|
|
};
|
|
export declare const DEFAULT_CLUSTER_OPTIONS: ClusterOptions;
|