redis-smq
Version:
A high-performance, reliable, and scalable message queue for Node.js.
208 lines • 10.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.NamespaceManager = void 0;
const redis_smq_common_1 = require("redis-smq-common");
const redis_keys_js_1 = require("../common/redis/redis-keys/redis-keys.js");
const configuration_js_1 = require("../config-manager/configuration.js");
const _delete_queue_js_1 = require("../queue-manager/_/_delete-queue.js");
const index_js_1 = require("../errors/index.js");
const with_shared_pool_connection_js_1 = require("../common/redis/redis-connection-pool/with-shared-pool-connection.js");
const _get_namespace_queues_js_1 = require("./_/_get-namespace-queues.js");
const validator_js_1 = require("../common/redis/redis-keys/validator.js");
class NamespaceManager {
constructor() {
this.logger = (0, redis_smq_common_1.createLogger)(configuration_js_1.Configuration.getConfig().logger, this.constructor.name.toLowerCase());
}
getNamespaces(cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting all namespaces');
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
const { keyNamespaces } = redis_keys_js_1.redisKeys.getMainKeys();
this.logger.debug('Fetching namespaces from Redis', {
key: keyNamespaces,
});
client.smembers(keyNamespaces, (err, reply) => {
if (err) {
this.logger.error('Failed to get namespaces', {
error: err.message,
});
return cb(err);
}
if (!reply) {
this.logger.error('Empty namespaces reply');
return cb(new redis_smq_common_1.CallbackEmptyReplyError());
}
this.logger.debug('Successfully retrieved namespaces', {
count: reply.length,
});
cb(null, reply);
});
}, callback);
});
}
getNamespaceQueues(namespace, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Getting queues for namespace', { namespace });
const ns = (0, validator_js_1.validateRedisKey)(namespace);
if (ns instanceof Error) {
this.logger.error('Invalid namespace', { namespace });
return callback(new index_js_1.InvalidNamespaceError());
}
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
const { keyNamespaces } = redis_keys_js_1.redisKeys.getMainKeys();
const { keyNamespaceQueues } = redis_keys_js_1.redisKeys.getNamespaceKeys(ns);
this.logger.debug('Checking if namespace exists', {
namespace: ns,
key: keyNamespaces,
});
redis_smq_common_1.async.waterfall([
(cb) => {
client.sismember(keyNamespaces, ns, (err, reply) => {
if (err) {
this.logger.error('Failed to check namespace existence', {
namespace: ns,
error: err.message,
});
return cb(err);
}
if (!reply) {
this.logger.error('Namespace not found', {
namespace: ns,
});
return cb(new index_js_1.NamespaceNotFoundError());
}
this.logger.debug('Namespace exists', { namespace: ns });
cb();
});
},
(_, cb) => {
this.logger.debug('Fetching queues for namespace', {
namespace: ns,
key: keyNamespaceQueues,
});
client.smembers(keyNamespaceQueues, (err, reply) => {
if (err) {
this.logger.error('Failed to get namespace queues', {
namespace: ns,
error: err.message,
});
return cb(err);
}
if (!reply) {
this.logger.error('Empty queues reply', { namespace: ns });
return cb(new redis_smq_common_1.CallbackEmptyReplyError());
}
const messageQueues = reply.map((i) => JSON.parse(i));
this.logger.debug('Successfully retrieved namespace queues', {
namespace: ns,
queueCount: messageQueues.length,
});
cb(null, messageQueues);
});
},
], cb);
}, callback);
});
}
delete(namespace, cb) {
return redis_smq_common_1.async.withOptionalCallback(cb, (callback) => {
this.logger.debug('Deleting namespace', { namespace });
const ns = (0, validator_js_1.validateRedisKey)(namespace);
if (ns instanceof Error) {
this.logger.error('Invalid namespace', { namespace });
return callback(new index_js_1.InvalidNamespaceError());
}
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, cb) => {
const { keyNamespaces } = redis_keys_js_1.redisKeys.getMainKeys();
this.logger.debug('Checking if namespace exists before deletion', {
namespace: ns,
key: keyNamespaces,
});
redis_smq_common_1.async.waterfall([
(cb) => {
client.sismember(keyNamespaces, ns, (err, isMember) => {
if (err) {
this.logger.error('Failed to check namespace existence', {
namespace: ns,
error: err.message,
});
return cb(err);
}
if (!isMember) {
this.logger.error('Namespace not found for deletion', {
namespace: ns,
});
return cb(new index_js_1.NamespaceNotFoundError());
}
this.logger.debug('Namespace exists, proceeding with deletion', {
namespace: ns,
});
cb();
});
},
(_, cb) => {
this.logger.debug('Getting all queues for deletion', {
namespace: ns,
});
(0, _get_namespace_queues_js_1._getNamespaceQueues)(client, ns, (err, reply) => {
if (err) {
this.logger.error('Failed to get namespace queues for deletion', {
namespace: ns,
error: err.message,
});
}
cb(err, reply);
});
},
(queues, cb) => {
this.logger.debug('Preparing to delete namespace and its queues', {
namespace: ns,
queueCount: queues.length,
});
redis_smq_common_1.async.eachOf(queues, (queueParams, _, done) => {
this.logger.debug('Deleting queue', {
namespace: ns,
queue: queueParams.name,
});
(0, _delete_queue_js_1._deleteQueue)(client, queueParams, (err) => {
if (err) {
this.logger.error('Failed to delete queue', {
namespace: ns,
queue: queueParams.name,
error: err,
});
if (err instanceof index_js_1.QueueNotFoundError)
return done();
}
done(err);
});
}, (err) => {
if (err) {
this.logger.error('Failed during queue deletion', {
namespace: ns,
error: err,
});
return cb(err);
}
client.srem(keyNamespaces, ns, (err) => {
if (err) {
this.logger.error('Failed to delete namespace', {
namespace: ns,
error: err,
});
return cb(err);
}
this.logger.debug('Successfully deleted namespace', {
namespace: ns,
});
cb();
});
});
},
], (err) => cb(err));
}, callback);
});
}
}
exports.NamespaceManager = NamespaceManager;
//# sourceMappingURL=namespace-manager.js.map