redis-smq
Version:
A simple high-performance Redis message queue for Node.js.
164 lines • 9.27 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const redis_smq_common_1 = require("redis-smq-common");
const scripts_js_1 = require("../../../common/redis-client/scripts/scripts.js");
const redis_keys_js_1 = require("../../../common/redis-keys/redis-keys.js");
const _from_message_js_1 = require("../../message/_/_from-message.js");
const _get_message_js_1 = require("../../message/_/_get-message.js");
const index_js_1 = require("../../message/index.js");
const index_js_2 = require("../../queue/index.js");
const worker_js_1 = require("./worker.js");
class PublishScheduledWorker extends worker_js_1.Worker {
constructor() {
super(...arguments);
this.work = (cb) => {
this.logger.debug('Starting publish scheduled messages work cycle');
this.logger.debug(`Queue: ${this.queueParsedParams.queueParams.ns}:${this.queueParsedParams.queueParams.name}, GroupId: ${this.queueParsedParams.groupId || 'none'}`);
redis_smq_common_1.async.waterfall([this.fetchMessageIds, this.fetchMessages, this.enqueueMessages], (err) => {
if (err) {
this.logger.error('Error in publish scheduled messages workflow', err);
}
else {
this.logger.debug('Completed publish scheduled messages work cycle');
}
cb(err);
});
};
this.fetchMessageIds = (cb) => {
this.logger.debug('Fetching scheduled message IDs');
const redisClient = this.redisClient.getInstance();
if (redisClient instanceof Error) {
this.logger.error('Failed to get Redis client instance', redisClient);
cb(redisClient);
return void 0;
}
const { keyQueueScheduled } = redis_keys_js_1.redisKeys.getQueueKeys(this.queueParsedParams.queueParams, this.queueParsedParams.groupId);
this.logger.debug(`Using scheduled queue key: ${keyQueueScheduled}`);
const currentTimestamp = Date.now();
redisClient.zrangebyscore(keyQueueScheduled, 0, currentTimestamp, 0, 9, (err, ids) => {
if (err) {
this.logger.error('Error fetching scheduled message IDs', err);
cb(err);
}
else {
const messageCount = (ids === null || ids === void 0 ? void 0 : ids.length) || 0;
this.logger.debug(`Found ${messageCount} scheduled messages ready for publishing (current timestamp: ${currentTimestamp})`);
cb(null, ids || []);
}
});
};
this.fetchMessages = (ids, cb) => {
if (!ids.length) {
this.logger.debug('No message IDs to fetch, skipping message retrieval');
cb(null, []);
return void 0;
}
this.logger.debug(`Fetching ${ids.length} messages from storage`);
const redisClient = this.redisClient.getInstance();
if (redisClient instanceof Error) {
this.logger.error('Failed to get Redis client instance', redisClient);
cb(redisClient);
return void 0;
}
(0, _get_message_js_1._getMessages)(redisClient, ids, (err, messages) => {
if (err) {
this.logger.error('Error fetching messages', err);
cb(err);
}
else {
const messageCount = (messages === null || messages === void 0 ? void 0 : messages.length) || 0;
this.logger.debug(`Successfully retrieved ${messageCount} messages`);
cb(null, messages || []);
}
});
};
this.enqueueMessages = (messages, cb) => {
if (!messages.length) {
this.logger.debug('No messages to enqueue, work cycle complete');
cb();
return void 0;
}
this.logger.debug(`Preparing to enqueue ${messages.length} messages`);
const keys = [];
const argv = [
index_js_1.EMessageProperty.STATUS,
index_js_1.EMessagePropertyStatus.PENDING,
index_js_1.EMessageProperty.STATE,
index_js_2.EQueueProperty.QUEUE_TYPE,
index_js_2.EQueueType.PRIORITY_QUEUE,
index_js_2.EQueueType.LIFO_QUEUE,
index_js_2.EQueueType.FIFO_QUEUE,
index_js_2.EQueueProperty.MESSAGES_COUNT,
index_js_1.EMessageProperty.MESSAGE,
];
redis_smq_common_1.async.eachOf(messages, (msg, index, done) => {
var _a;
const messageId = msg.getId();
this.logger.debug(`Processing message ${messageId} (${index + 1}/${messages.length})`);
const ts = Date.now();
const messagePriority = (_a = msg.producibleMessage.getPriority()) !== null && _a !== void 0 ? _a : '';
const { keyMessage: keyScheduledMessage } = redis_keys_js_1.redisKeys.getMessageKeys(messageId);
const nextScheduleTimestamp = msg.getNextScheduledTimestamp();
const scheduledMessageState = msg.getMessageState();
const destinationQueue = msg.getDestinationQueue();
const consumerGroupId = msg.getConsumerGroupId();
this.logger.debug(`Message ${messageId} destination: ${destinationQueue.ns}:${destinationQueue.name}, consumer group: ${consumerGroupId || 'none'}`);
const { keyQueueProperties, keyQueuePending, keyQueuePriorityPending, keyQueueScheduled, keyQueueMessages, } = redis_keys_js_1.redisKeys.getQueueKeys(destinationQueue, consumerGroupId);
let newMessage = null;
let newMessageState = null;
let newMessageId = '';
let newKeyMessage = '';
if (nextScheduleTimestamp) {
this.logger.debug(`Message ${messageId} has next schedule timestamp: ${nextScheduleTimestamp}, creating new message instance`);
newMessage = (0, _from_message_js_1._fromMessage)(msg, null, null);
newMessage.producibleMessage.resetScheduledParams();
newMessageState = newMessage
.getMessageState()
.setPublishedAt(ts)
.setScheduledMessageId(messageId);
newMessageId = newMessageState.getId();
newKeyMessage = redis_keys_js_1.redisKeys.getMessageKeys(newMessageId).keyMessage;
scheduledMessageState.setLastScheduledAt(ts);
this.logger.debug(`Created new message with ID ${newMessageId} from scheduled message ${messageId}`);
}
else {
this.logger.debug(`Message ${messageId} has no next schedule timestamp, updating existing message`);
scheduledMessageState.setPublishedAt(ts);
}
keys.push(newKeyMessage, keyQueuePending, keyQueueMessages, keyQueueProperties, keyQueuePriorityPending, keyQueueScheduled, keyScheduledMessage);
argv.push(newMessageId, newMessage ? JSON.stringify(newMessage) : '', newMessageState ? JSON.stringify(newMessageState) : '', messagePriority, messageId, nextScheduleTimestamp, JSON.stringify(scheduledMessageState));
done();
}, (err) => {
if (err) {
this.logger.error('Error during message processing for enqueue', err);
cb(err);
}
else {
this.logger.debug(`Executing PUBLISH_SCHEDULED_MESSAGE script for ${messages.length} messages`);
const redisClient = this.redisClient.getInstance();
if (redisClient instanceof Error) {
this.logger.error('Failed to get Redis client instance', redisClient);
cb(redisClient);
return void 0;
}
redisClient.runScript(scripts_js_1.ELuaScriptName.PUBLISH_SCHEDULED_MESSAGE, keys, argv, (err, reply) => {
if (err) {
this.logger.error('Error executing publish scheduled message script', err);
cb(err);
}
else if (reply !== 'OK') {
this.logger.error(`Script execution returned unexpected response: ${reply}`);
cb(new redis_smq_common_1.PanicError(String(reply)));
}
else {
this.logger.info(`Successfully published ${messages.length} scheduled messages`);
cb();
}
});
}
});
};
}
}
exports.default = (payload) => new PublishScheduledWorker(payload);
//# sourceMappingURL=publish-scheduled.worker.js.map