mm_redis 2.1.7 → 2.3.0

package/lib/tools/index.js

@@ -0,0 +1,16 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+/** 模块能力层：懒加载工具实现，避免模块入口被 require 时加载全部实现 */
+module.exports = new Proxy({}, {
+  get(_t, key) {
+    if (typeof key !== 'string') return undefined;
+    if (!fs.existsSync(path.join(__dirname, key, 'index.js'))) return undefined;
+    return require('./' + key);
+  },
+  has(_t, key) {
+    return typeof key === 'string' && fs.existsSync(path.join(__dirname, key, 'index.js'));
+  },
+  ownKeys() { return fs.readdirSync(__dirname, { withFileTypes: true }).filter(e => e.isDirectory()).map(e => e.name); },
+  getOwnPropertyDescriptor(_t, key) { return this.has(_t, key) ? { enumerable: true, configurable: true } : undefined; }
+});

package/lib/tools/push_queue/index.js

@@ -0,0 +1,115 @@
+/**
+ * 队列发信器
+ * 发送消息到消息队列（redis v4 官方包，与 mm_redis 共用底层库）
+ */
+
+/**
+ * 获取 Redis 客户端（复用 mm_redis 连接池，不可用时自建独立连接）
+ * @param {object} opts 配置选项
+ * @returns {object} { client, release } 或 null
+ */
+async function _getClient(opts) {
+  var opts2 = { ...opts };
+  // 统一 db/database 字段，mm_redis 读取的是 database 字段
+  if (opts2.db !== undefined && opts2.database === undefined) {
+    opts2.database = opts2.db;
+  }
+
+  var redis_admin = null;
+  try {
+    var { redisAdmin } = require('mm_redis');
+    if (redisAdmin) {
+      // 与 queue 管理器共用 queue 作用域，保证发布/消费配置一致
+      redis_admin = redisAdmin('queue', opts2);
+    }
+  } catch (e) {
+    // mm_redis 不可用时使用传入的 opts
+  }
+
+  // 优先复用 mm_redis 连接池，保证配置一致且不新建独立连接
+  if (redis_admin && typeof redis_admin._getConnection === 'function') {
+    var conn = await redis_admin._getConnection();
+    return {
+      client: conn,
+      release: function () {
+        try {
+          redis_admin._releaseConnection(conn);
+        } catch (e) {
+          void e;
+        }
+      }
+    };
+  }
+
+  // 回退: mm_redis 不可用，自建独立连接
+  var redis_mod = require('redis');
+  if (!redis_mod || !redis_mod.createClient) {
+    return null;
+  }
+  var createClient = redis_mod.createClient;
+  var client = createClient({
+    socket: {
+      host: opts2.host || 'localhost',
+      port: opts2.port || 6379,
+      connectTimeout: opts2.connect_timeout || 5000,
+      reconnectStrategy: false
+    },
+    password: opts2.password || '',
+    database: opts2.database || 0
+  });
+  await client.connect();
+  return {
+    client: client,
+    release: function () {
+      try {
+        client.quit();
+      } catch (e) {
+        void e;
+      }
+    }
+  };
+}
+
+/**
+ * 主方法
+ * @param {object} ctx 上下文对象
+ * @param {object} params 步骤参数
+ * @returns {object} 发送结果
+ */
+async function main(params, ctx, options) {
+  var opts = (this && typeof this.getOptions === 'function') ? this.getOptions() : {};
+  var driver = opts.driver || 'redis';
+
+  if (driver !== 'redis') {
+    throw new Error('不支持的队列驱动: ' + driver);
+  }
+
+  var queue_name = params.queue_name || '';
+  var data = params.data;
+
+  if (!queue_name) {
+    ctx.output = { error: { code: 'QUEUE_NO_NAME', message: '队列名称不能为空' } };
+    return ctx.output;
+  }
+
+  var holder = await _getClient(opts);
+  if (!holder || !holder.client) {
+    throw new Error('队列发信需要 redis 库，请手动执行: npm install redis');
+  }
+  var client = holder.client;
+  try {
+    await client.lPush(queue_name, JSON.stringify(data));
+  } finally {
+    await holder.release();
+  }
+
+  ctx.output = {
+    sent: true,
+    tip: '消息已入队',
+    queue_name: queue_name,
+    message: data
+  };
+  return ctx.output;
+}
+
+module.exports = { main };

