@azteam/redis-async 1.0.66 → 1.0.68

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@azteam/redis-async",
-    "version": "1.0.66",
+    "version": "1.0.68",
     "description": "",
     "main": "./lib/index.js",
     "module": "./src/index.js",
@@ -16,7 +16,7 @@
     "author": "toda <sp.azsolution.net@gmail.com>",
     "license": "MIT",
     "dependencies": {
-        "@azteam/util": "1.0.16",
+        "@azteam/util": "1.0.17",
         "redis": "4.0.6"
     }
 }

package/src/Provider.js

@@ -0,0 +1,34 @@
+import RedisAsync from './RedisAsync';
+
+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 RedisAsync(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/RedisAsync.js

@@ -0,0 +1,151 @@
+import {createClient} from 'redis';
+import {timeout} from '@azteam/util';
+
+class RedisAsync {
+    constructor(config) {
+        this.connected = false;
+        this.host = config.host;
+        this.port = config.port;
+        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('Redis not connected');
+        }
+    }
+
+    parsePrefix(name) {
+        if (this.prefix) {
+            return `${this.prefix}:${name}`;
+        }
+        return name;
+    }
+
+    connect() {
+        this._alert('connecting', 'Redis connecting...');
+
+        this.client = createClient({
+            host: this.host,
+            port: this.port,
+
+            retry_strategy: (options) => {
+                this.connected = false;
+                this._alert('connect', 'Redis disconnected');
+                this.client.quit();
+            },
+        });
+
+        this.client.connect();
+
+        this.client.on('connect', () => {
+            this.connected = true;
+            this._alert('connect', 'Redis connected');
+        });
+
+        this.client.on('end', () => {
+            this._alert('end', 'Redis end');
+        });
+
+        this.client.on('error', (err) => {
+            this._alert('error', `Redis Error${err}`);
+        });
+    }
+
+    async get(key, defaultValue = null) {
+        const prefixKey = this.parsePrefix(key);
+
+        if (this.connected) {
+            console.log(`Redis GET ${prefixKey}`);
+
+            const data = await this.client.get(prefixKey);
+            if (data) {
+                return JSON.parse(data);
+            }
+        } else {
+            this.connect();
+            return null;
+        }
+
+        return defaultValue;
+    }
+
+    async ttl(key) {
+        const prefixKey = this.parsePrefix(key);
+        return this.client.ttl(prefixKey);
+    }
+
+    async expire(key, timeSecond = 86400) {
+        const prefixKey = this.parsePrefix(key);
+        this.client.expire(prefixKey, timeSecond);
+    }
+
+    async set(key, data, timeSecond = 86400, count = 0) {
+        const prefixKey = this.parsePrefix(key);
+
+        if (this.connected) {
+            console.log(`Redis SET ${prefixKey}`);
+            await this.client.set(prefixKey, JSON.stringify(data));
+            await this.expire(prefixKey, timeSecond);
+            return true;
+        } else {
+            this.connect();
+
+            if (count < 5) {
+                return this.set(key, data, timeSecond, count + 1);
+            }
+            return false;
+        }
+    }
+
+    // async scan(pattern, cursor = 0, count = 1000) {
+    //     const scanAsync = promisify(this.client.scan).bind(this.client);
+    //     return await scanAsync(cursor, 'MATCH', pattern, 'COUNT', count);
+    // }
+
+    async remove(key, exact = true, count = 0) {
+        const prefixKey = this.parsePrefix(key);
+
+        if (this.connected) {
+            if (exact) {
+                console.log(`Redis REMOVE ${prefixKey}`);
+
+                await this.client.del(prefixKey);
+            } else {
+                const regexKey = `*${prefixKey}*`;
+
+                const keys = await this.client.keys(regexKey);
+
+                if (keys.length > 0) {
+                    console.log(`Redis REMOVE keys`, keys);
+                    return this.client.del(keys);
+                }
+            }
+        } else {
+            this.connect();
+            if (count < 5) {
+                return this.remove(key, exact, count + 1);
+            }
+            return false;
+        }
+        return false;
+    }
+
+    setAlertCallback(callback) {
+        this.alertCallback = callback;
+    }
+
+    _alert(status, msg) {
+        if (typeof this.alertCallback === 'function') {
+            this.alertCallback(status, msg);
+        } else {
+            console.error(status, msg);
+        }
+    }
+}
+
+export default RedisAsync;

package/src/index.js

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