@clonegod/ttd-sui-common 1.0.33 → 1.0.34

package/dist/redis/index.d.ts

@@ -0,0 +1 @@
+export * from "./redis_client";

package/dist/redis/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./redis_client"), exports);

package/dist/redis/redis_client.d.ts

@@ -0,0 +1,21 @@
+import { RedisClientType } from "redis";
+export declare class SimpleRedisClient {
+    private lock_prefix;
+    private redisClient;
+    private lockMaxRetries;
+    private lockRetryDelayMs;
+    private lockExpireSeconds;
+    constructor(lock_prefix: string);
+    getRedisClient(): Promise<RedisClientType>;
+    private getLockKey;
+    private acquireLock;
+    private releaseLock;
+    withLock<T>(lock_identifier: string, callback: () => Promise<T>, release_lock_delay_ms?: number): Promise<T>;
+    getValue(key: string): Promise<string>;
+    setValue(key: string, value: string, expireSeconds: number): Promise<any>;
+    hsetValue(key: string, field: string, value: string, expireSeconds: number): Promise<any>;
+    hgetvalue(key: string, field: string): Promise<any>;
+    hkeys(key: string): Promise<any>;
+    hgetall(key: string): Promise<any>;
+    del(key: string, field?: string): Promise<any>;
+}

package/dist/redis/redis_client.js

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleRedisClient = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+class SimpleRedisClient {
+    constructor(lock_prefix) {
+        this.lock_prefix = lock_prefix;
+        this.redisClient = null;
+        this.lockMaxRetries = 10;
+        this.lockRetryDelayMs = 300;
+        this.lockExpireSeconds = 3;
+    }
+    getRedisClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.redisClient) {
+                this.redisClient = yield (0, dist_1.getRedisCache)();
+            }
+            return this.redisClient;
+        });
+    }
+    getLockKey(lock_identifier) {
+        return `${this.lock_prefix}:lock:${lock_identifier}`;
+    }
+    acquireLock(lock_key_1, lock_value_1) {
+        return __awaiter(this, arguments, void 0, function* (lock_key, lock_value, expireSeconds = this.lockExpireSeconds) {
+            const redisClient = yield this.getRedisClient();
+            const result = yield redisClient.set(lock_key, lock_value, {
+                NX: true,
+                EX: expireSeconds
+            });
+            (0, dist_1.log_info)(`try acquireLock: lock_key=${lock_key}, lock_value=${lock_value}, expireSeconds=${expireSeconds}, result=${result}`);
+            const success = result === 'OK';
+            if (success) {
+                (0, dist_1.log_info)(`acquire lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
+            }
+            return success;
+        });
+    }
+    releaseLock(lock_key, lock_value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            const script = `
+            if redis.call('get', KEYS[1]) == ARGV[1] then
+                return redis.call('del', KEYS[1])
+            else
+                return 0
+            end
+        `;
+            const result = yield redisClient.eval(script, {
+                keys: [lock_key],
+                arguments: [lock_value]
+            });
+            const success = Number(result) === 1;
+            if (success) {
+                (0, dist_1.log_info)(`release lock success: lock_key=${lock_key}, lock_value=${lock_value}`);
+            }
+            else {
+                (0, dist_1.log_info)(`release lock failed: lock_key=${lock_key}, lock_value=${lock_value}, maybe expired or locked by other process`);
+            }
+            return success;
+        });
+    }
+    withLock(lock_identifier_1, callback_1) {
+        return __awaiter(this, arguments, void 0, function* (lock_identifier, callback, release_lock_delay_ms = 2000) {
+            const lock_key = this.getLockKey(lock_identifier);
+            const lock_value = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+            let retries = 0;
+            let acquired = false;
+            let first_try_time = Date.now();
+            let get_lock_time = 0;
+            try {
+                while (retries < this.lockMaxRetries) {
+                    acquired = yield this.acquireLock(lock_key, lock_value);
+                    if (acquired)
+                        break;
+                    yield new Promise(resolve => setTimeout(resolve, this.lockRetryDelayMs));
+                    retries++;
+                }
+                if (acquired) {
+                    get_lock_time = Date.now();
+                    return yield callback();
+                }
+            }
+            finally {
+                if (acquired) {
+                    const release_delay = parseInt(process.env.NONCE_LOCK_RELEASE_DELAY_MS || String(release_lock_delay_ms));
+                    yield (0, dist_1.sleep)(release_delay);
+                    yield this.releaseLock(lock_key, lock_value);
+                    (0, dist_1.log_info)(`withLock success: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, get lock take ${get_lock_time - first_try_time}ms, release_delay=${release_delay}ms, hold lock ${Date.now() - get_lock_time}ms`);
+                }
+                else {
+                    (0, dist_1.log_warn)(`withLock failed: lock_key=${lock_key}, lock_value=${lock_value}, retry times=${retries}, took ${Date.now() - first_try_time}ms`);
+                }
+            }
+        });
+    }
+    getValue(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.get(key);
+        });
+    }
+    setValue(key, value, expireSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.set(key, value, {
+                EX: expireSeconds
+            });
+        });
+    }
+    hsetValue(key, field, value, expireSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            yield redisClient.hSet(key, field, value);
+            yield redisClient.hExpire(key, field, expireSeconds);
+        });
+    }
+    hgetvalue(key, field) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.hGet(key, field);
+        });
+    }
+    hkeys(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.hKeys(key);
+        });
+    }
+    hgetall(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const redisClient = yield this.getRedisClient();
+            return yield redisClient.hGetAll(key);
+        });
+    }
+    del(key_1) {
+        return __awaiter(this, arguments, void 0, function* (key, field = '') {
+            const redisClient = yield this.getRedisClient();
+            if (field) {
+                return yield redisClient.hDel(key, field);
+            }
+            return yield redisClient.del(key);
+        });
+    }
+}
+exports.SimpleRedisClient = SimpleRedisClient;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-sui-common",
-    "version": "1.0.33",
+    "version": "1.0.34",
     "description": "Sui common library",
     "license": "UNLICENSED",
     "main": "dist/index.js",