package/lib/tools/queue/index.js

@@ -0,0 +1,395 @@
+/**
+ * 消息队列管理器
+ * 管理消息队列的通用操作，支持发布、消费、确认、重试、死信、延迟、批量消费
+ * 驱动: Redis (redis v4 官方包，与 mm_redis 共用底层库)
+ */
+
+/**
+ * 带超时的 Promise 竞争，超时后抛出错误
+ * @param {Promise} promise 原始 Promise
+ * @param {number} timeout_ms 超时毫秒数
+ * @returns {Promise} 竞争结果
+ * @throws {Error} 超时时抛出
+ */
+function _withTimeout(promise, timeout_ms) {
+  var timer = null;
+  var timeout_promise = new Promise(function (resolve, reject) {
+    timer = setTimeout(function () {
+      reject(new Error('Redis 连接超时'));
+    }, timeout_ms);
+  });
+  return Promise.race([promise, timeout_promise]).finally(function () {
+    clearTimeout(timer);
+  });
+}
+
+/**
+ * 获取 Redis 客户端（通过 mm_redis 的 redisAdmin 获取配置，创建独立连接）
+ * @param {object} opts 配置选项
+ * @returns {object} Redis 客户端
+ * @throws {Error} 连接失败或超时时抛出
+ */
+async function _getClient(opts) {
+  var opts2 = { ...opts };
+  // 统一 db/database 字段，mm_redis 读取的是 database 字段
+  if (opts2.db !== undefined && opts2.database === undefined) {
+    opts2.database = opts2.db;
+  }
+
+  var redis_admin = null;
+  try {
+    var { redisAdmin } = require('mm_redis');
+    if (redisAdmin) {
+      // 使用独立作用域，避免与 redis 管理器共用 sys 池导致本模块配置被覆盖
+      redis_admin = redisAdmin('queue', opts2);
+    }
+  } catch (e) {
+    // mm_redis 不可用时使用传入的 opts
+  }
+
+  // 优先复用 mm_redis 连接池，保证配置一致且不新建独立连接
+  // 使用超时限制，避免 Redis 不可用时连接无限挂起
+  if (redis_admin && typeof redis_admin._getConnection === 'function') {
+    var conn_promise = redis_admin._getConnection();
+    var conn;
+    try {
+      conn = await _withTimeout(conn_promise, opts2.connect_timeout || 3000);
+    } catch (e) {
+      // 超时后底层连接可能仍在创建，创建完成后强制回收，避免连接泄漏
+      conn_promise.then(function (c) {
+        try {
+          redis_admin._releaseConnection(c);
+        } catch (e2) {
+          void e2;
+        }
+      }).catch(function (e2) {
+        void e2;
+      });
+      throw e;
+    }
+    return {
+      client: conn,
+      release: function () {
+        try {
+          redis_admin._releaseConnection(conn);
+        } catch (e2) {
+          void e2;
+        }
+      }
+    };
+  }
+
+  // 回退: mm_redis 不可用，自建独立连接
+  // 禁用自动重连，连接失败时立即抛出，避免无限重连挂起
+  var redis_mod = require('redis');
+  if (!redis_mod || !redis_mod.createClient) {
+    return null;
+  }
+  var createClient = redis_mod.createClient;
+  var client = createClient({
+    socket: {
+      host: opts2.host || 'localhost',
+      port: opts2.port || 6379,
+      connectTimeout: opts2.connect_timeout || 5000,
+      reconnectStrategy: false
+    },
+    password: opts2.password || '',
+    database: opts2.database || 0
+  });
+  try {
+    await client.connect();
+  } catch (e) {
+    try {
+      await client.quit();
+    } catch (e2) {
+      void e2;
+    }
+    throw new Error('Redis 连接失败: ' + (e && e.message ? e.message : String(e)));
+  }
+  return {
+    client: client,
+    release: function () {
+      try {
+        client.quit();
+      } catch (e2) {
+        void e2;
+      }
+    }
+  };
+}
+
+/**
+ * 发布消息到队列
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @param {*} message 消息内容
+ * @returns {object} 发布结果
+ */
+async function _publish(client, queue_name, message) {
+  // lPush 返回的是列表长度而非消息ID，这里生成唯一消息ID
+  var message_id = Date.now().toString(36) + '-' + Math.random().toString(36).substr(2, 9);
+  await client.lPush(queue_name, JSON.stringify(message));
+  return { msg: '消息发布成功', message_id: message_id, queue: queue_name };
+}
+
+/**
+ * 消费队列消息
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @returns {object} 消费结果
+ */
+async function _consume(client, queue_name) {
+  var raw = await client.rPopLPush(queue_name, queue_name + ':processing');
+  if (!raw) {
+    return { obj: null, queue: queue_name };
+  }
+  var parsed = JSON.parse(raw);
+  return { obj: parsed, queue: queue_name, _raw: raw };
+}
+
+/**
+ * 批量消费队列消息
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @param {number} count 消费数量
+ * @returns {object} 批量消费结果
+ */
+async function _batchConsume(client, queue_name, count) {
+  var list = [];
+  for (var i = 0; i < count; i++) {
+    var raw = await client.rPopLPush(queue_name, queue_name + ':processing');
+    if (!raw) break;
+    list.push(JSON.parse(raw));
+  }
+  return { list: list, count: list.length, queue: queue_name };
+}
+
+/**
+ * 确认消费(删除处理中消息)
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @param {string} message_raw 原始消息字符串
+ * @returns {object} 确认结果
+ */
+async function _ack(client, queue_name, message_raw) {
+  if (!message_raw) {
+    return { error: { code: 'QUEUE_ACK_NO_MSG', message: '确认消费需要传入 _raw 消息原文' } };
+  }
+  var removed = await client.lRem(queue_name + ':processing', 1, message_raw);
+  return { msg: removed > 0 ? '消息已确认' : '消息未找到', queue: queue_name };
+}
+
+/**
+ * 消费失败重试(移回主队列)
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @param {string} message_raw 原始消息字符串
+ * @param {number} max_retries 最大重试次数
+ * @returns {object} 重试结果
+ */
+async function _retry(client, queue_name, message_raw, max_retries) {
+  if (!message_raw) {
+    return { error: { code: 'QUEUE_RETRY_NO_MSG', message: '重试需要传入 _raw 消息原文' } };
+  }
+  var max_retry = max_retries || 3;
+  var parsed = JSON.parse(message_raw);
+  var retry_count = (parsed._retry_count || 0) + 1;
+  if (retry_count > max_retry) {
+    await client.lRem(queue_name + ':processing', 1, message_raw);
+    parsed._retry_count = retry_count;
+    parsed._dlq_at = new Date().toISOString();
+    await client.lPush(queue_name + ':dlq', JSON.stringify(parsed));
+    return { msg: '已达最大重试次数，移入死信队列', retry_count: retry_count, queue: queue_name };
+  }
+  parsed._retry_count = retry_count;
+  await client.lRem(queue_name + ':processing', 1, message_raw);
+  await client.lPush(queue_name, JSON.stringify(parsed));
+  return { msg: '消息已重新入队', retry_count: retry_count, queue: queue_name };
+}
+
+/**
+ * 死信队列操作
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @param {string} dlq_action 死信操作: view/replay/clear
+ * @returns {object} 死信队列结果
+ */
+async function _dlq(client, queue_name, dlq_action) {
+  var dlq_key = queue_name + ':dlq';
+  switch (dlq_action) {
+    case 'view': {
+      var all = await client.lRange(dlq_key, 0, -1);
+      var list = (all || []).map(function (r) { return JSON.parse(r); });
+      return { list: list, count: list.length, queue: queue_name };
+    }
+    case 'replay': {
+      var moved = 0;
+      var msg;
+      while ((msg = await client.rPopLPush(dlq_key, queue_name)) !== null) {
+        moved++;
+      }
+      return { msg: '已重放 ' + moved + ' 条死信消息到主队列', count: moved, queue: queue_name };
+    }
+    case 'clear': {
+      var deleted = await client.del(dlq_key);
+      return { msg: '已清空死信队列', queue: queue_name };
+    }
+    default:
+      return { error: { code: 'QUEUE_DLQ_UNKNOWN', message: '不支持的死信操作: ' + dlq_action } };
+  }
+}
+
+/**
+ * 延迟消息
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @param {*} message 消息内容
+ * @param {number} delay_seconds 延迟秒数
+ * @returns {object} 延迟消息结果
+ */
+async function _delay(client, queue_name, message, delay_seconds) {
+  var delay_sec = delay_seconds || 0;
+  if (delay_sec <= 0) {
+    return { error: { code: 'QUEUE_DELAY_INVALID', message: '延迟时间必须大于0秒' } };
+  }
+  var exec_at = Date.now() + delay_sec * 1000;
+  await client.zAdd(queue_name + ':delay', { score: exec_at, value: JSON.stringify(message) });
+  return { msg: '延迟消息已添加', exec_at: new Date(exec_at).toISOString(), delay_seconds: delay_sec, queue: queue_name };
+}
+
+/**
+ * 将到期延迟消息移入主队列
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @returns {object} 迁移结果
+ */
+async function _delayPoll(client, queue_name) {
+  var now = Date.now();
+  var due_msgs = await client.zRangeByScore(queue_name + ':delay', 0, now);
+  if (!due_msgs || due_msgs.length === 0) {
+    return { msg: '无到期延迟消息', count: 0, queue: queue_name };
+  }
+  for (var i = 0; i < due_msgs.length; i++) {
+    await client.lPush(queue_name, due_msgs[i]);
+  }
+  await client.zRemRangeByScore(queue_name + ':delay', 0, now);
+  return { msg: '已迁移到期消息', count: due_msgs.length, queue: queue_name };
+}
+
+/**
+ * 查看队列状态
+ * @param {object} client Redis 客户端
+ * @param {string} queue_name 队列名称
+ * @returns {object} 队列状态
+ */
+async function _status(client, queue_name) {
+  var main_len = await client.lLen(queue_name);
+  var proc_len = await client.lLen(queue_name + ':processing');
+  var dlq_len = await client.lLen(queue_name + ':dlq');
+  var delay_len = await client.zCard(queue_name + ':delay');
+  return {
+    obj: {
+      queue: queue_name,
+      pending: main_len,
+      processing: proc_len,
+      dead_letter: dlq_len,
+      delayed: delay_len
+    }
+  };
+}
+
+/**
+ * 主函数
+ * @param {object} ctx 上下文
+ * @param {object} params 参数
+ * @returns {object} 执行结果
+ */
+async function main(params, ctx, options) {
+  var opts = (this && typeof this.getOptions === 'function') ? this.getOptions() : {};
+  var driver = opts.driver || 'redis';
+
+  if (driver !== 'redis') {
+    ctx.output = {
+      error: {
+        code: 'MGR_UNSUPPORTED_DRIVER',
+        message: '不支持的队列驱动: ' + driver + '，当前支持: redis'
+      }
+    };
+    return ctx.output;
+  }
+
+  var holder;
+  try {
+    holder = await _getClient(opts);
+  } catch (e) {
+    ctx.output = {
+      error: {
+        code: 'MGR_CONNECT_FAIL',
+        message: 'Redis 连接失败: ' + e.message
+      }
+    };
+    return ctx.output;
+  }
+
+  if (!holder || !holder.client) {
+    ctx.output = {
+      error: {
+        code: 'MGR_MISSING_DEP',
+        message: '消息队列需要 redis 库，请手动执行: npm install redis'
+      }
+    };
+    return ctx.output;
+  }
+  var client = holder.client;
+
+  var action = params.action || '';
+  var queue_name = params.queue_name || '';
+
+  if (!queue_name) {
+    ctx.output = { error: { code: 'QUEUE_NO_NAME', message: '队列名称不能为空' } };
+    await holder.release();
+    return ctx.output;
+  }
+
+  try {
+    switch (action) {
+      case 'publish':
+        ctx.output = await _publish(client, queue_name, params.message);
+        break;
+      case 'consume':
+        ctx.output = await _consume(client, queue_name);
+        break;
+      case 'batch_consume':
+        ctx.output = await _batchConsume(client, queue_name, params.count || 10);
+        break;
+      case 'ack':
+        ctx.output = await _ack(client, queue_name, params._raw);
+        break;
+      case 'retry':
+        ctx.output = await _retry(client, queue_name, params._raw, params.max_retries);
+        break;
+      case 'dlq':
+        ctx.output = await _dlq(client, queue_name, params.dlq_action);
+        break;
+      case 'delay':
+        ctx.output = await _delay(client, queue_name, params.message, params.delay_seconds);
+        break;
+      case 'delay_poll':
+        ctx.output = await _delayPoll(client, queue_name);
+        break;
+      case 'status':
+        ctx.output = await _status(client, queue_name);
+        break;
+      default:
+        ctx.output = {
+          error: { code: 'MGR_UNKNOWN_ACTION', message: '不支持的操作: ' + action }
+        };
+    }
+  } finally {
+    await holder.release();
+  }
+
+  return ctx.output;
+}
+
+module.exports = { main };

