357 lines
14 KiB
JavaScript
357 lines
14 KiB
JavaScript
|
"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
|