@less-is-more/less-js 1.4.42 → 1.5.0-2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@less-is-more/less-js",
-  "version": "1.4.42",
+  "version": "1.5.0-2",
   "description": "Fast develop kit for nodejs",
   "main": "src/index.js",
   "scripts": {

package/src/cache.js

@@ -1,6 +1,7 @@
 const Redis = require("./redis");
 const Param = require("./param");
 const zlib = require("zlib");
+const Nas = require("./nas");
 
 module.exports = class Cache {
   /**
@@ -39,9 +40,10 @@ module.exports = class Cache {
    * @param {*} args 直接传arguments，用于拼接缓存key
    * @param {function} fn 没有缓存的实现
    * @param {boolean} zip 是否压缩
+   * @param {boolean} nas 是否使用Nas缓存
    * @returns 优先返回对象
    */
-  static async auto(keyPrefix, timeSecond, args, fn, zip = false) {
+  static async auto(keyPrefix, timeSecond, args, fn, zip = false, nas = false) {
     let fullKey = keyPrefix;
     for (let i = 0; i < args.length; i++) {
       fullKey += ":" + args[i].toString();
@@ -50,7 +52,11 @@ module.exports = class Cache {
     let savedData = Cache._getLocal(fullKey);
     let hasLocal = false;
     if (Param.isBlank(savedData)) {
-      savedData = await Redis.exec("get", fullKey);
+      if (nas) {
+        savedData = Nas.get(fullKey);
+      } else {
+        savedData = await Redis.exec("get", fullKey);
+      }
       if (!Param.isBlank(savedData)) {
         // 本地缓存1分钟
         Cache._setLocal(fullKey, savedData, 60000);
@@ -76,7 +82,12 @@ module.exports = class Cache {
           if (Cache._needZip(redisContent, zip)) {
             redisContent = Cache._zip(redisContent);
           }
-          await Redis.exec("setex", fullKey, timeSecond + "", redisContent);
+          if (nas) {
+            Nas.set(fullKey, result, timeSecond);
+          } else {
+            await Redis.exec("setex", fullKey, timeSecond + "", redisContent);
+          }
+
           // 本地缓存1分钟
           Cache._setLocal(fullKey, redisContent, 60000);
         }

package/src/index.js

@@ -9,6 +9,7 @@ var Service = require("./service.js");
 var Oss = require("./oss.js");
 var GroupMessage = require("./group-message.js");
 var JsonKit = require("./json-kit.js");
+var Nas = require("./nas.js");
 module.exports = {
   Ret,
   Router,
@@ -21,4 +22,5 @@ module.exports = {
   Oss,
   GroupMessage,
   JsonKit,
+  Nas,
 };

package/src/nas.js

@@ -0,0 +1,251 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+/**
+ * 本地硬盘缓存实现类
+ * 提供类似Redis的缓存功能，支持超时时间
+ * 适用于多服务器共享NAS存储
+ */
+class Nas {
+  static _getCacheDir() {
+    let cacheDir = null;
+
+    // 如果提供了缓存目录参数，则使用该目录，否则使用默认目录
+    const defaultCacheDir = path.join(os.tmpdir(), "cache");
+    cacheDir =
+      cacheDir || (fs.existsSync("/cache") ? "/cache" : defaultCacheDir);
+
+    // 确保缓存目录存在
+    try {
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+    } catch (e) {
+      console.error("创建缓存目录失败:", cacheDir, e);
+    }
+    return cacheDir;
+  }
+
+  /**
+   * 获取缓存值
+   * @param {string} key - 缓存键
+   * @returns {any} 缓存值，如果过期或不存在则返回null
+   */
+  static get(key) {
+    return Nas._loadFromDisk(key);
+  }
+
+  /**
+   * 获取缓存值，如果不存在则返回默认值
+   * @param {string} key - 缓存键
+   * @param {any} defaultValue - 默认值
+   * @returns {any} 缓存值或默认值
+   */
+  static getOrDefault(key, defaultValue) {
+    const value = Nas.get(key);
+    return value !== null ? value : defaultValue;
+  }
+
+  /**
+   * 设置缓存值
+   * @param {string} key - 缓存键
+   * @param {any} value - 缓存值
+   * @param {number} timeout - 超时时间（秒），-1表示永不过期
+   */
+  static set(key, value, timeout = -1) {
+    const expireTime = timeout === -1 ? -1 : Date.now() + timeout * 1000;
+    Nas._saveToDisk(key, value, expireTime);
+  }
+
+  /**
+   * 检查缓存是否存在且未过期
+   * @param {string} key - 缓存键
+   * @returns {boolean} 是否存在且未过期
+   */
+  static exists(key) {
+    return Nas.get(key) !== null;
+  }
+
+  /**
+   * 删除指定的缓存项
+   * @param {string} key - 缓存键
+   */
+  static del(key) {
+    Nas._deleteCacheFile(key);
+  }
+
+  /**
+   * 从硬盘加载缓存值
+   * @param {string} key - 缓存键
+   * @returns {any} 缓存值，如果过期或不存在则返回null
+   */
+  static _loadFromDisk(key) {
+    const filePath = Nas._getFilePath(key);
+
+    try {
+      if (!fs.existsSync(filePath)) {
+        return null;
+      }
+
+      // 读取缓存文件
+      const content = fs.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+
+      if (lines.length >= 2) {
+        const expireTimeString = lines[0];
+        const value = lines.slice(1).join("\n"); // 处理值中可能包含换行符的情况
+
+        const expireTime = parseInt(expireTimeString);
+
+        if (!isNaN(expireTime)) {
+          if (expireTime === -1 || Date.now() < expireTime) {
+            // 文件未过期，返回值
+            return Buffer.from(value, "base64").toString("utf8");
+          } else {
+            // 文件已过期，删除文件
+            Nas._deleteCacheFile(key);
+            return null;
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("读取缓存文件失败:", filePath, e);
+    }
+
+    return null;
+  }
+
+  /**
+   * 保存缓存值到硬盘
+   * @param {string} key - 缓存键
+   * @param {any} value - 缓存值
+   * @param {number} expireTime - 过期时间戳，-1表示永不过期
+   */
+  static _saveToDisk(key, value, expireTime) {
+    // 将值转换为字符串，如果是对象则转换为JSON字符串
+    const content = Buffer.from(value, "utf8").toString("base64");
+    const filePath = Nas._getFilePath(key);
+
+    try {
+      // 写入过期时间戳和值，用换行符分隔
+      const fileContent = `${expireTime}\n${content}`;
+      fs.writeFileSync(filePath, fileContent, "utf8");
+    } catch (e) {
+      console.error("保存缓存文件失败:", filePath, e);
+    }
+  }
+
+  /**
+   * 删除缓存文件
+   * @param {string} key - 缓存键
+   */
+  static _deleteCacheFile(key) {
+    const filePath = Nas._getFilePath(key);
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch (e) {
+      console.warn("删除缓存文件失败:", filePath, e);
+    }
+  }
+
+  /**
+   * 获取缓存文件路径
+   * @param {string} key - 缓存键
+   * @returns {string} 文件路径
+   */
+  static _getFilePath(key) {
+    // 为键生成安全的文件名
+    const safeKey = key.replace(/[^a-zA-Z0-9-_.]/g, "_");
+    return path.join(Nas._getCacheDir(), `${safeKey}.cache`);
+  }
+
+  /**
+   * 清空所有缓存
+   */
+  static flushAll() {
+    try {
+      const cacheDir = Nas._getCacheDir();
+      if (fs.existsSync(cacheDir) && fs.statSync(cacheDir).isDirectory()) {
+        const files = fs.readdirSync(cacheDir);
+        for (const file of files) {
+          if (file.endsWith(".cache")) {
+            const filePath = path.join(cacheDir, file);
+            fs.unlinkSync(filePath);
+          }
+        }
+      }
+    } catch (e) {
+      console.error("清空缓存失败", e);
+    }
+  }
+
+  /**
+   * 设置指定键的过期时间
+   * @param {string} key - 缓存键
+   * @param {number} second - 过期时间（秒）
+   */
+  static expire(key, second) {
+    const currentValue = Nas.get(key);
+    if (currentValue !== null) {
+      const expireTime = Date.now() + second * 1000;
+      Nas._saveToDisk(key, currentValue, expireTime);
+    }
+  }
+
+  /**
+   * 设置指定键的过期时间戳
+   * @param {string} key - 缓存键
+   * @param {number} expireTime - 过期时间戳（毫秒）
+   */
+  static expireAt(key, expireTime) {
+    const currentValue = Nas.get(key);
+    if (currentValue !== null) {
+      Nas._saveToDisk(key, currentValue, expireTime);
+    }
+  }
+
+  /**
+   * 获取指定键的剩余生存时间
+   * @param {string} key - 缓存键
+   * @returns {number} 剩余生存时间（秒），如果不存在或已过期则返回-1
+   */
+  static ttl(key) {
+    const filePath = Nas._getFilePath(key);
+
+    try {
+      if (!fs.existsSync(filePath)) {
+        return -1;
+      }
+
+      // 读取缓存文件
+      const content = fs.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+
+      if (lines.length >= 1) {
+        const expireTimeString = lines[0];
+        const expireTime = parseInt(expireTimeString);
+
+        if (!isNaN(expireTime)) {
+          if (Date.now() < expireTime) {
+            // 文件未过期，计算剩余时间
+            const remainingTime = Math.floor((expireTime - Date.now()) / 1000);
+            return Math.max(0, remainingTime); // 确保返回非负值
+          } else {
+            // 文件已过期，删除文件
+            Nas._deleteCacheFile(key);
+            return -1;
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("读取缓存文件失败:", filePath, e);
+    }
+
+    return -1;
+  }
+}
+
+module.exports = Nas;

package/test/test-nas.js

@@ -0,0 +1,99 @@
+const Nas = require("../src/nas");
+const assert = require("assert");
+
+describe("Nas Class Tests", function () {
+  it("should set and get a string value", function () {
+    Nas.set("testKey", "testValue");
+    const value = Nas.get("testKey");
+    assert.equal(value, "testValue");
+  });
+
+  it("should handle expiration correctly", function (done) {
+    Nas.set("expiringKey", "expiringValue", 1); // 1秒后过期
+
+    setTimeout(() => {
+      const expiredValue = Nas.get("expiringKey");
+      assert.equal(expiredValue, null);
+      done();
+    }, 1100);
+  });
+
+  it("should return null for expired keys", function () {
+    Nas.set("shortLivedKey", "value", 0.5); // 0.5秒后过期
+    setTimeout(() => {
+      const value = Nas.get("shortLivedKey");
+      assert.equal(value, null);
+    }, 1000);
+  });
+
+  it("should check if key exists", function () {
+    Nas.set("existKey", "value");
+    assert(Nas.exists("existKey"));
+    assert(Nas.exists("nonExistKey") == false);
+  });
+
+  it("should delete a key", function () {
+    Nas.set("deleteKey", "value");
+    assert(Nas.exists("deleteKey"));
+    Nas.del("deleteKey");
+    assert(Nas.exists("deleteKey") == false);
+  });
+
+  it("should return default value when key does not exist", function () {
+    const defaultValue = Nas.getOrDefault("nonExistingKey", "default");
+    assert.equal(defaultValue, "default");
+  });
+
+  it("should return actual value when key exists with getOrDefault", function () {
+    Nas.set("existingKey", "actualValue");
+    const value = Nas.getOrDefault("existingKey", "defaultValue");
+    assert.equal(value, "actualValue");
+  });
+
+  it("should handle expiration with expire method", function (done) {
+    Nas.set("expireTest", "value", 10); // 设置10秒后过期
+    const initialTtl = Nas.ttl("expireTest");
+    assert(initialTtl > 5); // 初始TTL应该大于5秒
+
+    Nas.expire("expireTest", 1); // 重新设置为1秒后过期
+    const updatedTtl = Nas.ttl("expireTest");
+    assert(updatedTtl <= 1); // TTL应该小于等于1秒
+
+    setTimeout(() => {
+      const expiredTtl = Nas.ttl("expireTest");
+      assert.equal(expiredTtl, -1); // 已过期，返回-1
+      done();
+    }, 1100);
+  });
+
+  it("should handle expiration with expireAt method", function (done) {
+    Nas.set("expireAtTest", "value");
+    const futureTime = Date.now() + 1000; // 1秒后
+    Nas.expireAt("expireAtTest", futureTime);
+
+    setTimeout(() => {
+      const expiredAtValue = Nas.get("expireAtTest");
+      assert(expiredAtValue == null); // 已过期，应该返回null
+      done();
+    }, 1100);
+  });
+
+  it("should flush all cache entries", function () {
+    Nas.set("flushTest1", "value1");
+    Nas.set("flushTest2", "value2");
+
+    assert.isTrue(Nas.exists("flushTest1"));
+    assert.isTrue(Nas.exists("flushTest2"));
+
+    Nas.flushAll();
+
+    assert.isFalse(Nas.exists("flushTest1"));
+    assert.isFalse(Nas.exists("flushTest2"));
+  });
+
+  it("should handle non-expiring keys (timeout = -1)", function () {
+    Nas.set("permanentKey", "permanentValue", -1);
+    const value = Nas.get("permanentKey");
+    assert.equal(value, "permanentValue");
+  });
+});