package/lib/tools/redis/index.js

@@ -0,0 +1,57 @@
+/**
+ * Redis管理器
+ * 管理 Redis 连接和缓存操作（基于 mm_redis）
+ */
+async function main(params, ctx, options) {
+  const { redisAdmin } = require('mm_redis');
+  var action = params.action || '';
+  var key = params.key || '';
+  var value = params.value;
+  var ttl = params.ttl || 0;
+  var field = params.field;
+  var body = params.body || {};
+
+  var opts = this.getOptions();
+
+  let config = { ...opts };
+
+  var redis = redisAdmin('os', config);
+  await redis.open();
+
+  const SIMPLE = [
+    'get', 'set', 'del', 'has', 'exists', 'add', 'getset',
+    'expire', 'pexpire', 'persist', 'ttl',
+    'incr', 'decr', 'incrby', 'decrby', 'incrbyfloat',
+    'keys', 'clear', 'clearExpire', 'dbsize', 'flushdb', 'isConnected',
+    'mget', 'mset',
+    'strlen', 'append', 'setrange',
+    'hgetall', 'hkeys', 'hvals', 'hlen', 'hdel', 'hmset', 'hmget',
+    'setForList', 'addForList', 'getForList', 'clearForList', 'hasForList',
+    'sadd', 'srem', 'sismember', 'smembers', 'scard', 'sinter', 'sunion', 'sdiff',
+    'zcard', 'zrem', 'zcount', 'zrevrange',
+    'publish', 'unsubscribe'
+  ];
+
+  const FIELD_METHODS = [
+    'hget', 'hset', 'hexists',
+    'zadd', 'zscore', 'zrank', 'zrevrank', 'zincrby'
+  ];
+
+  if (SIMPLE.indexOf(action) !== -1) {
+    ctx.output = await redis[action](key, value, ttl);
+  } else if (FIELD_METHODS.indexOf(action) !== -1) {
+    ctx.output = await redis[action](key, field, value, ttl);
+  } else if (action === 'hsetObj') {
+    ctx.output = await redis.hmset(key, body);
+  } else if (action === 'msetObj') {
+    ctx.output = await redis.mset(body, ttl);
+  } else {
+    ctx.output = {
+      error: { code: 'MGR_UNKNOWN_ACTION', message: '不支持的操作: ' + action }
+    };
+  }
+
+  return ctx.output;
+}
+
+module.exports = { main };