@platform-x/hep-message-broker-client 1.1.14 → 1.1.16

package/src/messageBroker/MessageConsumer.ts

@@ -0,0 +1,85 @@
+import { Logger } from "../Util/logger";
+import { PublishMessageInputType } from "./types/PublishMessageInputType";
+import RetryManager from './RetryManager';
+import MessageProducer from "./MessageProducer";
+import BaseRabbitMQClient from "./BaseRabbitMQClient";
+
+
+let configData: any = {};
+let max_retries: number = 0; // Maximum retries for connection and queue
+let retry_delay: string = ""; // Back-off time for message retry
+
+class MessageConsumer extends  BaseRabbitMQClient{
+    private readonly messageProducer: MessageProducer;
+    constructor() {
+        super();
+        this.messageProducer = new MessageProducer()
+    }
+    /**
+   * Funvction for initialize consumer queue
+   * @param consumerQueues
+   */
+    public async initializeConsumers() {
+        try {
+            Logger.info('Reached in initialize consumer', `initializeConsumers`);
+            let consume_queues = configData?.consume_queues;
+            // Consume messages from all queues
+            for (const queue in configData?.consume_queues) {
+                if (Object.prototype.hasOwnProperty.call(consume_queues, queue)) {
+                    // Call function Consume messages with retry
+                    await this.consumerMessage(queue);
+                }
+            }
+        } catch (error: unknown) {
+            Logger.error('Error initializing consumers:', 'initializeConsumers', (error as Error).message);
+            return { error: (error as Error).message };
+        }
+    }
+
+
+
+    /**
+     * Function to consume message with retry
+     * @param queueName
+     */
+    private async consumerMessage(queueName: string) {
+        Logger.info("Reached: Consuming messages from the main queue", 'consumerMessage')
+        await this.channel?.consume(queueName, async (message: any) => {
+            if (message) {
+                let msgData: any = message.content.toString();
+                const success: boolean = await this.consumerHandler({ queueName, message: msgData });
+                try {
+                    if (!success) {
+                        const boundPublishMessage = this.messageProducer.publishMessage.bind(this);
+                        const boundConsumerHandler = this.consumerHandler.bind(this);
+                        retry_delay = configData?.retry_delay;
+                        const reqData: PublishMessageInputType = { queueName, message };
+                        // Instantiate RetryManager
+                        const retryManager = RetryManager.getInstance<PublishMessageInputType>(max_retries, retry_delay);
+                        retryManager.performActionWithRetry(boundPublishMessage, reqData, boundConsumerHandler)
+                    } else {
+                        Logger.info(`Acknowledge the successful processing`, 'consumerMessage');
+                        this.channel?.ack(message); // Acknowledge the successful processing
+                    }
+                } catch (error) {
+                    Logger.error(`Error processing message`, 'consumerMessage', { message: (error as Error).message });
+                    this.channel?.nack(message, false, false); // Move message to DLQ after failure
+                }
+            }
+        });
+    };
+
+    /**
+     * Function for consumer massage handler
+     * @param channel
+     * @param queue
+     * @param message
+     * @returns 
+     */
+    private async consumerHandler(request: PublishMessageInputType): Promise<boolean> {
+        Logger.info(`${JSON.stringify(request)}`, 'consumerHandler');
+        return true;
+    }
+}
+
+export default MessageConsumer;

package/src/messageBroker/MessageProducer.ts

