-first commit
This commit is contained in:
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
|
||||
Reference in New Issue
Block a user