@azteam/rabbitmq-async 1.0.146 → 1.0.147

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/rabbitmq-async",
-    "version": "1.0.146",
+    "version": "1.0.147",
     "description": "",
     "main": "./lib/index.js",
     "module": "./src/index.js",

package/src/Provider.js

@@ -0,0 +1,34 @@
+import RabbitMQAsync from './RabbitMQAsync';
+
+class Provider {
+    constructor(configs = []) {
+        this.connections = {};
+        this.configs = {};
+        if (Array.isArray(configs)) {
+            configs.map((config) => {
+                this.configs[config.name] = config;
+                return true;
+            });
+        } else {
+            this.configs.main = configs;
+        }
+    }
+
+    getConnection(name = 'main') {
+        if (!this.connections[name]) {
+            this.connections[name] = new RabbitMQAsync(this.configs[name]);
+        }
+        return this.connections[name];
+    }
+
+    async waitAllConnection() {
+        await Promise.all(
+            Object.keys(this.configs).map((keyConfig) => {
+                const connection = this.getConnection(keyConfig);
+                return connection.waitConnection();
+            })
+        );
+    }
+}
+
+export default Provider;

package/src/RabbitMQAsync.js

@@ -0,0 +1,220 @@
+import amqp from 'amqplib';
+import {timeout} from '@azteam/util';
+import _ from 'lodash';
+
+class RabbitMQAsync {
+    constructor(config) {
+        this.connected = false;
+        this.username = config.username;
+        this.password = config.password;
+        this.host = config.host;
+        this.prefix = config.prefix;
+        this.connect();
+    }
+
+    async waitConnection(n = 10) {
+        for (let i = 0; !this.connected || i < n; i += 1) {
+            await timeout(1000);
+        }
+        if (!this.connected) {
+            throw new Error('Rabbit not connected');
+        }
+    }
+
+    async connect() {
+        this._alert('connecting', 'MQ connecting...');
+        const opt = {credentials: amqp.credentials.plain(this.username, this.password)};
+        try {
+            this.client = await amqp.connect(`amqp://${this.host}`, opt);
+            this.connected = true;
+            this._alert('connect', 'MQ connected');
+
+            this.client.on('error', (err) => {
+                this.connected = false;
+                this._alert('error', `MQ Error${err}`);
+                this.reconnect();
+            });
+
+            this.client.on('close', () => {
+                this.connected = false;
+                this._alert('close', 'MQ closed');
+                this.reconnect();
+            });
+        } catch (err) {
+            this.connected = false;
+            this._alert('error', `MQ connect${err}`);
+            await this.reconnect();
+        }
+    }
+
+    async reconnect() {
+        this._alert('reconnect', 'MQ try reconnect...');
+        await timeout(5000);
+        await this.connect();
+    }
+
+    close() {
+        this.connected = false;
+        this.client.close();
+    }
+
+    parsePrefix(name) {
+        if (this.prefix) {
+            return `${this.prefix}:${name}`;
+        }
+        return name;
+    }
+
+    async send(queueName, msg = {}, force = true) {
+        const prefixQueueName = this.parsePrefix(queueName);
+
+        if (this.connected) {
+            let channel;
+            try {
+                channel = await this.client.createChannel();
+                const queueInfo = await channel.assertQueue(prefixQueueName, {
+                    durable: true,
+                });
+
+                if (force || queueInfo.messageCount === 0) {
+                    await channel.sendToQueue(prefixQueueName, Buffer.from(JSON.stringify(msg)), {
+                        persistent: true,
+                    });
+                }
+
+                return true;
+            } catch (err) {
+                await timeout(2000);
+                return this.send(queueName, msg);
+            } finally {
+                try {
+                    await channel.close();
+                } catch (err) {}
+            }
+        } else {
+            await timeout(2000);
+            return this.send(queueName, msg);
+        }
+    }
+
+    async getInfo(queueName) {
+        const prefixQueueName = this.parsePrefix(queueName);
+
+        if (this.connected) {
+            let channel;
+            try {
+                channel = await this.client.createChannel();
+                return await channel.assertQueue(prefixQueueName, {
+                    durable: true,
+                });
+            } catch (err) {
+                return this.getInfo(queueName);
+            } finally {
+                try {
+                    await channel.close();
+                } catch (err) {}
+            }
+        } else {
+            return this.getInfo(queueName);
+        }
+    }
+
+    async receiving(queueName, cb, callbackError = null) {
+        const prefixQueueName = this.parsePrefix(queueName);
+
+        if (this.connected) {
+            let channel;
+            try {
+                channel = await this.client.createChannel();
+
+                await channel.assertQueue(prefixQueueName, {
+                    durable: true,
+                });
+
+                await channel.prefetch(1);
+
+                const messageQueue = this;
+
+                await new Promise((resolve, reject) => {
+                    channel.consume(prefixQueueName, async function (msg) {
+                        if (msg) {
+                            const data = JSON.parse(msg.content.toString());
+
+                            if (data) {
+                                try {
+                                    if (msg.fields.redelivered) {
+                                        if (!data.retry) {
+                                            data.retry = 0;
+                                        }
+                                        data.retry += 1;
+
+                                        if (data.retry < 5) {
+                                            await messageQueue.send(queueName, data);
+                                        } else {
+                                            await messageQueue.send(messageQueue.parsePrefix('RETRY'), {
+                                                queueName,
+                                                data,
+                                                retry_time: new Date(),
+                                            });
+                                        }
+                                        await channel.ack(msg);
+                                    } else {
+                                        try {
+                                            await cb(data);
+                                            await channel.ack(msg);
+                                        } catch (err) {
+                                            const errString = err.toString();
+
+                                            if (_.some(['IllegalOperationError: Channel closed'], (el) => _.includes(errString, el))) {
+                                                reject(new Error(errString));
+                                            } else {
+                                                if (callbackError) {
+                                                    callbackError(prefixQueueName, err);
+                                                }
+                                                if (data.noRetry) {
+                                                    await channel.ack(msg);
+                                                } else {
+                                                    await channel.nack(msg);
+                                                }
+                                            }
+                                        }
+                                    }
+                                } catch (err) {
+                                    reject(err);
+                                }
+                            } else {
+                                channel.ack(msg);
+                            }
+                        } else {
+                            reject(new Error('msg null'));
+                        }
+                    });
+                });
+            } catch (err) {
+                try {
+                    await channel.close();
+                } catch (err2) {}
+
+                await timeout(5000);
+                return this.receiving(queueName, cb, callbackError);
+            }
+        } else {
+            await timeout(5000);
+            return this.receiving(queueName, cb, callbackError);
+        }
+    }
+
+    setAlertCallback(callback) {
+        this.alertCallback = callback;
+    }
+
+    _alert(status, msg) {
+        if (typeof this.alertCallback === 'function') {
+            this.alertCallback(status, msg);
+        } else {
+            console.info(status, msg);
+        }
+    }
+}
+
+export default RabbitMQAsync;

package/src/index.js

@@ -0,0 +1,4 @@
+import Provider from './Provider';
+import RabbitMQAsync from './RabbitMQAsync';
+
+export {RabbitMQAsync, Provider as RabbitMQProvider};