@@ -0,0 +1,142 @@
+import MessageModel from "../models/MessageModel";
+import { generateCorrelationId } from "../Util/commonUtil";
+import { Logger } from "../Util/logger";
+import BaseRabbitMQClient from "./BaseRabbitMQClient";
+import ConnectionManager from "./ConnectionManager";
+import { PublishMessageInputType } from "./types/PublishMessageInputType";
+
+class MessageProducer extends BaseRabbitMQClient{
+    private readonly correlationId:string;
+    public connectionManager:ConnectionManager;
+    constructor() {
+        super();
+        this.correlationId= generateCorrelationId();
+        this.connectionManager = new ConnectionManager();
+    }
+
+
+    
+    /**
+      * Function to publish a message with retry
+      * @param queueName 
+      * @param message 
+      * @returns 
+    */
+    public async publishMessage(request: PublishMessageInputType): Promise<boolean> {
+        const queueName: string = request.queueName;
+        const data: MessageModel = request.message;
+        console.log(data.message, queueName, 'message')
+        Logger.info('Reached:publishMessage', 'publishMessage');
+        const messageBuffer = Buffer.from(JSON.stringify(data?.message));
+        this.channel = this.connectionManager.getChannel();
+        try {
+            const isSent = await new Promise<boolean>((resolve, reject) => {
+                this.connection?.on('close', (err: any) => {
+                    Logger.error(`RabbitMQ: bindConnectionEventHandler:close`, `Connection closed`, err);
+        
+                });
+               let sent = this.channel?.sendToQueue('update_metadata_queue', Buffer.from(JSON.stringify('Hello world test')), {
+                    persistent: true, // Ensures the message is persisted
+                    // correlationId: data?.message?.correlationId,
+                });
+                console.log("publish message successfully")
+                // console.log(sent, 'send')
+                if (sent) {
+                    Logger.debug(`Message sent successfully`, 'publishMessage', { data, queueName });
+                    resolve(true);
+                } else {
+                    Logger.error(`Failed to publish message.`, 'publishMessage', { message: messageBuffer.toString() });
+                    reject(false);
+                }
+            });
+            console.log(isSent)
+            return true;;
+        } catch (error) {
+            console.log(error)
+            Logger.error(`Error sending message: ${error}`, 'sendMessage', error);
+            return false;
+        }
+    }
+
+    /**
+      * Function to publish a message with retry
+      * @param exchangeName 
+      * @param routingKey
+      * @param message 
+      * @param options
+      * @returns 
+    */
+    public async publishMessageToExchange(
+       request: PublishMessageInputType
+    ): Promise<boolean> {
+        const exchangeName:string | undefined = request?.exchangeName ?? '';
+        const queueName:string = request.queueName;
+        const data:MessageModel = request?.message
+        // const options:object | null = request?.options; // Optional parameter for retry count if you wnats to override the default retry count
+        // const messageObj = {
+        //     message,
+        //     correlationId:this.correlationId,
+        // }
+        Logger.info('Reached:publishMessageToExchange', 'publishMessageToExchange');
+        // Publish the message
+        const messageBuffer = Buffer.from(JSON.stringify(data.message));
+        try {
+            const isSent = await new Promise<boolean>((resolve, reject) => {
+                // this.channel?.on
+                const sent = this.channel?.publish(exchangeName, queueName, messageBuffer,{
+                    persistent: true, // Ensures the message is persisted
+                    correlationId: this.correlationId,
+                });
+                if (sent) {
+                    Logger.debug(`Message sent successfully`, 'publishMessageToExchange', { data, queueName });
+                    resolve(true);
+                } else {
+                    Logger.error(`Failed to publish message to exchange.`, 'publishMessageToExchange', { message: messageBuffer.toString() });
+                    reject(false);
+                }
+            });
+            return isSent;
+        } catch (error) {
+            Logger.error(`Error sending message: ${error}`, 'sendMessage');
+            return false;
+        }
+    };
+
+    /**
+     * Funciton to message handler
+     */
+
+    public async messageHandler(request:PublishMessageInputType):Promise<boolean>{
+        Logger.info(`${JSON.stringify(request)}`, 'messageHandler');
+        return true;
+    }
+
+     /**
+      * Function to connect create to RabbitMQ
+      */
+    //  public async createConnection(): Promise<ConnectionWrapper> {
+    //     try {
+    //         Logger.info('Reached to createConnection', 'createConnection');
+    //         this.configManager.loadConfig(config?.RABBITMQ?.CONFIG_PATH);
+    //         let url: string = `amqp://${this.configData?.username}:${this.configData?.password}@${this.configData?.host}`;
+    //         // Create a connection to RabbitMQ server
+    //         this.connection = await amqp.connect(url, { heartbeat: this.configData?.heartbeat });
+    //         isConnectionOpen = true; 
+    //         // check the connection status
+    //         this.bindConnectionEventHandler();
+    //         // create channel
+    //         this.channel = await this.connection.createConfirmChannel();
+    //         Logger.info('RabbitMQ connected successfully! ', 'createConnection');
+    //         // create exchange and queue and bind with exchange
+    //         await this.setupQueuesAndExchanges();
+    //         const connectionWrapper: ConnectionWrapper = { connection: this.connection, channel: this.channel }
+    //         return connectionWrapper;
+    //     } catch (error) {
+    //         // Log and rethrow any errors that occur during connection
+    //         Logger.error('Failed to connect to RabbitMQ', 'connection', (error as Error)?.message);
+    //         return { connection: null, channel: null } as unknown as ConnectionWrapper;
+    //     }
+    // }
+}
+
+export default MessageProducer;

package/src/messageBroker/RabbitMQClient.ts

