@qwe8652591/abap-recursive-query 1.1.0

package/dist/common/RedisQueueManager.js

@@ -0,0 +1,663 @@
+"use strict";
+/**
+ * Redis 队列管理器
+ * 负责管理任务队列、Job状态、缓存等
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisQueueManager = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const util_1 = require("util");
+const zlib_1 = require("zlib");
+const types_1 = require("./types");
+const config_1 = require("./config");
+const gzipAsync = (0, util_1.promisify)(zlib_1.gzip);
+const gunzipAsync = (0, util_1.promisify)(zlib_1.gunzip);
+/**
+ * Redis 队列管理器
+ * ✅ 优化：改进连接复用机制，减少连接数
+ */
+class RedisQueueManager {
+    redis;
+    enableCompression;
+    pubClient; // ✅ Pub/Sub 发布客户端
+    subClients = new Map(); // ✅ 订阅客户端映射
+    sharedSubClient; // ✅ 优化：共享订阅客户端（用于多个 Job）
+    constructor(redis) {
+        this.redis = redis || new ioredis_1.default(config_1.redisConfig);
+        this.pubClient = this.redis; // 使用主连接作为发布客户端
+        this.enableCompression = config_1.queueConfig.enableCompression;
+        // 监听连接事件
+        this.redis.on('connect', () => {
+            console.error('[Redis] 已连接到 Redis 服务器');
+        });
+        this.redis.on('error', (err) => {
+            console.error('[Redis] 连接错误:', err);
+        });
+    }
+    // ============================================
+    // Job 管理
+    // ============================================
+    /**
+     * 创建新的 Job
+     */
+    async createJob(jobId, rootObjectType, rootObjectName, config) {
+        const job = {
+            jobId,
+            rootObjectType,
+            rootObjectName,
+            config,
+            status: 'PENDING',
+            totalTasks: 0,
+            completedTasks: 0,
+            failedTasks: 0,
+            skippedTasks: 0,
+            createdAt: new Date(),
+            errors: []
+        };
+        const jobKey = types_1.RedisKeys.JOB(jobId);
+        await this.redis.hmset(jobKey, this.serializeJob(job));
+        // 设置过期时间（1小时）
+        await this.redis.expire(jobKey, config_1.queueConfig.jobTimeout / 1000);
+        // 添加到Job索引
+        await this.redis.zadd(types_1.RedisKeys.JOB_INDEX, Date.now(), jobId);
+        console.error(`[Job] 创建 Job: ${jobId}`);
+    }
+    /**
+     * 获取 Job 信息
+     */
+    async getJob(jobId) {
+        const jobKey = types_1.RedisKeys.JOB(jobId);
+        const jobData = await this.redis.hgetall(jobKey);
+        if (!jobData || Object.keys(jobData).length === 0) {
+            return null;
+        }
+        return this.deserializeJob(jobData);
+    }
+    /**
+     * 更新 Job 状态
+     */
+    async updateJobStatus(jobId, status) {
+        const jobKey = types_1.RedisKeys.JOB(jobId);
+        await this.redis.hset(jobKey, 'status', status);
+        if (status === 'RUNNING') {
+            await this.redis.hset(jobKey, 'startedAt', new Date().toISOString());
+        }
+        else if (status === 'COMPLETED' || status === 'FAILED' || status === 'CANCELLED') {
+            await this.redis.hset(jobKey, 'completedAt', new Date().toISOString());
+        }
+        console.error(`[Job] 更新 Job 状态: ${jobId} -> ${status}`);
+    }
+    /**
+     * 增加 Job 的任务计数
+     */
+    async incrementJobTaskCount(jobId, field) {
+        const jobKey = types_1.RedisKeys.JOB(jobId);
+        await this.redis.hincrby(jobKey, field, 1);
+    }
+    /**
+     * 记录 Job 错误
+     * @param jobId Job ID
+     * @param error 错误信息
+     */
+    async recordJobError(jobId, error) {
+        const jobKey = types_1.RedisKeys.JOB(jobId);
+        await this.redis.rpush(`${jobKey}:errors`, error);
+    }
+    /**
+     * 获取活跃的 Job IDs
+     */
+    async getActiveJobIds() {
+        const jobIds = await this.redis.zrange(types_1.RedisKeys.JOB_INDEX, 0, -1);
+        const activeJobs = [];
+        for (const jobId of jobIds) {
+            const job = await this.getJob(jobId);
+            if (job && (job.status === 'PENDING' || job.status === 'RUNNING')) {
+                activeJobs.push(jobId);
+            }
+        }
+        return activeJobs;
+    }
+    // ============================================
+    // Task 管理
+    // ============================================
+    /**
+     * 创建任务并推送到Job专属队列
+     */
+    async createTask(task, isRetry = false) {
+        const queueKey = types_1.RedisKeys.TASK_QUEUE(task.jobId); // ⚠️ Job专属队列
+        const taskKey = types_1.RedisKeys.TASK(task.taskId);
+        // 1. 保存任务详情
+        await this.redis.hmset(taskKey, this.serializeTask(task));
+        // 设置过期时间
+        await this.redis.expire(taskKey, config_1.queueConfig.cacheExpiry);
+        // 2. 推送到Job专属队列（优先级队列）
+        await this.redis.zadd(queueKey, task.priority, task.taskId);
+        // 3. 增加队列大小计数
+        await this.redis.incr(types_1.RedisKeys.QUEUE_SIZE(task.jobId));
+        // 4. 添加到Job的任务列表
+        await this.redis.sadd(types_1.RedisKeys.JOB_TASKS(task.jobId), task.taskId);
+        // 5. 增加Job的总任务数（⚠️ 重试任务不增加总数，避免进度显示错误）
+        if (!isRetry) {
+            await this.incrementJobTaskCount(task.jobId, 'totalTasks');
+        }
+        return task.taskId;
+    }
+    /**
+     * 从指定Job的队列拉取任务
+     */
+    async pullTask(jobId, timeout = 5) {
+        const queueKey = types_1.RedisKeys.TASK_QUEUE(jobId); // ⚠️ 从指定Job队列拉取
+        // 阻塞式拉取（优先级最高的任务）
+        const result = await this.redis.bzpopmin(queueKey, timeout);
+        if (!result || result.length < 2) {
+            return null;
+        }
+        const taskId = result[1];
+        const task = await this.getTask(taskId);
+        if (!task) {
+            return null;
+        }
+        // 减少队列大小计数
+        await this.redis.decr(types_1.RedisKeys.QUEUE_SIZE(jobId));
+        return task;
+    }
+    /**
+     * 从多个Job的队列拉取任务（消费者可以处理多个Job）
+     */
+    async pullTaskFromAnyJob(jobIds, timeout = 5) {
+        if (jobIds.length === 0) {
+            return null;
+        }
+        const queueKeys = jobIds.map(id => types_1.RedisKeys.TASK_QUEUE(id));
+        // 阻塞式拉取（从多个队列中取优先级最高的）
+        const result = await this.redis.bzpopmin(...queueKeys, timeout);
+        if (!result || result.length < 2) {
+            return null;
+        }
+        const taskId = result[1];
+        const task = await this.getTask(taskId);
+        // 减少队列大小计数
+        if (task) {
+            await this.redis.decr(types_1.RedisKeys.QUEUE_SIZE(task.jobId));
+        }
+        return task;
+    }
+    /**
+     * 获取任务信息
+     */
+    async getTask(taskId) {
+        const taskKey = types_1.RedisKeys.TASK(taskId);
+        const taskData = await this.redis.hgetall(taskKey);
+        if (!taskData || Object.keys(taskData).length === 0) {
+            return null;
+        }
+        return this.deserializeTask(taskData);
+    }
+    /**
+     * 更新任务状态
+     */
+    async updateTaskStatus(taskId, status, workerId, error) {
+        const taskKey = types_1.RedisKeys.TASK(taskId);
+        const updates = { status };
+        if (status === 'RUNNING') {
+            updates.startedAt = new Date().toISOString();
+            if (workerId) {
+                updates.workerId = workerId;
+            }
+        }
+        else if (status === 'COMPLETED' || status === 'FAILED' || status === 'SKIPPED') {
+            updates.completedAt = new Date().toISOString();
+        }
+        if (error) {
+            updates.error = error;
+        }
+        await this.redis.hmset(taskKey, updates);
+    }
+    /**
+     * 完成任务（✅ 优化：发送队列空间通知）
+     */
+    async completeTask(taskId, result) {
+        const task = await this.getTask(taskId);
+        if (!task) {
+            console.error(`[Task] 任务不存在: ${taskId}`);
+            return;
+        }
+        await this.updateTaskStatus(taskId, 'COMPLETED');
+        await this.incrementJobTaskCount(task.jobId, 'completedTasks');
+        // ✅ 通知队列有空间（事件驱动的背压控制）
+        await this.notifyQueueSpace(task.jobId);
+        // 检查Job是否完成
+        await this.checkJobCompletion(task.jobId);
+    }
+    /**
+     * 任务失败
+     */
+    async failTask(taskId, error) {
+        const task = await this.getTask(taskId);
+        if (!task) {
+            console.error(`[Task] 任务不存在: ${taskId}`);
+            return;
+        }
+        // 检查是否需要重试
+        if (task.retryCount < task.maxRetries) {
+            // 重新入队
+            const retryTask = {
+                ...task,
+                retryCount: task.retryCount + 1,
+                status: 'PENDING',
+                priority: task.priority + 10000 // 降低优先级
+            };
+            // ⚠️ 重要：传入 isRetry = true，避免重复计算 totalTasks
+            await this.createTask(retryTask, true);
+            console.error(`[Task] 任务重试: ${taskId} (${retryTask.retryCount}/${task.maxRetries})`);
+        }
+        else {
+            // 标记为失败
+            await this.updateTaskStatus(taskId, 'FAILED', undefined, error);
+            await this.incrementJobTaskCount(task.jobId, 'failedTasks');
+            // 删除失败任务的缓存，释放内存
+            await this.deleteCache(task.jobId, task.objectKey);
+            console.error(`[Task] 删除失败任务的缓存: ${task.objectKey}`);
+            // 记录错误到Job
+            await this.recordJobError(task.jobId, `任务失败 (${task.objectKey}): ${error}`);
+            // 检查Job是否完成
+            await this.checkJobCompletion(task.jobId);
+        }
+    }
+    /**
+     * 检查Job是否完成（✅ 修复：只有在所有任务处理完后才更新状态）
+     */
+    async checkJobCompletion(jobId) {
+        const job = await this.getJob(jobId);
+        if (!job) {
+            return;
+        }
+        const finishedTasks = job.completedTasks + job.failedTasks + job.skippedTasks;
+        // ✅ 修复：只有当所有任务都处理完后才更新 Job 状态
+        // 之前的问题：只要有失败任务就立即标记为 FAILED，导致 Producer 提前退出
+        if (finishedTasks >= job.totalTasks && job.totalTasks > 0) {
+            // 计算失败率
+            const failureRate = job.failedTasks / job.totalTasks;
+            // 根据失败率决定状态
+            // - 如果没有失败任务：COMPLETED
+            // - 如果失败率 < 50%：COMPLETED（部分失败也算完成）
+            // - 如果失败率 >= 50%：FAILED
+            let status;
+            if (job.failedTasks === 0) {
+                status = 'COMPLETED';
+            }
+            else if (failureRate < 0.5) {
+                status = 'COMPLETED'; // 部分失败，但大部分成功
+                console.error(`[Job] Job ${jobId} 完成（部分失败: ${job.failedTasks}/${job.totalTasks}）`);
+            }
+            else {
+                status = 'FAILED'; // 失败率过高
+            }
+            await this.updateJobStatus(jobId, status);
+            console.error(`[Job] Job完成: ${jobId}, 状态: ${status}, 成功: ${job.completedTasks}, 失败: ${job.failedTasks}, 跳过: ${job.skippedTasks}`);
+        }
+    }
+    // ============================================
+    // 队列监控
+    // ============================================
+    /**
+     * 获取指定Job的队列大小
+     */
+    async getQueueSize(jobId) {
+        const sizeStr = await this.redis.get(types_1.RedisKeys.QUEUE_SIZE(jobId));
+        return parseInt(sizeStr || '0');
+    }
+    /**
+     * 获取队列中的任务数（精确但较慢）
+     */
+    async getQueueTaskCount(jobId) {
+        const queueKey = types_1.RedisKeys.TASK_QUEUE(jobId);
+        return await this.redis.zcard(queueKey);
+    }
+    // ============================================
+    // 缓存管理
+    // ============================================
+    /**
+     * 缓存对象数据
+     */
+    async cacheObject(jobId, objectKey, data) {
+        const cacheKey = types_1.RedisKeys.CACHE(jobId, objectKey);
+        let cachedData;
+        if (this.enableCompression) {
+            // 压缩存储
+            const jsonString = JSON.stringify(data);
+            const compressed = await gzipAsync(Buffer.from(jsonString));
+            cachedData = compressed.toString('base64');
+        }
+        else {
+            cachedData = JSON.stringify(data);
+        }
+        await this.redis.setex(cacheKey, config_1.queueConfig.cacheExpiry, cachedData);
+    }
+    /**
+     * 获取缓存的对象数据
+     */
+    async getCache(jobId, objectKey) {
+        const cacheKey = types_1.RedisKeys.CACHE(jobId, objectKey);
+        const cachedData = await this.redis.get(cacheKey);
+        if (!cachedData) {
+            return null;
+        }
+        if (this.enableCompression) {
+            // 解压缩
+            const buffer = Buffer.from(cachedData, 'base64');
+            const decompressed = await gunzipAsync(buffer);
+            return JSON.parse(decompressed.toString());
+        }
+        else {
+            return JSON.parse(cachedData);
+        }
+    }
+    /**
+     * 删除缓存
+     */
+    async deleteCache(jobId, objectKey) {
+        const cacheKey = types_1.RedisKeys.CACHE(jobId, objectKey);
+        await this.redis.del(cacheKey);
+    }
+    // ============================================
+    // 去重检查
+    // ============================================
+    /**
+     * 检查对象是否已访问
+     */
+    async isVisited(jobId, objectKey) {
+        const visitedKey = types_1.RedisKeys.VISITED(jobId);
+        return (await this.redis.sismember(visitedKey, objectKey)) === 1;
+    }
+    /**
+     * 标记对象为已访问
+     */
+    async markVisited(jobId, objectKey) {
+        const visitedKey = types_1.RedisKeys.VISITED(jobId);
+        await this.redis.sadd(visitedKey, objectKey);
+        await this.redis.expire(visitedKey, config_1.queueConfig.cacheExpiry);
+    }
+    /**
+     * 原子性地标记对象为已访问（如果未访问则标记）
+     * @param jobId Job ID
+     * @param objectKey 对象键
+     * @returns true 表示首次访问（未被访问过），false 表示已访问
+     */
+    async markVisitedIfNotExists(jobId, objectKey) {
+        const visitedKey = types_1.RedisKeys.VISITED(jobId);
+        // SADD 返回 1 表示新增成功（未访问），返回 0 表示已存在（已访问）
+        const result = await this.redis.sadd(visitedKey, objectKey);
+        // 设置过期时间
+        await this.redis.expire(visitedKey, config_1.queueConfig.cacheExpiry);
+        return result === 1; // true = 首次访问，false = 已访问
+    }
+    /**
+     * 检查附加数据是否已处理（用于去重）
+     * @param jobId Job ID
+     * @param category 数据类别（textelements/messages/guititle/guistatus/screens）
+     * @param programName 程序名称
+     * @returns true 表示已处理，false 表示未处理
+     */
+    async hasProcessed(jobId, category, programName) {
+        const key = `abap:job:${jobId}:processed:${category}:${programName}`;
+        return (await this.redis.exists(key)) === 1;
+    }
+    /**
+     * 标记附加数据为已处理
+     * @param jobId Job ID
+     * @param category 数据类别
+     * @param programName 程序名称
+     */
+    async markProcessed(jobId, category, programName) {
+        const key = `abap:job:${jobId}:processed:${category}:${programName}`;
+        await this.redis.setex(key, config_1.queueConfig.cacheExpiry, '1');
+    }
+    // ============================================
+    // 进度追踪
+    // ============================================
+    /**
+     * 更新进度
+     */
+    async updateProgress(jobId, progress) {
+        const progressKey = types_1.RedisKeys.PROGRESS(jobId);
+        await this.redis.hmset(progressKey, {
+            totalTasks: progress.totalTasks.toString(),
+            completedTasks: progress.completedTasks.toString(),
+            failedTasks: progress.failedTasks.toString(),
+            skippedTasks: progress.skippedTasks.toString(),
+            percentage: progress.percentage.toFixed(2),
+            lastUpdateTime: progress.lastUpdateTime.toISOString()
+        });
+        await this.redis.expire(progressKey, config_1.queueConfig.cacheExpiry);
+    }
+    /**
+     * 获取进度
+     */
+    async getProgress(jobId) {
+        const progressKey = types_1.RedisKeys.PROGRESS(jobId);
+        const progressData = await this.redis.hgetall(progressKey);
+        if (!progressData || Object.keys(progressData).length === 0) {
+            // 从Job数据中获取进度
+            const job = await this.getJob(jobId);
+            if (!job) {
+                return null;
+            }
+            const total = job.totalTasks || 1;
+            const completed = job.completedTasks + job.failedTasks + job.skippedTasks;
+            return {
+                totalTasks: job.totalTasks,
+                completedTasks: job.completedTasks,
+                failedTasks: job.failedTasks,
+                skippedTasks: job.skippedTasks,
+                percentage: (completed / total) * 100,
+                lastUpdateTime: new Date()
+            };
+        }
+        return {
+            totalTasks: parseInt(progressData.totalTasks || '0'),
+            completedTasks: parseInt(progressData.completedTasks || '0'),
+            failedTasks: parseInt(progressData.failedTasks || '0'),
+            skippedTasks: parseInt(progressData.skippedTasks || '0'),
+            percentage: parseFloat(progressData.percentage || '0'),
+            lastUpdateTime: new Date(progressData.lastUpdateTime)
+        };
+    }
+    // ============================================
+    // 辅助方法
+    // ============================================
+    /**
+     * 序列化 Job
+     */
+    serializeJob(job) {
+        return {
+            jobId: job.jobId,
+            rootObjectType: job.rootObjectType,
+            rootObjectName: job.rootObjectName,
+            config: JSON.stringify(job.config),
+            status: job.status,
+            totalTasks: job.totalTasks.toString(),
+            completedTasks: job.completedTasks.toString(),
+            failedTasks: job.failedTasks.toString(),
+            skippedTasks: job.skippedTasks.toString(),
+            createdAt: job.createdAt.toISOString(),
+            startedAt: job.startedAt?.toISOString() || '',
+            completedAt: job.completedAt?.toISOString() || '',
+            errors: JSON.stringify(job.errors)
+        };
+    }
+    /**
+     * 反序列化 Job
+     */
+    deserializeJob(data) {
+        return {
+            jobId: data.jobId,
+            rootObjectType: data.rootObjectType,
+            rootObjectName: data.rootObjectName,
+            config: JSON.parse(data.config || '{}'),
+            status: data.status,
+            totalTasks: parseInt(data.totalTasks || '0'),
+            completedTasks: parseInt(data.completedTasks || '0'),
+            failedTasks: parseInt(data.failedTasks || '0'),
+            skippedTasks: parseInt(data.skippedTasks || '0'),
+            createdAt: new Date(data.createdAt),
+            startedAt: data.startedAt ? new Date(data.startedAt) : undefined,
+            completedAt: data.completedAt ? new Date(data.completedAt) : undefined,
+            errors: JSON.parse(data.errors || '[]')
+        };
+    }
+    /**
+     * 序列化 Task
+     */
+    serializeTask(task) {
+        return {
+            taskId: task.taskId,
+            jobId: task.jobId,
+            objectKey: task.objectKey,
+            taskType: task.taskType,
+            objectType: task.objectType,
+            objectName: task.objectName,
+            depth: task.depth.toString(),
+            priority: task.priority.toString(),
+            status: task.status,
+            retryCount: task.retryCount.toString(),
+            maxRetries: task.maxRetries.toString(),
+            createdAt: task.createdAt.toISOString(),
+            startedAt: task.startedAt?.toISOString() || '',
+            completedAt: task.completedAt?.toISOString() || '',
+            metadata: JSON.stringify(task.metadata),
+            error: task.error || '',
+            workerId: task.workerId || ''
+        };
+    }
+    /**
+     * 反序列化 Task
+     */
+    deserializeTask(data) {
+        return {
+            taskId: data.taskId,
+            jobId: data.jobId,
+            objectKey: data.objectKey,
+            taskType: data.taskType,
+            objectType: data.objectType,
+            objectName: data.objectName,
+            depth: parseInt(data.depth || '0'),
+            priority: parseInt(data.priority || '0'),
+            status: data.status,
+            retryCount: parseInt(data.retryCount || '0'),
+            maxRetries: parseInt(data.maxRetries || '3'),
+            createdAt: new Date(data.createdAt),
+            startedAt: data.startedAt ? new Date(data.startedAt) : undefined,
+            completedAt: data.completedAt ? new Date(data.completedAt) : undefined,
+            metadata: JSON.parse(data.metadata || '{}'),
+            error: data.error || undefined,
+            workerId: data.workerId || undefined
+        };
+    }
+    // ============================================
+    // Pub/Sub 通知机制（✅ 优化：事件驱动的背压控制）
+    // ============================================
+    /**
+     * 发布队列空间可用事件（在 Consumer 完成任务时调用）
+     */
+    async notifyQueueSpace(jobId) {
+        const channel = `abap:queue:space:${jobId}`;
+        await this.pubClient.publish(channel, Date.now().toString());
+    }
+    /**
+     * 订阅队列空间可用事件
+     * ✅ 优化：使用共享订阅客户端，减少连接数
+     * @returns 返回取消订阅的函数
+     */
+    async subscribeQueueSpace(jobId, callback) {
+        const channel = `abap:queue:space:${jobId}`;
+        // ✅ 优化：复用共享订阅客户端，而非每次创建新连接
+        if (!this.sharedSubClient) {
+            this.sharedSubClient = this.redis.duplicate();
+            // 监听所有消息并分发给相应的回调
+            this.sharedSubClient.on('message', (ch, message) => {
+                // 从 subClients 获取对应的回调列表
+                const callbacks = this.subClients.get(ch);
+                if (callbacks && Array.isArray(callbacks)) {
+                    callbacks.forEach((cb) => {
+                        if (typeof cb === 'function') {
+                            cb();
+                        }
+                    });
+                }
+            });
+            console.error('[Redis] 创建共享订阅客户端');
+        }
+        // 获取或创建该频道的回调列表
+        if (!this.subClients.has(channel)) {
+            this.subClients.set(channel, []);
+            // 首次订阅该频道
+            await this.sharedSubClient.subscribe(channel);
+        }
+        // 添加回调到列表
+        const callbacks = this.subClients.get(channel);
+        callbacks.push(callback);
+        // 返回取消订阅函数
+        return async () => {
+            const callbacks = this.subClients.get(channel);
+            if (callbacks) {
+                // 移除该回调
+                const index = callbacks.indexOf(callback);
+                if (index !== -1) {
+                    callbacks.splice(index, 1);
+                }
+                // 如果该频道没有回调了，取消订阅
+                if (callbacks.length === 0) {
+                    this.subClients.delete(channel);
+                    if (this.sharedSubClient) {
+                        await this.sharedSubClient.unsubscribe(channel);
+                    }
+                }
+            }
+        };
+    }
+    // ============================================
+    // 资源管理
+    // ============================================
+    /**
+     * 关闭连接
+     * ✅ 优化：正确关闭共享订阅客户端
+     */
+    async close() {
+        // 关闭共享订阅客户端
+        if (this.sharedSubClient) {
+            try {
+                await this.sharedSubClient.quit();
+                console.error('[Redis] 已关闭共享订阅客户端');
+            }
+            catch (error) {
+                console.error('[Redis] 关闭共享订阅客户端失败:', error);
+            }
+            this.sharedSubClient = undefined;
+        }
+        this.subClients.clear();
+        // 关闭主连接
+        await this.redis.quit();
+        console.error('[Redis] 已断开连接');
+    }
+    /**
+     * 清理Job的所有数据
+     */
+    async cleanupJob(jobId) {
+        const keys = [
+            types_1.RedisKeys.JOB(jobId),
+            types_1.RedisKeys.JOB_TASKS(jobId),
+            types_1.RedisKeys.TASK_QUEUE(jobId),
+            types_1.RedisKeys.VISITED(jobId),
+            types_1.RedisKeys.PROGRESS(jobId),
+            types_1.RedisKeys.QUEUE_SIZE(jobId)
+        ];
+        await this.redis.del(...keys);
+        await this.redis.zrem(types_1.RedisKeys.JOB_INDEX, jobId);
+        console.error(`[Job] 清理 Job 数据: ${jobId}`);
+    }
+}
+exports.RedisQueueManager = RedisQueueManager;