-first commit
This commit is contained in:
72
node_modules/@redis/client/dist/lib/cluster/cluster-slots.d.ts
generated
vendored
Normal file
72
node_modules/@redis/client/dist/lib/cluster/cluster-slots.d.ts
generated
vendored
Normal file
@@ -0,0 +1,72 @@
|
||||
/// <reference types="node" />
|
||||
/// <reference types="node" />
|
||||
import { RedisClusterOptions } from '.';
|
||||
import { RedisClientType } from '../client';
|
||||
import { EventEmitter } from 'node:stream';
|
||||
import { ChannelListeners } from '../client/pub-sub';
|
||||
import { RedisArgument, RedisFunctions, RedisModules, RedisScripts, RespVersions, TypeMapping } from '../RESP/types';
|
||||
import { PooledClientSideCacheProvider } from '../client/cache';
|
||||
interface NodeAddress {
|
||||
host: string;
|
||||
port: number;
|
||||
}
|
||||
export type NodeAddressMap = {
|
||||
[address: string]: NodeAddress;
|
||||
} | ((address: string) => NodeAddress | undefined);
|
||||
export interface Node<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> {
|
||||
address: string;
|
||||
client?: RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
|
||||
connectPromise?: Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
}
|
||||
export interface ShardNode<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> extends Node<M, F, S, RESP, TYPE_MAPPING>, NodeAddress {
|
||||
id: string;
|
||||
readonly: boolean;
|
||||
}
|
||||
export interface MasterNode<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> extends ShardNode<M, F, S, RESP, TYPE_MAPPING> {
|
||||
pubSub?: {
|
||||
connectPromise?: Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
client: RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
|
||||
};
|
||||
}
|
||||
export interface Shard<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> {
|
||||
master: MasterNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
replicas?: Array<ShardNode<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
nodesIterator?: IterableIterator<ShardNode<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
}
|
||||
type PubSubNode<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = (Omit<Node<M, F, S, RESP, TYPE_MAPPING>, 'client'> & Required<Pick<Node<M, F, S, RESP, TYPE_MAPPING>, 'client'>>);
|
||||
export type OnShardedChannelMovedError = (err: unknown, channel: string, listeners?: ChannelListeners) => void;
|
||||
export default class RedisClusterSlots<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> {
|
||||
#private;
|
||||
slots: Shard<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
masters: MasterNode<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
replicas: ShardNode<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
readonly nodeByAddress: Map<string, ShardNode<M, F, S, RESP, TYPE_MAPPING> | MasterNode<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
pubSubNode?: PubSubNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
clientSideCache?: PooledClientSideCacheProvider;
|
||||
get isOpen(): boolean;
|
||||
constructor(options: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING>, emit: EventEmitter['emit']);
|
||||
connect(): Promise<void>;
|
||||
nodeClient(node: ShardNode<M, F, S, RESP, TYPE_MAPPING>): RedisClientType<M, F, S, RESP, TYPE_MAPPING> | Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
rediscover(startWith: RedisClientType<M, F, S, RESP>): Promise<void>;
|
||||
/**
|
||||
* @deprecated Use `close` instead.
|
||||
*/
|
||||
quit(): Promise<void>;
|
||||
/**
|
||||
* @deprecated Use `destroy` instead.
|
||||
*/
|
||||
disconnect(): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
destroy(): void;
|
||||
getClient(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined): RedisClientType<M, F, S, RESP, TYPE_MAPPING> | Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
_randomNodeIterator?: IterableIterator<ShardNode<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
getRandomNode(): ShardNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
getSlotRandomNode(slotNumber: number): ShardNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
getMasterByAddress(address: string): RedisClientType<M, F, S, RESP, TYPE_MAPPING> | Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>> | undefined;
|
||||
getPubSubClient(): RedisClientType<M, F, S, RESP, TYPE_MAPPING> | Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
executeUnsubscribeCommand(unsubscribe: (client: RedisClientType<M, F, S, RESP>) => Promise<void>): Promise<void>;
|
||||
getShardedPubSubClient(channel: string): RedisClientType<M, F, S, RESP, TYPE_MAPPING> | Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
executeShardedUnsubscribeCommand(channel: string, unsubscribe: (client: RedisClientType<M, F, S, RESP, TYPE_MAPPING>) => Promise<void>): Promise<void>;
|
||||
}
|
||||
export {};
|
||||
//# sourceMappingURL=cluster-slots.d.ts.map
|
||||
1
node_modules/@redis/client/dist/lib/cluster/cluster-slots.d.ts.map
generated
vendored
Normal file
1
node_modules/@redis/client/dist/lib/cluster/cluster-slots.d.ts.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"cluster-slots.d.ts","sourceRoot":"","sources":["../../../lib/cluster/cluster-slots.ts"],"names":[],"mappings":"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"}
|
||||
462
node_modules/@redis/client/dist/lib/cluster/cluster-slots.js
generated
vendored
Normal file
462
node_modules/@redis/client/dist/lib/cluster/cluster-slots.js
generated
vendored
Normal file
@@ -0,0 +1,462 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
var _a;
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const errors_1 = require("../errors");
|
||||
const client_1 = __importDefault(require("../client"));
|
||||
const pub_sub_1 = require("../client/pub-sub");
|
||||
const cluster_key_slot_1 = __importDefault(require("cluster-key-slot"));
|
||||
const cache_1 = require("../client/cache");
|
||||
class RedisClusterSlots {
|
||||
static #SLOTS = 16384;
|
||||
#options;
|
||||
#clientFactory;
|
||||
#emit;
|
||||
slots = new Array(_a.#SLOTS);
|
||||
masters = new Array();
|
||||
replicas = new Array();
|
||||
nodeByAddress = new Map();
|
||||
pubSubNode;
|
||||
clientSideCache;
|
||||
#isOpen = false;
|
||||
get isOpen() {
|
||||
return this.#isOpen;
|
||||
}
|
||||
#validateOptions(options) {
|
||||
if (options?.clientSideCache && options?.RESP !== 3) {
|
||||
throw new Error('Client Side Caching is only supported with RESP3');
|
||||
}
|
||||
}
|
||||
constructor(options, emit) {
|
||||
this.#validateOptions(options);
|
||||
this.#options = options;
|
||||
if (options?.clientSideCache) {
|
||||
if (options.clientSideCache instanceof cache_1.PooledClientSideCacheProvider) {
|
||||
this.clientSideCache = options.clientSideCache;
|
||||
}
|
||||
else {
|
||||
this.clientSideCache = new cache_1.BasicPooledClientSideCache(options.clientSideCache);
|
||||
}
|
||||
}
|
||||
this.#clientFactory = client_1.default.factory(this.#options);
|
||||
this.#emit = emit;
|
||||
}
|
||||
async connect() {
|
||||
if (this.#isOpen) {
|
||||
throw new Error('Cluster already open');
|
||||
}
|
||||
this.#isOpen = true;
|
||||
try {
|
||||
await this.#discoverWithRootNodes();
|
||||
this.#emit('connect');
|
||||
}
|
||||
catch (err) {
|
||||
this.#isOpen = false;
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
async #discoverWithRootNodes() {
|
||||
let start = Math.floor(Math.random() * this.#options.rootNodes.length);
|
||||
for (let i = start; i < this.#options.rootNodes.length; i++) {
|
||||
if (!this.#isOpen)
|
||||
throw new Error('Cluster closed');
|
||||
if (await this.#discover(this.#options.rootNodes[i]))
|
||||
return;
|
||||
}
|
||||
for (let i = 0; i < start; i++) {
|
||||
if (!this.#isOpen)
|
||||
throw new Error('Cluster closed');
|
||||
if (await this.#discover(this.#options.rootNodes[i]))
|
||||
return;
|
||||
}
|
||||
throw new errors_1.RootNodesUnavailableError();
|
||||
}
|
||||
#resetSlots() {
|
||||
this.slots = new Array(_a.#SLOTS);
|
||||
this.masters = [];
|
||||
this.replicas = [];
|
||||
this._randomNodeIterator = undefined;
|
||||
}
|
||||
async #discover(rootNode) {
|
||||
this.clientSideCache?.clear();
|
||||
this.clientSideCache?.disable();
|
||||
try {
|
||||
const addressesInUse = new Set(), promises = [], eagerConnect = this.#options.minimizeConnections !== true;
|
||||
const shards = await this.#getShards(rootNode);
|
||||
this.#resetSlots(); // Reset slots AFTER shards have been fetched to prevent a race condition
|
||||
for (const { from, to, master, replicas } of shards) {
|
||||
const shard = {
|
||||
master: this.#initiateSlotNode(master, false, eagerConnect, addressesInUse, promises)
|
||||
};
|
||||
if (this.#options.useReplicas) {
|
||||
shard.replicas = replicas.map(replica => this.#initiateSlotNode(replica, true, eagerConnect, addressesInUse, promises));
|
||||
}
|
||||
for (let i = from; i <= to; i++) {
|
||||
this.slots[i] = shard;
|
||||
}
|
||||
}
|
||||
if (this.pubSubNode && !addressesInUse.has(this.pubSubNode.address)) {
|
||||
const channelsListeners = this.pubSubNode.client.getPubSubListeners(pub_sub_1.PUBSUB_TYPE.CHANNELS), patternsListeners = this.pubSubNode.client.getPubSubListeners(pub_sub_1.PUBSUB_TYPE.PATTERNS);
|
||||
this.pubSubNode.client.destroy();
|
||||
if (channelsListeners.size || patternsListeners.size) {
|
||||
promises.push(this.#initiatePubSubClient({
|
||||
[pub_sub_1.PUBSUB_TYPE.CHANNELS]: channelsListeners,
|
||||
[pub_sub_1.PUBSUB_TYPE.PATTERNS]: patternsListeners
|
||||
}));
|
||||
}
|
||||
}
|
||||
//Keep only the nodes that are still in use
|
||||
for (const [address, node] of this.nodeByAddress.entries()) {
|
||||
if (addressesInUse.has(address))
|
||||
continue;
|
||||
if (node.client) {
|
||||
node.client.destroy();
|
||||
}
|
||||
const { pubSub } = node;
|
||||
if (pubSub) {
|
||||
pubSub.client.destroy();
|
||||
}
|
||||
this.nodeByAddress.delete(address);
|
||||
}
|
||||
await Promise.all(promises);
|
||||
this.clientSideCache?.enable();
|
||||
return true;
|
||||
}
|
||||
catch (err) {
|
||||
this.#emit('error', err);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
async #getShards(rootNode) {
|
||||
const options = this.#clientOptionsDefaults(rootNode);
|
||||
options.socket ??= {};
|
||||
options.socket.reconnectStrategy = false;
|
||||
options.RESP = this.#options.RESP;
|
||||
options.commandOptions = undefined;
|
||||
// TODO: find a way to avoid type casting
|
||||
const client = await this.#clientFactory(options)
|
||||
.on('error', err => this.#emit('error', err))
|
||||
.connect();
|
||||
try {
|
||||
// switch to `CLUSTER SHARDS` when Redis 7.0 will be the minimum supported version
|
||||
return await client.clusterSlots();
|
||||
}
|
||||
finally {
|
||||
client.destroy();
|
||||
}
|
||||
}
|
||||
#getNodeAddress(address) {
|
||||
switch (typeof this.#options.nodeAddressMap) {
|
||||
case 'object':
|
||||
return this.#options.nodeAddressMap[address];
|
||||
case 'function':
|
||||
return this.#options.nodeAddressMap(address);
|
||||
}
|
||||
}
|
||||
#clientOptionsDefaults(options) {
|
||||
if (!this.#options.defaults)
|
||||
return options;
|
||||
let socket;
|
||||
if (this.#options.defaults.socket) {
|
||||
socket = {
|
||||
...this.#options.defaults.socket,
|
||||
...options?.socket
|
||||
};
|
||||
}
|
||||
else {
|
||||
socket = options?.socket;
|
||||
}
|
||||
return {
|
||||
...this.#options.defaults,
|
||||
...options,
|
||||
socket: socket
|
||||
};
|
||||
}
|
||||
#initiateSlotNode(shard, readonly, eagerConnent, addressesInUse, promises) {
|
||||
const address = `${shard.host}:${shard.port}`;
|
||||
let node = this.nodeByAddress.get(address);
|
||||
if (!node) {
|
||||
node = {
|
||||
...shard,
|
||||
address,
|
||||
readonly,
|
||||
client: undefined,
|
||||
connectPromise: undefined
|
||||
};
|
||||
if (eagerConnent) {
|
||||
promises.push(this.#createNodeClient(node));
|
||||
}
|
||||
this.nodeByAddress.set(address, node);
|
||||
}
|
||||
if (!addressesInUse.has(address)) {
|
||||
addressesInUse.add(address);
|
||||
(readonly ? this.replicas : this.masters).push(node);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
#createClient(node, readonly = node.readonly) {
|
||||
const socket = this.#getNodeAddress(node.address) ??
|
||||
{ host: node.host, port: node.port, };
|
||||
const clientInfo = Object.freeze({
|
||||
host: socket.host,
|
||||
port: socket.port,
|
||||
});
|
||||
const emit = this.#emit;
|
||||
const client = this.#clientFactory(this.#clientOptionsDefaults({
|
||||
clientSideCache: this.clientSideCache,
|
||||
RESP: this.#options.RESP,
|
||||
socket,
|
||||
readonly,
|
||||
}))
|
||||
.on('error', error => emit('node-error', error, clientInfo))
|
||||
.on('reconnecting', () => emit('node-reconnecting', clientInfo))
|
||||
.once('ready', () => emit('node-ready', clientInfo))
|
||||
.once('connect', () => emit('node-connect', clientInfo))
|
||||
.once('end', () => emit('node-disconnect', clientInfo))
|
||||
.on('__MOVED', async (allPubSubListeners) => {
|
||||
await this.rediscover(client);
|
||||
this.#emit('__resubscribeAllPubSubListeners', allPubSubListeners);
|
||||
});
|
||||
return client;
|
||||
}
|
||||
#createNodeClient(node, readonly) {
|
||||
const client = node.client = this.#createClient(node, readonly);
|
||||
return node.connectPromise = client.connect()
|
||||
.finally(() => node.connectPromise = undefined);
|
||||
}
|
||||
nodeClient(node) {
|
||||
return (node.connectPromise ?? // if the node is connecting
|
||||
node.client ?? // if the node is connected
|
||||
this.#createNodeClient(node) // if the not is disconnected
|
||||
);
|
||||
}
|
||||
#runningRediscoverPromise;
|
||||
async rediscover(startWith) {
|
||||
this.#runningRediscoverPromise ??= this.#rediscover(startWith)
|
||||
.finally(() => {
|
||||
this.#runningRediscoverPromise = undefined;
|
||||
});
|
||||
return this.#runningRediscoverPromise;
|
||||
}
|
||||
async #rediscover(startWith) {
|
||||
if (await this.#discover(startWith.options))
|
||||
return;
|
||||
return this.#discoverWithRootNodes();
|
||||
}
|
||||
/**
|
||||
* @deprecated Use `close` instead.
|
||||
*/
|
||||
quit() {
|
||||
return this.#destroy(client => client.quit());
|
||||
}
|
||||
/**
|
||||
* @deprecated Use `destroy` instead.
|
||||
*/
|
||||
disconnect() {
|
||||
return this.#destroy(client => client.disconnect());
|
||||
}
|
||||
close() {
|
||||
return this.#destroy(client => client.close());
|
||||
}
|
||||
destroy() {
|
||||
this.#isOpen = false;
|
||||
for (const client of this.#clients()) {
|
||||
client.destroy();
|
||||
}
|
||||
if (this.pubSubNode) {
|
||||
this.pubSubNode.client.destroy();
|
||||
this.pubSubNode = undefined;
|
||||
}
|
||||
this.#resetSlots();
|
||||
this.nodeByAddress.clear();
|
||||
this.#emit('disconnect');
|
||||
}
|
||||
*#clients() {
|
||||
for (const master of this.masters) {
|
||||
if (master.client) {
|
||||
yield master.client;
|
||||
}
|
||||
if (master.pubSub) {
|
||||
yield master.pubSub.client;
|
||||
}
|
||||
}
|
||||
for (const replica of this.replicas) {
|
||||
if (replica.client) {
|
||||
yield replica.client;
|
||||
}
|
||||
}
|
||||
}
|
||||
async #destroy(fn) {
|
||||
this.#isOpen = false;
|
||||
const promises = [];
|
||||
for (const client of this.#clients()) {
|
||||
promises.push(fn(client));
|
||||
}
|
||||
if (this.pubSubNode) {
|
||||
promises.push(fn(this.pubSubNode.client));
|
||||
this.pubSubNode = undefined;
|
||||
}
|
||||
this.#resetSlots();
|
||||
this.nodeByAddress.clear();
|
||||
await Promise.allSettled(promises);
|
||||
this.#emit('disconnect');
|
||||
}
|
||||
getClient(firstKey, isReadonly) {
|
||||
if (!firstKey) {
|
||||
return this.nodeClient(this.getRandomNode());
|
||||
}
|
||||
const slotNumber = (0, cluster_key_slot_1.default)(firstKey);
|
||||
if (!isReadonly) {
|
||||
return this.nodeClient(this.slots[slotNumber].master);
|
||||
}
|
||||
return this.nodeClient(this.getSlotRandomNode(slotNumber));
|
||||
}
|
||||
*#iterateAllNodes() {
|
||||
if (this.masters.length + this.replicas.length === 0)
|
||||
return;
|
||||
let i = Math.floor(Math.random() * (this.masters.length + this.replicas.length));
|
||||
if (i < this.masters.length) {
|
||||
do {
|
||||
yield this.masters[i];
|
||||
} while (++i < this.masters.length);
|
||||
for (const replica of this.replicas) {
|
||||
yield replica;
|
||||
}
|
||||
}
|
||||
else {
|
||||
i -= this.masters.length;
|
||||
do {
|
||||
yield this.replicas[i];
|
||||
} while (++i < this.replicas.length);
|
||||
}
|
||||
while (true) {
|
||||
for (const master of this.masters) {
|
||||
yield master;
|
||||
}
|
||||
for (const replica of this.replicas) {
|
||||
yield replica;
|
||||
}
|
||||
}
|
||||
}
|
||||
_randomNodeIterator;
|
||||
getRandomNode() {
|
||||
this._randomNodeIterator ??= this.#iterateAllNodes();
|
||||
return this._randomNodeIterator.next().value;
|
||||
}
|
||||
*#slotNodesIterator(slot) {
|
||||
let i = Math.floor(Math.random() * (1 + slot.replicas.length));
|
||||
if (i < slot.replicas.length) {
|
||||
do {
|
||||
yield slot.replicas[i];
|
||||
} while (++i < slot.replicas.length);
|
||||
}
|
||||
while (true) {
|
||||
yield slot.master;
|
||||
for (const replica of slot.replicas) {
|
||||
yield replica;
|
||||
}
|
||||
}
|
||||
}
|
||||
getSlotRandomNode(slotNumber) {
|
||||
const slot = this.slots[slotNumber];
|
||||
if (!slot.replicas?.length) {
|
||||
return slot.master;
|
||||
}
|
||||
slot.nodesIterator ??= this.#slotNodesIterator(slot);
|
||||
return slot.nodesIterator.next().value;
|
||||
}
|
||||
getMasterByAddress(address) {
|
||||
const master = this.nodeByAddress.get(address);
|
||||
if (!master)
|
||||
return;
|
||||
return this.nodeClient(master);
|
||||
}
|
||||
getPubSubClient() {
|
||||
if (!this.pubSubNode)
|
||||
return this.#initiatePubSubClient();
|
||||
return this.pubSubNode.connectPromise ?? this.pubSubNode.client;
|
||||
}
|
||||
async #initiatePubSubClient(toResubscribe) {
|
||||
const index = Math.floor(Math.random() * (this.masters.length + this.replicas.length)), node = index < this.masters.length ?
|
||||
this.masters[index] :
|
||||
this.replicas[index - this.masters.length], client = this.#createClient(node, false);
|
||||
this.pubSubNode = {
|
||||
address: node.address,
|
||||
client,
|
||||
connectPromise: client.connect()
|
||||
.then(async (client) => {
|
||||
if (toResubscribe) {
|
||||
await Promise.all([
|
||||
client.extendPubSubListeners(pub_sub_1.PUBSUB_TYPE.CHANNELS, toResubscribe[pub_sub_1.PUBSUB_TYPE.CHANNELS]),
|
||||
client.extendPubSubListeners(pub_sub_1.PUBSUB_TYPE.PATTERNS, toResubscribe[pub_sub_1.PUBSUB_TYPE.PATTERNS])
|
||||
]);
|
||||
}
|
||||
this.pubSubNode.connectPromise = undefined;
|
||||
return client;
|
||||
})
|
||||
.catch(err => {
|
||||
this.pubSubNode = undefined;
|
||||
throw err;
|
||||
})
|
||||
};
|
||||
return this.pubSubNode.connectPromise;
|
||||
}
|
||||
async executeUnsubscribeCommand(unsubscribe) {
|
||||
const client = await this.getPubSubClient();
|
||||
await unsubscribe(client);
|
||||
if (!client.isPubSubActive) {
|
||||
client.destroy();
|
||||
this.pubSubNode = undefined;
|
||||
}
|
||||
}
|
||||
getShardedPubSubClient(channel) {
|
||||
const { master } = this.slots[(0, cluster_key_slot_1.default)(channel)];
|
||||
if (!master.pubSub)
|
||||
return this.#initiateShardedPubSubClient(master);
|
||||
return master.pubSub.connectPromise ?? master.pubSub.client;
|
||||
}
|
||||
async #initiateShardedPubSubClient(master) {
|
||||
const client = this.#createClient(master, false)
|
||||
.on('server-sunsubscribe', async (channel, listeners) => {
|
||||
try {
|
||||
await this.rediscover(client);
|
||||
const redirectTo = await this.getShardedPubSubClient(channel);
|
||||
await redirectTo.extendPubSubChannelListeners(pub_sub_1.PUBSUB_TYPE.SHARDED, channel, listeners);
|
||||
}
|
||||
catch (err) {
|
||||
this.#emit('sharded-shannel-moved-error', err, channel, listeners);
|
||||
}
|
||||
});
|
||||
master.pubSub = {
|
||||
client,
|
||||
connectPromise: client.connect()
|
||||
.then(client => {
|
||||
master.pubSub.connectPromise = undefined;
|
||||
return client;
|
||||
})
|
||||
.catch(err => {
|
||||
master.pubSub = undefined;
|
||||
throw err;
|
||||
})
|
||||
};
|
||||
return master.pubSub.connectPromise;
|
||||
}
|
||||
async executeShardedUnsubscribeCommand(channel, unsubscribe) {
|
||||
const { master } = this.slots[(0, cluster_key_slot_1.default)(channel)];
|
||||
if (!master.pubSub)
|
||||
return;
|
||||
const client = master.pubSub.connectPromise ?
|
||||
await master.pubSub.connectPromise :
|
||||
master.pubSub.client;
|
||||
await unsubscribe(client);
|
||||
if (!client.isPubSubActive) {
|
||||
client.destroy();
|
||||
master.pubSub = undefined;
|
||||
}
|
||||
}
|
||||
}
|
||||
_a = RedisClusterSlots;
|
||||
exports.default = RedisClusterSlots;
|
||||
//# sourceMappingURL=cluster-slots.js.map
|
||||
1
node_modules/@redis/client/dist/lib/cluster/cluster-slots.js.map
generated
vendored
Normal file
1
node_modules/@redis/client/dist/lib/cluster/cluster-slots.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
178
node_modules/@redis/client/dist/lib/cluster/index.d.ts
generated
vendored
Normal file
178
node_modules/@redis/client/dist/lib/cluster/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1,178 @@
|
||||
/// <reference types="node" />
|
||||
import { RedisClientOptions, RedisClientType } from '../client';
|
||||
import { CommandOptions } from '../client/commands-queue';
|
||||
import { CommandArguments, CommanderConfig, TypeMapping, RedisArgument, RedisFunctions, RedisModules, RedisScripts, ReplyUnion, RespVersions } from '../RESP/types';
|
||||
import { EventEmitter } from 'node:events';
|
||||
import RedisClusterSlots, { NodeAddressMap, ShardNode } from './cluster-slots';
|
||||
import { RedisClusterMultiCommandType } from './multi-command';
|
||||
import { PubSubListener, PubSubListeners } from '../client/pub-sub';
|
||||
import { RedisTcpSocketOptions } from '../client/socket';
|
||||
import { ClientSideCacheConfig, PooledClientSideCacheProvider } from '../client/cache';
|
||||
import { WithCommands, WithFunctions, WithModules, WithScripts } from '../client';
|
||||
interface ClusterCommander<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> extends CommanderConfig<M, F, S, RESP> {
|
||||
commandOptions?: ClusterCommandOptions<TYPE_MAPPING>;
|
||||
}
|
||||
export type RedisClusterClientOptions = Omit<RedisClientOptions<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisTcpSocketOptions>, keyof ClusterCommander<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>>;
|
||||
export interface RedisClusterOptions<M extends RedisModules = RedisModules, F extends RedisFunctions = RedisFunctions, S extends RedisScripts = RedisScripts, RESP extends RespVersions = RespVersions, TYPE_MAPPING extends TypeMapping = TypeMapping> extends ClusterCommander<M, F, S, RESP, TYPE_MAPPING> {
|
||||
/**
|
||||
* Should contain details for some of the cluster nodes that the client will use to discover
|
||||
* the "cluster topology". We recommend including details for at least 3 nodes here.
|
||||
*/
|
||||
rootNodes: Array<RedisClusterClientOptions>;
|
||||
/**
|
||||
* Default values used for every client in the cluster. Use this to specify global values,
|
||||
* for example: ACL credentials, timeouts, TLS configuration etc.
|
||||
*/
|
||||
defaults?: Partial<RedisClusterClientOptions>;
|
||||
/**
|
||||
* When `true`, `.connect()` will only discover the cluster topology, without actually connecting to all the nodes.
|
||||
* Useful for short-term or PubSub-only connections.
|
||||
*/
|
||||
minimizeConnections?: boolean;
|
||||
/**
|
||||
* When `true`, distribute load by executing readonly commands (such as `GET`, `GEOSEARCH`, etc.) across all cluster nodes. When `false`, only use master nodes.
|
||||
*/
|
||||
useReplicas?: boolean;
|
||||
/**
|
||||
* The maximum number of times a command will be redirected due to `MOVED` or `ASK` errors.
|
||||
*/
|
||||
maxCommandRedirections?: number;
|
||||
/**
|
||||
* Mapping between the addresses in the cluster (see `CLUSTER SHARDS`) and the addresses the client should connect to
|
||||
* Useful when the cluster is running on another network
|
||||
*/
|
||||
nodeAddressMap?: NodeAddressMap;
|
||||
/**
|
||||
* Client Side Caching configuration for the pool.
|
||||
*
|
||||
* Enables Redis Servers and Clients to work together to cache results from commands
|
||||
* sent to a server. The server will notify the client when cached results are no longer valid.
|
||||
* In pooled mode, the cache is shared across all clients in the pool.
|
||||
*
|
||||
* Note: Client Side Caching is only supported with RESP3.
|
||||
*
|
||||
* @example Anonymous cache configuration
|
||||
* ```
|
||||
* const client = createCluster({
|
||||
* clientSideCache: {
|
||||
* ttl: 0,
|
||||
* maxEntries: 0,
|
||||
* evictPolicy: "LRU"
|
||||
* },
|
||||
* minimum: 5
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* @example Using a controllable cache
|
||||
* ```
|
||||
* const cache = new BasicPooledClientSideCache({
|
||||
* ttl: 0,
|
||||
* maxEntries: 0,
|
||||
* evictPolicy: "LRU"
|
||||
* });
|
||||
* const client = createCluster({
|
||||
* clientSideCache: cache,
|
||||
* minimum: 5
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
clientSideCache?: PooledClientSideCacheProvider | ClientSideCacheConfig;
|
||||
}
|
||||
export type RedisClusterType<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}> = (RedisCluster<M, F, S, RESP, TYPE_MAPPING> & WithCommands<RESP, TYPE_MAPPING> & WithModules<M, RESP, TYPE_MAPPING> & WithFunctions<F, RESP, TYPE_MAPPING> & WithScripts<S, RESP, TYPE_MAPPING>);
|
||||
export interface ClusterCommandOptions<TYPE_MAPPING extends TypeMapping = TypeMapping> extends CommandOptions<TYPE_MAPPING> {
|
||||
}
|
||||
export default class RedisCluster<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> extends EventEmitter {
|
||||
#private;
|
||||
static factory<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}>(config?: ClusterCommander<M, F, S, RESP, TYPE_MAPPING>): (options?: Omit<RedisClusterOptions, keyof Exclude<typeof config, undefined>>) => RedisClusterType<M, F, S, RESP, TYPE_MAPPING>;
|
||||
static create<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}>(options?: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING>): RedisClusterType<M, F, S, RESP, TYPE_MAPPING>;
|
||||
readonly _options: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING>;
|
||||
readonly _slots: RedisClusterSlots<M, F, S, RESP, TYPE_MAPPING>;
|
||||
private _self;
|
||||
private _commandOptions?;
|
||||
/**
|
||||
* An array of the cluster slots, each slot contain its `master` and `replicas`.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific node (master or replica).
|
||||
*/
|
||||
get slots(): import("./cluster-slots").Shard<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
get clientSideCache(): PooledClientSideCacheProvider | undefined;
|
||||
/**
|
||||
* An array of the cluster masters.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific master node.
|
||||
*/
|
||||
get masters(): import("./cluster-slots").MasterNode<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
/**
|
||||
* An array of the cluster replicas.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific replica node.
|
||||
*/
|
||||
get replicas(): ShardNode<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
/**
|
||||
* A map form a node address (`<host>:<port>`) to its shard, each shard contain its `master` and `replicas`.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific node (master or replica).
|
||||
*/
|
||||
get nodeByAddress(): Map<string, import("./cluster-slots").MasterNode<M, F, S, RESP, TYPE_MAPPING> | ShardNode<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
/**
|
||||
* The current pub/sub node.
|
||||
*/
|
||||
get pubSubNode(): (Omit<import("./cluster-slots").Node<M, F, S, RESP, TYPE_MAPPING>, "client"> & Required<Pick<import("./cluster-slots").Node<M, F, S, RESP, TYPE_MAPPING>, "client">>) | undefined;
|
||||
get isOpen(): boolean;
|
||||
constructor(options: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING>);
|
||||
duplicate<_M extends RedisModules = M, _F extends RedisFunctions = F, _S extends RedisScripts = S, _RESP extends RespVersions = RESP, _TYPE_MAPPING extends TypeMapping = TYPE_MAPPING>(overrides?: Partial<RedisClusterOptions<_M, _F, _S, _RESP, _TYPE_MAPPING>>): RedisClusterType<_M, _F, _S, _RESP, _TYPE_MAPPING>;
|
||||
connect(): Promise<RedisClusterType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
withCommandOptions<OPTIONS extends ClusterCommandOptions<TYPE_MAPPING>, TYPE_MAPPING extends TypeMapping>(options: OPTIONS): RedisClusterType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping ? TYPE_MAPPING : {}>;
|
||||
private _commandOptionsProxy;
|
||||
/**
|
||||
* Override the `typeMapping` command option
|
||||
*/
|
||||
withTypeMapping<TYPE_MAPPING extends TypeMapping>(typeMapping: TYPE_MAPPING): RedisClusterType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping ? TYPE_MAPPING : {}>;
|
||||
_handleAsk<T>(fn: (client: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, opts?: ClusterCommandOptions) => Promise<T>): (client: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, options?: ClusterCommandOptions) => Promise<T>;
|
||||
_execute<T>(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, options: ClusterCommandOptions | undefined, fn: (client: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, opts?: ClusterCommandOptions) => Promise<T>): Promise<T>;
|
||||
sendCommand<T = ReplyUnion>(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, args: CommandArguments, options?: ClusterCommandOptions): Promise<T>;
|
||||
MULTI(routing?: RedisArgument): RedisClusterMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>;
|
||||
multi: (routing?: RedisArgument) => RedisClusterMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>;
|
||||
SUBSCRIBE<T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T): Promise<void>;
|
||||
subscribe: <T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T | undefined) => Promise<void>;
|
||||
UNSUBSCRIBE<T extends boolean = false>(channels?: string | Array<string>, listener?: PubSubListener<boolean>, bufferMode?: T): Promise<void>;
|
||||
unsubscribe: <T extends boolean = false>(channels?: string | Array<string>, listener?: PubSubListener<boolean>, bufferMode?: T | undefined) => Promise<void>;
|
||||
PSUBSCRIBE<T extends boolean = false>(patterns: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T): Promise<void>;
|
||||
pSubscribe: <T extends boolean = false>(patterns: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T | undefined) => Promise<void>;
|
||||
PUNSUBSCRIBE<T extends boolean = false>(patterns?: string | Array<string>, listener?: PubSubListener<T>, bufferMode?: T): Promise<void>;
|
||||
pUnsubscribe: <T extends boolean = false>(patterns?: string | Array<string>, listener?: PubSubListener<T> | undefined, bufferMode?: T | undefined) => Promise<void>;
|
||||
SSUBSCRIBE<T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T): Promise<void>;
|
||||
sSubscribe: <T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T | undefined) => Promise<void>;
|
||||
SUNSUBSCRIBE<T extends boolean = false>(channels: string | Array<string>, listener?: PubSubListener<T>, bufferMode?: T): Promise<void>;
|
||||
resubscribeAllPubSubListeners(allListeners: PubSubListeners): void;
|
||||
sUnsubscribe: <T extends boolean = false>(channels: string | Array<string>, listener?: PubSubListener<T> | undefined, bufferMode?: T | undefined) => Promise<void>;
|
||||
/**
|
||||
* @deprecated Use `close` instead.
|
||||
*/
|
||||
quit(): Promise<void>;
|
||||
/**
|
||||
* @deprecated Use `destroy` instead.
|
||||
*/
|
||||
disconnect(): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
destroy(): void;
|
||||
nodeClient(node: ShardNode<M, F, S, RESP, TYPE_MAPPING>): RedisClientType<M, F, S, RESP, TYPE_MAPPING> | Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
|
||||
/**
|
||||
* Returns a random node from the cluster.
|
||||
* Userful for running "forward" commands (like PUBLISH) on a random node.
|
||||
*/
|
||||
getRandomNode(): ShardNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
/**
|
||||
* Get a random node from a slot.
|
||||
* Useful for running readonly commands on a slot.
|
||||
*/
|
||||
getSlotRandomNode(slot: number): ShardNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
/**
|
||||
* @deprecated use `.masters` instead
|
||||
* TODO
|
||||
*/
|
||||
getMasters(): import("./cluster-slots").MasterNode<M, F, S, RESP, TYPE_MAPPING>[];
|
||||
/**
|
||||
* @deprecated use `.slots[<SLOT>]` instead
|
||||
* TODO
|
||||
*/
|
||||
getSlotMaster(slot: number): import("./cluster-slots").MasterNode<M, F, S, RESP, TYPE_MAPPING>;
|
||||
}
|
||||
export {};
|
||||
//# sourceMappingURL=index.d.ts.map
|
||||
1
node_modules/@redis/client/dist/lib/cluster/index.d.ts.map
generated
vendored
Normal file
1
node_modules/@redis/client/dist/lib/cluster/index.d.ts.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
357
node_modules/@redis/client/dist/lib/cluster/index.js
generated
vendored
Normal file
357
node_modules/@redis/client/dist/lib/cluster/index.js
generated
vendored
Normal file
@@ -0,0 +1,357 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const commands_1 = __importDefault(require("../commands"));
|
||||
const node_events_1 = require("node:events");
|
||||
const commander_1 = require("../commander");
|
||||
const cluster_slots_1 = __importDefault(require("./cluster-slots"));
|
||||
const multi_command_1 = __importDefault(require("./multi-command"));
|
||||
const errors_1 = require("../errors");
|
||||
const parser_1 = require("../client/parser");
|
||||
const ASKING_1 = require("../commands/ASKING");
|
||||
const single_entry_cache_1 = __importDefault(require("../single-entry-cache"));
|
||||
class RedisCluster extends node_events_1.EventEmitter {
|
||||
static #createCommand(command, resp) {
|
||||
const transformReply = (0, commander_1.getTransformReply)(command, resp);
|
||||
return async function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
command.parseCommand(parser, ...args);
|
||||
return this._self._execute(parser.firstKey, command.IS_READ_ONLY, this._commandOptions, (client, opts) => client._executeCommand(command, parser, opts, transformReply));
|
||||
};
|
||||
}
|
||||
static #createModuleCommand(command, resp) {
|
||||
const transformReply = (0, commander_1.getTransformReply)(command, resp);
|
||||
return async function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
command.parseCommand(parser, ...args);
|
||||
return this._self._execute(parser.firstKey, command.IS_READ_ONLY, this._self._commandOptions, (client, opts) => client._executeCommand(command, parser, opts, transformReply));
|
||||
};
|
||||
}
|
||||
static #createFunctionCommand(name, fn, resp) {
|
||||
const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn);
|
||||
const transformReply = (0, commander_1.getTransformReply)(fn, resp);
|
||||
return async function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
parser.push(...prefix);
|
||||
fn.parseCommand(parser, ...args);
|
||||
return this._self._execute(parser.firstKey, fn.IS_READ_ONLY, this._self._commandOptions, (client, opts) => client._executeCommand(fn, parser, opts, transformReply));
|
||||
};
|
||||
}
|
||||
static #createScriptCommand(script, resp) {
|
||||
const prefix = (0, commander_1.scriptArgumentsPrefix)(script);
|
||||
const transformReply = (0, commander_1.getTransformReply)(script, resp);
|
||||
return async function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
parser.push(...prefix);
|
||||
script.parseCommand(parser, ...args);
|
||||
return this._self._execute(parser.firstKey, script.IS_READ_ONLY, this._commandOptions, (client, opts) => client._executeScript(script, parser, opts, transformReply));
|
||||
};
|
||||
}
|
||||
static #SingleEntryCache = new single_entry_cache_1.default();
|
||||
static factory(config) {
|
||||
let Cluster = RedisCluster.#SingleEntryCache.get(config);
|
||||
if (!Cluster) {
|
||||
Cluster = (0, commander_1.attachConfig)({
|
||||
BaseClass: RedisCluster,
|
||||
commands: commands_1.default,
|
||||
createCommand: RedisCluster.#createCommand,
|
||||
createModuleCommand: RedisCluster.#createModuleCommand,
|
||||
createFunctionCommand: RedisCluster.#createFunctionCommand,
|
||||
createScriptCommand: RedisCluster.#createScriptCommand,
|
||||
config
|
||||
});
|
||||
Cluster.prototype.Multi = multi_command_1.default.extend(config);
|
||||
RedisCluster.#SingleEntryCache.set(config, Cluster);
|
||||
}
|
||||
return (options) => {
|
||||
// returning a "proxy" to prevent the namespaces._self to leak between "proxies"
|
||||
return Object.create(new Cluster(options));
|
||||
};
|
||||
}
|
||||
static create(options) {
|
||||
return RedisCluster.factory(options)(options);
|
||||
}
|
||||
_options;
|
||||
_slots;
|
||||
_self = this;
|
||||
_commandOptions;
|
||||
/**
|
||||
* An array of the cluster slots, each slot contain its `master` and `replicas`.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific node (master or replica).
|
||||
*/
|
||||
get slots() {
|
||||
return this._self._slots.slots;
|
||||
}
|
||||
get clientSideCache() {
|
||||
return this._self._slots.clientSideCache;
|
||||
}
|
||||
/**
|
||||
* An array of the cluster masters.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific master node.
|
||||
*/
|
||||
get masters() {
|
||||
return this._self._slots.masters;
|
||||
}
|
||||
/**
|
||||
* An array of the cluster replicas.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific replica node.
|
||||
*/
|
||||
get replicas() {
|
||||
return this._self._slots.replicas;
|
||||
}
|
||||
/**
|
||||
* A map form a node address (`<host>:<port>`) to its shard, each shard contain its `master` and `replicas`.
|
||||
* Use with {@link RedisCluster.prototype.nodeClient} to get the client for a specific node (master or replica).
|
||||
*/
|
||||
get nodeByAddress() {
|
||||
return this._self._slots.nodeByAddress;
|
||||
}
|
||||
/**
|
||||
* The current pub/sub node.
|
||||
*/
|
||||
get pubSubNode() {
|
||||
return this._self._slots.pubSubNode;
|
||||
}
|
||||
get isOpen() {
|
||||
return this._self._slots.isOpen;
|
||||
}
|
||||
constructor(options) {
|
||||
super();
|
||||
this._options = options;
|
||||
this._slots = new cluster_slots_1.default(options, this.emit.bind(this));
|
||||
this.on('__resubscribeAllPubSubListeners', this.resubscribeAllPubSubListeners.bind(this));
|
||||
if (options?.commandOptions) {
|
||||
this._commandOptions = options.commandOptions;
|
||||
}
|
||||
}
|
||||
duplicate(overrides) {
|
||||
return new (Object.getPrototypeOf(this).constructor)({
|
||||
...this._self._options,
|
||||
commandOptions: this._commandOptions,
|
||||
...overrides
|
||||
});
|
||||
}
|
||||
async connect() {
|
||||
await this._self._slots.connect();
|
||||
return this;
|
||||
}
|
||||
withCommandOptions(options) {
|
||||
const proxy = Object.create(this);
|
||||
proxy._commandOptions = options;
|
||||
return proxy;
|
||||
}
|
||||
_commandOptionsProxy(key, value) {
|
||||
const proxy = Object.create(this);
|
||||
proxy._commandOptions = Object.create(this._commandOptions ?? null);
|
||||
proxy._commandOptions[key] = value;
|
||||
return proxy;
|
||||
}
|
||||
/**
|
||||
* Override the `typeMapping` command option
|
||||
*/
|
||||
withTypeMapping(typeMapping) {
|
||||
return this._commandOptionsProxy('typeMapping', typeMapping);
|
||||
}
|
||||
// /**
|
||||
// * Override the `policies` command option
|
||||
// * TODO
|
||||
// */
|
||||
// withPolicies<POLICIES extends CommandPolicies> (policies: POLICIES) {
|
||||
// return this._commandOptionsProxy('policies', policies);
|
||||
// }
|
||||
_handleAsk(fn) {
|
||||
return async (client, options) => {
|
||||
const chainId = Symbol("asking chain");
|
||||
const opts = options ? { ...options } : {};
|
||||
opts.chainId = chainId;
|
||||
const ret = await Promise.all([
|
||||
client.sendCommand([ASKING_1.ASKING_CMD], { chainId: chainId }),
|
||||
fn(client, opts)
|
||||
]);
|
||||
return ret[1];
|
||||
};
|
||||
}
|
||||
async _execute(firstKey, isReadonly, options, fn) {
|
||||
const maxCommandRedirections = this._options.maxCommandRedirections ?? 16;
|
||||
let client = await this._slots.getClient(firstKey, isReadonly);
|
||||
let i = 0;
|
||||
let myFn = fn;
|
||||
while (true) {
|
||||
try {
|
||||
return await myFn(client, options);
|
||||
}
|
||||
catch (err) {
|
||||
myFn = fn;
|
||||
// TODO: error class
|
||||
if (++i > maxCommandRedirections || !(err instanceof Error)) {
|
||||
throw err;
|
||||
}
|
||||
if (err.message.startsWith('ASK')) {
|
||||
const address = err.message.substring(err.message.lastIndexOf(' ') + 1);
|
||||
let redirectTo = await this._slots.getMasterByAddress(address);
|
||||
if (!redirectTo) {
|
||||
await this._slots.rediscover(client);
|
||||
redirectTo = await this._slots.getMasterByAddress(address);
|
||||
}
|
||||
if (!redirectTo) {
|
||||
throw new Error(`Cannot find node ${address}`);
|
||||
}
|
||||
client = redirectTo;
|
||||
myFn = this._handleAsk(fn);
|
||||
continue;
|
||||
}
|
||||
if (err.message.startsWith('MOVED')) {
|
||||
await this._slots.rediscover(client);
|
||||
client = await this._slots.getClient(firstKey, isReadonly);
|
||||
continue;
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
}
|
||||
async sendCommand(firstKey, isReadonly, args, options) {
|
||||
// Merge global options with local options
|
||||
const opts = {
|
||||
...this._self._commandOptions,
|
||||
...options
|
||||
};
|
||||
return this._self._execute(firstKey, isReadonly, opts, (client, opts) => client.sendCommand(args, opts));
|
||||
}
|
||||
MULTI(routing) {
|
||||
return new this.Multi(async (firstKey, isReadonly, commands) => {
|
||||
const client = await this._self._slots.getClient(firstKey, isReadonly);
|
||||
return client._executeMulti(commands);
|
||||
}, async (firstKey, isReadonly, commands) => {
|
||||
const client = await this._self._slots.getClient(firstKey, isReadonly);
|
||||
return client._executePipeline(commands);
|
||||
}, routing, this._commandOptions?.typeMapping);
|
||||
}
|
||||
multi = this.MULTI;
|
||||
async SUBSCRIBE(channels, listener, bufferMode) {
|
||||
return (await this._self._slots.getPubSubClient())
|
||||
.SUBSCRIBE(channels, listener, bufferMode);
|
||||
}
|
||||
subscribe = this.SUBSCRIBE;
|
||||
async UNSUBSCRIBE(channels, listener, bufferMode) {
|
||||
return this._self._slots.executeUnsubscribeCommand(client => client.UNSUBSCRIBE(channels, listener, bufferMode));
|
||||
}
|
||||
unsubscribe = this.UNSUBSCRIBE;
|
||||
async PSUBSCRIBE(patterns, listener, bufferMode) {
|
||||
return (await this._self._slots.getPubSubClient())
|
||||
.PSUBSCRIBE(patterns, listener, bufferMode);
|
||||
}
|
||||
pSubscribe = this.PSUBSCRIBE;
|
||||
async PUNSUBSCRIBE(patterns, listener, bufferMode) {
|
||||
return this._self._slots.executeUnsubscribeCommand(client => client.PUNSUBSCRIBE(patterns, listener, bufferMode));
|
||||
}
|
||||
pUnsubscribe = this.PUNSUBSCRIBE;
|
||||
async SSUBSCRIBE(channels, listener, bufferMode) {
|
||||
const maxCommandRedirections = this._self._options.maxCommandRedirections ?? 16, firstChannel = Array.isArray(channels) ? channels[0] : channels;
|
||||
let client = await this._self._slots.getShardedPubSubClient(firstChannel);
|
||||
for (let i = 0;; i++) {
|
||||
try {
|
||||
return await client.SSUBSCRIBE(channels, listener, bufferMode);
|
||||
}
|
||||
catch (err) {
|
||||
if (++i > maxCommandRedirections || !(err instanceof errors_1.ErrorReply)) {
|
||||
throw err;
|
||||
}
|
||||
if (err.message.startsWith('MOVED')) {
|
||||
await this._self._slots.rediscover(client);
|
||||
client = await this._self._slots.getShardedPubSubClient(firstChannel);
|
||||
continue;
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
}
|
||||
sSubscribe = this.SSUBSCRIBE;
|
||||
SUNSUBSCRIBE(channels, listener, bufferMode) {
|
||||
return this._self._slots.executeShardedUnsubscribeCommand(Array.isArray(channels) ? channels[0] : channels, client => client.SUNSUBSCRIBE(channels, listener, bufferMode));
|
||||
}
|
||||
resubscribeAllPubSubListeners(allListeners) {
|
||||
for (const [channel, listeners] of allListeners.CHANNELS) {
|
||||
listeners.buffers.forEach(bufListener => {
|
||||
this.subscribe(channel, bufListener, true);
|
||||
});
|
||||
listeners.strings.forEach(strListener => {
|
||||
this.subscribe(channel, strListener);
|
||||
});
|
||||
}
|
||||
;
|
||||
for (const [channel, listeners] of allListeners.PATTERNS) {
|
||||
listeners.buffers.forEach(bufListener => {
|
||||
this.pSubscribe(channel, bufListener, true);
|
||||
});
|
||||
listeners.strings.forEach(strListener => {
|
||||
this.pSubscribe(channel, strListener);
|
||||
});
|
||||
}
|
||||
;
|
||||
for (const [channel, listeners] of allListeners.SHARDED) {
|
||||
listeners.buffers.forEach(bufListener => {
|
||||
this.sSubscribe(channel, bufListener, true);
|
||||
});
|
||||
listeners.strings.forEach(strListener => {
|
||||
this.sSubscribe(channel, strListener);
|
||||
});
|
||||
}
|
||||
;
|
||||
}
|
||||
sUnsubscribe = this.SUNSUBSCRIBE;
|
||||
/**
|
||||
* @deprecated Use `close` instead.
|
||||
*/
|
||||
quit() {
|
||||
return this._self._slots.quit();
|
||||
}
|
||||
/**
|
||||
* @deprecated Use `destroy` instead.
|
||||
*/
|
||||
disconnect() {
|
||||
return this._self._slots.disconnect();
|
||||
}
|
||||
close() {
|
||||
this._self._slots.clientSideCache?.onPoolClose();
|
||||
return this._self._slots.close();
|
||||
}
|
||||
destroy() {
|
||||
this._self._slots.clientSideCache?.onPoolClose();
|
||||
return this._self._slots.destroy();
|
||||
}
|
||||
nodeClient(node) {
|
||||
return this._self._slots.nodeClient(node);
|
||||
}
|
||||
/**
|
||||
* Returns a random node from the cluster.
|
||||
* Userful for running "forward" commands (like PUBLISH) on a random node.
|
||||
*/
|
||||
getRandomNode() {
|
||||
return this._self._slots.getRandomNode();
|
||||
}
|
||||
/**
|
||||
* Get a random node from a slot.
|
||||
* Useful for running readonly commands on a slot.
|
||||
*/
|
||||
getSlotRandomNode(slot) {
|
||||
return this._self._slots.getSlotRandomNode(slot);
|
||||
}
|
||||
/**
|
||||
* @deprecated use `.masters` instead
|
||||
* TODO
|
||||
*/
|
||||
getMasters() {
|
||||
return this.masters;
|
||||
}
|
||||
/**
|
||||
* @deprecated use `.slots[<SLOT>]` instead
|
||||
* TODO
|
||||
*/
|
||||
getSlotMaster(slot) {
|
||||
return this.slots[slot].master;
|
||||
}
|
||||
}
|
||||
exports.default = RedisCluster;
|
||||
//# sourceMappingURL=index.js.map
|
||||
1
node_modules/@redis/client/dist/lib/cluster/index.js.map
generated
vendored
Normal file
1
node_modules/@redis/client/dist/lib/cluster/index.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
39
node_modules/@redis/client/dist/lib/cluster/multi-command.d.ts
generated
vendored
Normal file
39
node_modules/@redis/client/dist/lib/cluster/multi-command.d.ts
generated
vendored
Normal file
@@ -0,0 +1,39 @@
|
||||
import COMMANDS from '../commands';
|
||||
import { MULTI_REPLY, MultiReply, MultiReplyType, RedisMultiQueuedCommand } from '../multi-command';
|
||||
import { ReplyWithTypeMapping, CommandReply, Command, CommandArguments, CommanderConfig, RedisFunctions, RedisModules, RedisScripts, RespVersions, TransformReply, TypeMapping, RedisArgument } from '../RESP/types';
|
||||
import { Tail } from '../commands/generic-transformers';
|
||||
type CommandSignature<REPLIES extends Array<unknown>, C extends Command, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = (...args: Tail<Parameters<C['parseCommand']>>) => RedisClusterMultiCommandType<[
|
||||
...REPLIES,
|
||||
ReplyWithTypeMapping<CommandReply<C, RESP>, TYPE_MAPPING>
|
||||
], M, F, S, RESP, TYPE_MAPPING>;
|
||||
type WithCommands<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
|
||||
[P in keyof typeof COMMANDS]: CommandSignature<REPLIES, (typeof COMMANDS)[P], M, F, S, RESP, TYPE_MAPPING>;
|
||||
};
|
||||
type WithModules<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
|
||||
[P in keyof M]: {
|
||||
[C in keyof M[P]]: CommandSignature<REPLIES, M[P][C], M, F, S, RESP, TYPE_MAPPING>;
|
||||
};
|
||||
};
|
||||
type WithFunctions<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
|
||||
[L in keyof F]: {
|
||||
[C in keyof F[L]]: CommandSignature<REPLIES, F[L][C], M, F, S, RESP, TYPE_MAPPING>;
|
||||
};
|
||||
};
|
||||
type WithScripts<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
|
||||
[P in keyof S]: CommandSignature<REPLIES, S[P], M, F, S, RESP, TYPE_MAPPING>;
|
||||
};
|
||||
export type RedisClusterMultiCommandType<REPLIES extends Array<any>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = (RedisClusterMultiCommand<REPLIES> & WithCommands<REPLIES, M, F, S, RESP, TYPE_MAPPING> & WithModules<REPLIES, M, F, S, RESP, TYPE_MAPPING> & WithFunctions<REPLIES, M, F, S, RESP, TYPE_MAPPING> & WithScripts<REPLIES, M, F, S, RESP, TYPE_MAPPING>);
|
||||
export type ClusterMultiExecute = (firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, commands: Array<RedisMultiQueuedCommand>) => Promise<Array<unknown>>;
|
||||
export default class RedisClusterMultiCommand<REPLIES = []> {
|
||||
#private;
|
||||
static extend<M extends RedisModules = Record<string, never>, F extends RedisFunctions = Record<string, never>, S extends RedisScripts = Record<string, never>, RESP extends RespVersions = 2>(config?: CommanderConfig<M, F, S, RESP>): any;
|
||||
constructor(executeMulti: ClusterMultiExecute, executePipeline: ClusterMultiExecute, routing: RedisArgument | undefined, typeMapping?: TypeMapping);
|
||||
addCommand(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, args: CommandArguments, transformReply?: TransformReply): this;
|
||||
exec<T extends MultiReply = MULTI_REPLY['GENERIC']>(execAsPipeline?: boolean): Promise<MultiReplyType<T, REPLIES>>;
|
||||
EXEC: <T extends MultiReply = "generic">(execAsPipeline?: boolean) => Promise<MultiReplyType<T, REPLIES>>;
|
||||
execTyped(execAsPipeline?: boolean): Promise<REPLIES>;
|
||||
execAsPipeline<T extends MultiReply = MULTI_REPLY['GENERIC']>(): Promise<MultiReplyType<T, REPLIES>>;
|
||||
execAsPipelineTyped(): Promise<REPLIES>;
|
||||
}
|
||||
export {};
|
||||
//# sourceMappingURL=multi-command.d.ts.map
|
||||
1
node_modules/@redis/client/dist/lib/cluster/multi-command.d.ts.map
generated
vendored
Normal file
1
node_modules/@redis/client/dist/lib/cluster/multi-command.d.ts.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"multi-command.d.ts","sourceRoot":"","sources":["../../../lib/cluster/multi-command.ts"],"names":[],"mappings":"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"}
|
||||
112
node_modules/@redis/client/dist/lib/cluster/multi-command.js
generated
vendored
Normal file
112
node_modules/@redis/client/dist/lib/cluster/multi-command.js
generated
vendored
Normal file
@@ -0,0 +1,112 @@
|
||||
"use strict";
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const commands_1 = __importDefault(require("../commands"));
|
||||
const multi_command_1 = __importDefault(require("../multi-command"));
|
||||
const commander_1 = require("../commander");
|
||||
const parser_1 = require("../client/parser");
|
||||
class RedisClusterMultiCommand {
|
||||
static #createCommand(command, resp) {
|
||||
const transformReply = (0, commander_1.getTransformReply)(command, resp);
|
||||
return function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
command.parseCommand(parser, ...args);
|
||||
const redisArgs = parser.redisArgs;
|
||||
redisArgs.preserve = parser.preserve;
|
||||
const firstKey = parser.firstKey;
|
||||
return this.addCommand(firstKey, command.IS_READ_ONLY, redisArgs, transformReply);
|
||||
};
|
||||
}
|
||||
static #createModuleCommand(command, resp) {
|
||||
const transformReply = (0, commander_1.getTransformReply)(command, resp);
|
||||
return function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
command.parseCommand(parser, ...args);
|
||||
const redisArgs = parser.redisArgs;
|
||||
redisArgs.preserve = parser.preserve;
|
||||
const firstKey = parser.firstKey;
|
||||
return this._self.addCommand(firstKey, command.IS_READ_ONLY, redisArgs, transformReply);
|
||||
};
|
||||
}
|
||||
static #createFunctionCommand(name, fn, resp) {
|
||||
const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn);
|
||||
const transformReply = (0, commander_1.getTransformReply)(fn, resp);
|
||||
return function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
parser.push(...prefix);
|
||||
fn.parseCommand(parser, ...args);
|
||||
const redisArgs = parser.redisArgs;
|
||||
redisArgs.preserve = parser.preserve;
|
||||
const firstKey = parser.firstKey;
|
||||
return this._self.addCommand(firstKey, fn.IS_READ_ONLY, redisArgs, transformReply);
|
||||
};
|
||||
}
|
||||
static #createScriptCommand(script, resp) {
|
||||
const transformReply = (0, commander_1.getTransformReply)(script, resp);
|
||||
return function (...args) {
|
||||
const parser = new parser_1.BasicCommandParser();
|
||||
script.parseCommand(parser, ...args);
|
||||
const scriptArgs = parser.redisArgs;
|
||||
scriptArgs.preserve = parser.preserve;
|
||||
const firstKey = parser.firstKey;
|
||||
return this.#addScript(firstKey, script.IS_READ_ONLY, script, scriptArgs, transformReply);
|
||||
};
|
||||
}
|
||||
static extend(config) {
|
||||
return (0, commander_1.attachConfig)({
|
||||
BaseClass: RedisClusterMultiCommand,
|
||||
commands: commands_1.default,
|
||||
createCommand: RedisClusterMultiCommand.#createCommand,
|
||||
createModuleCommand: RedisClusterMultiCommand.#createModuleCommand,
|
||||
createFunctionCommand: RedisClusterMultiCommand.#createFunctionCommand,
|
||||
createScriptCommand: RedisClusterMultiCommand.#createScriptCommand,
|
||||
config
|
||||
});
|
||||
}
|
||||
#multi;
|
||||
#executeMulti;
|
||||
#executePipeline;
|
||||
#firstKey;
|
||||
#isReadonly = true;
|
||||
constructor(executeMulti, executePipeline, routing, typeMapping) {
|
||||
this.#multi = new multi_command_1.default(typeMapping);
|
||||
this.#executeMulti = executeMulti;
|
||||
this.#executePipeline = executePipeline;
|
||||
this.#firstKey = routing;
|
||||
}
|
||||
#setState(firstKey, isReadonly) {
|
||||
this.#firstKey ??= firstKey;
|
||||
this.#isReadonly &&= isReadonly;
|
||||
}
|
||||
addCommand(firstKey, isReadonly, args, transformReply) {
|
||||
this.#setState(firstKey, isReadonly);
|
||||
this.#multi.addCommand(args, transformReply);
|
||||
return this;
|
||||
}
|
||||
#addScript(firstKey, isReadonly, script, args, transformReply) {
|
||||
this.#setState(firstKey, isReadonly);
|
||||
this.#multi.addScript(script, args, transformReply);
|
||||
return this;
|
||||
}
|
||||
async exec(execAsPipeline = false) {
|
||||
if (execAsPipeline)
|
||||
return this.execAsPipeline();
|
||||
return this.#multi.transformReplies(await this.#executeMulti(this.#firstKey, this.#isReadonly, this.#multi.queue));
|
||||
}
|
||||
EXEC = this.exec;
|
||||
execTyped(execAsPipeline = false) {
|
||||
return this.exec(execAsPipeline);
|
||||
}
|
||||
async execAsPipeline() {
|
||||
if (this.#multi.queue.length === 0)
|
||||
return [];
|
||||
return this.#multi.transformReplies(await this.#executePipeline(this.#firstKey, this.#isReadonly, this.#multi.queue));
|
||||
}
|
||||
execAsPipelineTyped() {
|
||||
return this.execAsPipeline();
|
||||
}
|
||||
}
|
||||
exports.default = RedisClusterMultiCommand;
|
||||
//# sourceMappingURL=multi-command.js.map
|
||||
1
node_modules/@redis/client/dist/lib/cluster/multi-command.js.map
generated
vendored
Normal file
1
node_modules/@redis/client/dist/lib/cluster/multi-command.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"file":"multi-command.js","sourceRoot":"","sources":["../../../lib/cluster/multi-command.ts"],"names":[],"mappings":"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"}
|
||||
Reference in New Issue
Block a user