76 lines
3.4 KiB
JavaScript
76 lines
3.4 KiB
JavaScript
import { RedisQueueBackend } from '../classes/redis-queue-backend';
|
|
import { RedisConnection } from '../classes/redis-connection';
|
|
import { QueueKeys } from '../classes/queue-keys';
|
|
import { createIORedisClient, isIRedisClient } from '../classes/ioredis-client';
|
|
import { isRedisInstance } from './index';
|
|
/**
|
|
* Builds the dedicated, blocking connection that a worker needs so its blocking
|
|
* fetch (`BZPOPMIN`) does not stall regular operations. Reuses / duplicates the
|
|
* provided connection options with its own name.
|
|
*/
|
|
const createBlockingConnection = (name, opts) => {
|
|
var _a;
|
|
const base64Name = Buffer.from(name).toString('base64');
|
|
const workerName = opts.name;
|
|
const connectionName = `${(_a = opts.prefix) !== null && _a !== void 0 ? _a : 'bull'}:${base64Name}${workerName ? `:w:${workerName}` : ''}`;
|
|
return new RedisConnection(isRedisInstance(opts.connection)
|
|
? (isIRedisClient(opts.connection)
|
|
? opts.connection
|
|
: createIORedisClient(opts.connection)).duplicate({ connectionName })
|
|
: Object.assign(Object.assign({}, opts.connection), { connectionName }), {
|
|
shared: false,
|
|
blocking: true,
|
|
skipVersionCheck: opts.skipVersionCheck,
|
|
});
|
|
};
|
|
/**
|
|
* The default ({@link RedisConnection}-based) implementation of
|
|
* {@link BackendFactory}. The returned backend owns its connection(s); the
|
|
* high-level classes (Queue, Worker, FlowProducer, …) depend only on
|
|
* {@link IQueueBackend} and never touch a Redis client directly.
|
|
*
|
|
* Other datastores can provide their own {@link BackendFactory} and inject it
|
|
* into the queue classes.
|
|
*/
|
|
export const createRedisBackend = (name, opts, { blocking = false, withBlockingConnection = false } = {}) => {
|
|
const connection = new RedisConnection(opts.connection, {
|
|
shared: isRedisInstance(opts.connection),
|
|
blocking,
|
|
skipVersionCheck: opts.skipVersionCheck,
|
|
skipWaitingForReady: opts.skipWaitingForReady,
|
|
});
|
|
const blockingConnection = withBlockingConnection
|
|
? createBlockingConnection(name, opts)
|
|
: undefined;
|
|
const queueKeys = new QueueKeys(opts.prefix);
|
|
const keys = queueKeys.getKeys(name);
|
|
const toKey = (type) => queueKeys.toKey(name, type);
|
|
return new RedisQueueBackend(connection, name, keys, toKey, opts, blockingConnection);
|
|
};
|
|
/**
|
|
* The process-wide default {@link BackendFactory} used by the high-level
|
|
* classes ({@link QueueBase}, {@link FlowProducer}) when the caller does not
|
|
* pass an explicit `backendFactory`. Initialised to the Redis backend so the
|
|
* default behaviour is unchanged.
|
|
*/
|
|
let defaultBackendFactory = createRedisBackend;
|
|
/**
|
|
* Overrides the process-wide default {@link BackendFactory}. Useful to point
|
|
* every Queue/Worker/FlowProducer at a different datastore (e.g. the PostgreSQL
|
|
* backend) without threading a factory through every constructor — notably so
|
|
* the existing test suite can run unchanged against another backend.
|
|
*
|
|
* Pass no argument (or `undefined`) to reset back to the Redis backend.
|
|
*/
|
|
export function setDefaultBackendFactory(factory) {
|
|
defaultBackendFactory =
|
|
factory !== null && factory !== void 0 ? factory : createRedisBackend;
|
|
}
|
|
/**
|
|
* Returns the current process-wide default {@link BackendFactory}, typed as the
|
|
* caller's concrete backend `B`.
|
|
*/
|
|
export function getDefaultBackendFactory() {
|
|
return defaultBackendFactory;
|
|
}
|