redis-smq
Version:
A high-performance, reliable, and scalable message queue for Node.js.
198 lines • 9.09 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MessageBrowser = 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 _parse_queue_extended_params_js_1 = require("../../queue-manager/_/_parse-queue-extended-params.js");
const _validate_queue_extended_params_js_1 = require("./_/_validate-queue-extended-params.js");
const with_shared_pool_connection_js_1 = require("../../common/redis/redis-connection-pool/with-shared-pool-connection.js");
const index_js_1 = require("../../errors/index.js");
const purge_queue_job_manager_js_1 = require("../../common/background-jobs/jobs/purge-queue/purge-queue-job-manager.js");
const index_js_2 = require("../../queue-operation-validator/index.js");
const _validate_operation_js_1 = require("../../queue-operation-validator/_/_validate-operation.js");
const _get_message_ids_js_1 = require("./_/_get-message-ids.js");
class MessageBrowser {
constructor(messageManager, messageStorage, messageType, redisKey, requireGroupId, logger) {
this.messageManager = messageManager;
this.messageStorage = messageStorage;
this.messageType = messageType;
this.logger = logger;
this.redisKey = redisKey;
this.requireGroupId = requireGroupId;
}
validatePurgeOperation(parsedParams, cb) {
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
(0, _validate_operation_js_1._validateOperation)(client, parsedParams.queueParams, index_js_2.EQueueOperation.PURGE, done);
}, cb);
}
createPurgeJob(parsedParams, cb) {
this.withPurgeQueueJobManager((purgeQueueJobManager, done) => {
const target = {
queue: parsedParams,
messageType: this.messageType,
};
purgeQueueJobManager.create(target, {}, (err, job) => {
if (err) {
this.logger.error(`Could not create purge job for queue ${parsedParams.queueParams.name}`, err);
done(err);
return;
}
done(null, job === null || job === void 0 ? void 0 : job.id);
});
}, cb);
}
isJobForQueue(job, parsedParams) {
return (job.payload.queue.queueParams.name === parsedParams.queueParams.name &&
job.payload.queue.queueParams.ns === parsedParams.queueParams.ns &&
job.payload.queue.groupId === parsedParams.groupId &&
job.payload.messageType === this.messageType);
}
withValidatedQueue(queue, operation, cb) {
const parsedParams = (0, _parse_queue_extended_params_js_1._parseQueueExtendedParams)(queue);
if (parsedParams instanceof Error) {
this.logger.error(`Error parsing queue parameters: ${parsedParams.message}`);
cb(parsedParams);
return;
}
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
(0, _validate_queue_extended_params_js_1._validateQueueExtendedParams)(client, parsedParams, this.requireGroupId, (err) => {
if (err) {
this.logger.error(`Error validating queue parameters: ${err.message}`);
done(err);
return;
}
operation(parsedParams, done);
});
}, cb);
}
withPurgeQueueJobManager(operation, cb) {
(0, with_shared_pool_connection_js_1.withSharedPoolConnection)((client, done) => {
redis_smq_common_1.async.waterfall([
(next) => {
const purgeQueueJobManager = new purge_queue_job_manager_js_1.PurgeQueueJobManager(client, this.logger);
purgeQueueJobManager.initialize((err) => {
if (err) {
next(err);
return;
}
next(null, purgeQueueJobManager);
});
},
operation,
], done);
}, cb);
}
purge(queue, cb) {
this.logger.info(`Purging queue messages for queue ${JSON.stringify(queue)}`);
this.withValidatedQueue(queue, (parsedParams, done) => {
this.validatePurgeOperation(parsedParams, (err) => {
if (err) {
done(err);
return;
}
this.createPurgeJob(parsedParams, done);
});
}, cb);
}
getPurgeJob(queue, jobId, cb) {
this.withValidatedQueue(queue, (parsedParams, done) => {
this.withPurgeQueueJobManager((purgeQueueJobManager, innerDone) => {
purgeQueueJobManager.get(jobId, (err, job) => {
if (err) {
innerDone(err);
return;
}
if (!job) {
innerDone(new redis_smq_common_1.CallbackEmptyReplyError());
return;
}
if (!this.isJobForQueue(job, parsedParams)) {
innerDone(new index_js_1.InvalidPurgeQueueJobIdError({
metadata: { jobId },
}));
return;
}
innerDone(null, job);
});
}, done);
}, cb);
}
getPurgeJobStatus(queue, jobId, cb) {
this.getPurgeJob(queue, jobId, (err, job) => {
if (err) {
cb(err);
return;
}
if (!job) {
cb(new redis_smq_common_1.CallbackEmptyReplyError());
return;
}
cb(null, job.status);
});
}
cancelPurge(queue, jobId, cb) {
this.withValidatedQueue(queue, (parsedParams, done) => {
this.withPurgeQueueJobManager((purgeQueueJobManager, innerDone) => {
purgeQueueJobManager.get(jobId, (err, job) => {
if (err) {
innerDone(err);
return;
}
if (!job || !this.isJobForQueue(job, parsedParams)) {
innerDone(new index_js_1.InvalidPurgeQueueJobIdError({
metadata: { jobId },
}));
return;
}
purgeQueueJobManager.cancel(jobId, (err) => innerDone(err));
});
}, done);
}, cb);
}
getMessages(queue, page, pageSize, cb) {
this.withValidatedQueue(queue, (parsedParams, done) => {
this.logger.debug(`Getting messages for ${parsedParams.queueParams.name}, page ${page}, size ${pageSize}`);
redis_smq_common_1.async.waterfall([
(next) => {
(0, _get_message_ids_js_1._getMessageIds)(parsedParams, page, pageSize, this.redisKey, this.messageStorage, this.logger, next);
},
(pageResult, next) => {
if (pageResult.items.length === 0) {
next(null, Object.assign(Object.assign({}, pageResult), { items: [] }));
return;
}
this.messageManager.getMessagesByIds(pageResult.items, (err, messages) => {
if (err) {
next(err);
return;
}
next(null, Object.assign(Object.assign({}, pageResult), { items: messages !== null && messages !== void 0 ? messages : [] }));
});
},
], done);
}, cb);
}
countMessages(queue, cb) {
this.withValidatedQueue(queue, (parsedParams, done) => {
this.logger.debug(`Counting messages for ${parsedParams.queueParams.name}`);
const keys = redis_keys_js_1.redisKeys.getQueueKeys(parsedParams.queueParams.ns, parsedParams.queueParams.name, parsedParams.groupId);
const keyVal = keys[this.redisKey];
this.messageStorage.count(keyVal, (err, count) => {
if (err) {
this.logger.error(`Error counting messages: ${err.message}`);
done(err);
return;
}
this.logger.debug(`Queue ${parsedParams.queueParams.name} has ${count} messages`);
done(null, count);
});
}, cb);
}
getMessageIds(queue, page, pageSize, cb) {
this.withValidatedQueue(queue, (parsedParams, done) => {
(0, _get_message_ids_js_1._getMessageIds)(parsedParams, page, pageSize, this.redisKey, this.messageStorage, this.logger, done);
}, cb);
}
}
exports.MessageBrowser = MessageBrowser;
//# sourceMappingURL=message-browser.js.map