@@ -0,0 +1,47 @@
+// Import the amqplib library for RabbitMQ
+import { Logger } from '../Util/logger';
+import BaseRabbitMQClient from './BaseRabbitMQClient';
+import ConnectionManager from './ConnectionManager';
+
+
+export class RabbitMQClient extends BaseRabbitMQClient {
+    constructor() {
+       super();
+    }
+
+    /**
+     * Function to initialize the RabbitMQ connection
+     */
+    public async initialize() {
+        try {
+            Logger.info('Reached to initialize', 'initialize');
+            // Create a connection to RabbitMQ server
+            const connectionManager = await ConnectionManager.getInstance();
+            await connectionManager.createConnection();
+            Logger.info('RabbitMQ connection created', 'initialize');
+        } catch (error) {
+            // Log and rethrow any errors that occur during initialization
+            Logger.error('Failed to create RabbitMQ connection', 'initialize', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Function to close the connection and channel
+     */
+    public async disconnect() {
+        try {
+            Logger.info('Reached to disconnect', 'disconnect');
+            // Close the channel
+            await this.channel?.close();
+            // Close the connection
+            await this.connection?.close();
+            Logger.info('RabbitMQ connection closed', 'disconnect');
+        } catch (error) {
+            // Log and rethrow any errors that occur during closing
+            Logger.error('Failed to close RabbitMQ connection', 'disconnect', error);
+            throw error;
+        }
+    };
+
+}

package/src/messageBroker/RetryManager.ts

@@ -0,0 +1,64 @@
+import { Logger } from '../Util/logger';
+type ActionType<T> = (input: T) => void;
+
+class RetryManager<T>{
+    private static instance: RetryManager<any>;
+    private readonly max_retry:number;
+    private readonly retry_delay:string[]|string;
+    
+    constructor(max_retry:number, retry_delay:string){
+        this.max_retry =  max_retry;
+        this.retry_delay = retry_delay?.split("|");
+    }
+
+    /**
+     * Function for create singlton class instance and return instance
+     * @param max_retry 
+     * @param retry_delay 
+     * @returns 
+     */
+    public static getInstance<T>(max_retry: number, retry_delay: string): RetryManager<T> {
+        if (!RetryManager.instance) {
+            RetryManager.instance = new RetryManager<T>(max_retry, retry_delay);
+        }
+        return RetryManager.instance as RetryManager<T>;
+    }
+    /**
+     * Function for perform action with retry
+     * @param actionHandler 
+     * @param context 
+     * @param failActionHandler 
+     * @returns 
+     */
+    public async performActionWithRetry(actionHandler:ActionType<T>, context:T, failActionHandler:ActionType<T>):Promise<boolean>{
+        Logger.info("Reached: in perform action with retry", "performActionWithRetry")
+        let attempt: number = 0;
+        while (attempt < this.max_retry) {
+            try {
+                actionHandler(context);
+                return true;
+            } catch (error) {
+                attempt++;
+                Logger.error(`Failed to publish message. Attempt ${attempt} of ${this.max_retry}. Error:`, 'performActionWithRetry', { message: (error as Error).message });
+                if (attempt >= this.max_retry) {
+                    Logger.error('Max retries reached. Failed to publish message.', 'performActionWithRetry');
+                    // Optionally: Log or persist the failed message to a DB, file, or other storage for manual intervention
+                    failActionHandler(context);
+                    return false;
+                }
+                // Wait before retrying (Exponential Backoff)
+                let retryDelay: number;
+                if(this.retry_delay.length-1 === attempt){
+                    retryDelay = Number(this.retry_delay[attempt - 1]);
+                }else{
+                    retryDelay = Number(this.retry_delay[this.retry_delay.length-1]);
+                }
+                Logger.info(`Retrying in ${retryDelay / 1000} seconds...`, 'performActionWithRetry');
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            }
+        }
+        return false;
+    }
+    
+}
+export default RetryManager;

package/src/messageBroker/interface/ConnectionWrapper.ts

@@ -0,0 +1,7 @@
+import * as amqp from 'amqplib';
+
+interface ConnectionWrapper {
+    connection: amqp.Connection,
+    channel: amqp.Channel
+}
+export default ConnectionWrapper;

package/src/messageBroker/interface/IMessageBrokerClient.ts

@@ -0,0 +1,11 @@
+import { PublishMessageInputType } from "../types/PublishMessageInputType";
+
+export interface IMessageBrokerClient {
+    initialize(configData: object | null): void;
+    disconnect(): void;
+    // will create a class for publishOptions instead of object
+    publishMessage(request:PublishMessageInputType): Promise<boolean>;
+    // will create a class for publishOptions instead of object
+    publishMessageToExchange(request: PublishMessageInputType):Promise<boolean>;
+    // publish confirm in publishMessage need to implement
+}