079project 1.0.0

package/enhancedForwarder.js

@@ -0,0 +1,378 @@
+const express = require('express');
+const bodyParser = require('body-parser');
+const axios = require('axios');
+const redis = require('redis');
+const cors = require('cors');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// 配置
+const PORT = 7500;
+const REDIS_URL = 'redis://localhost:6379';
+const REQUEST_TIMEOUT = 30000; // 30秒
+const STATIC_DIR = path.join(__dirname, 'public');
+
+// 创建Redis客户端
+let redisClient;
+async function initRedis() {
+    redisClient = redis.createClient({
+        url: REDIS_URL
+    });
+    redisClient.on('error', (err) => console.error('Redis错误:', err));
+    await redisClient.connect();
+    console.log('Redis已连接');
+    return redisClient;
+}
+
+// 创建Express应用
+const app = express();
+app.use(bodyParser.json({ limit: '10mb' }));
+app.use(bodyParser.urlencoded({ extended: true, limit: '10mb' }));
+app.use(cors());
+
+// 如果存在静态目录，提供静态文件服务
+if (fs.existsSync(STATIC_DIR)) {
+    app.use(express.static(STATIC_DIR));
+}
+
+// 工作组路由表 - 从Redis加载
+async function getWorkgroups() {
+    try {
+        const totalCount = parseInt(await redisClient.get('workgroup:totalCount') || '0');
+        const readyCount = parseInt(await redisClient.get('workgroup:readyCount') || '0');
+        
+        const groups = [];
+        for (let i = 0; i < readyCount; i++) {
+            const configStr = await redisClient.get(`workgroup:${i}:config`);
+            if (configStr) {
+                groups.push(JSON.parse(configStr));
+            }
+        }
+        
+        return {
+            total: totalCount,
+            ready: readyCount,
+            groups
+        };
+    } catch (error) {
+        console.error('获取工作组信息失败:', error);
+        return { total: 0, ready: 0, groups: [] };
+    }
+}
+
+// 根据文本内容确定目标工作组
+async function determineTargetGroups(text) {
+    if (!text) return [];
+
+    const allGroups = (await getWorkgroups()).groups;
+    if (allGroups.length === 0) {
+        console.warn('没有可用的工作组');
+        return [];
+    }
+
+    // 词频分析
+    const words = text.toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 1);
+    
+    if (words.length === 0) return [allGroups[0]]; // 默认使用第一个组
+    
+    // 简单实现：将每个词分发到包含该词的工作组
+    const wordMatches = new Map(); // 记录每个工作组匹配的词数
+    
+    for (const group of allGroups) {
+        wordMatches.set(group.id, 0);
+        
+        // 实现更高效的方法是使用Redis的集合操作
+        // 这里使用简化的方法
+        try {
+            // 使用Redis集合检查工作组是否含有这些词
+            const groupKey = `workgroup:${group.id}:vocabulary`;
+            const vocabExists = await redisClient.exists(groupKey);
+            
+            if (vocabExists) {
+                // 检查该组包含多少个词
+                for (const word of words) {
+                    const contains = await redisClient.sIsMember(groupKey, word);
+                    if (contains) {
+                        wordMatches.set(group.id, wordMatches.get(group.id) + 1);
+                    }
+                }
+            }
+        } catch (error) {
+            console.error(`检查工作组 ${group.id} 词汇时出错:`, error);
+        }
+    }
+    
+    // 根据匹配词数排序工作组
+    const sortedGroups = [...wordMatches.entries()]
+        .sort((a, b) => b[1] - a[1])  // 按匹配数降序
+        .map(([id, matches]) => {
+            return {
+                group: allGroups.find(g => g.id === id),
+                matches
+            };
+        })
+        .filter(item => item.matches > 0);
+    
+    // 如果没有匹配，返回默认组
+    if (sortedGroups.length === 0) {
+        return [allGroups[0]];
+    }
+    
+    // 返回前3个最匹配的工作组
+    return sortedGroups.slice(0, 3).map(item => item.group);
+}
+
+// 向工作组发送请求
+async function requestWorkgroup(group, endpoint, data) {
+    const ports = group.servePorts;
+    let lastError = null;
+    
+    // 尝试每个端口
+    for (const port of ports) {
+        try {
+            const url = `http://localhost:${port}/api/${endpoint}`;
+            const response = await axios.post(url, data, {
+                timeout: REQUEST_TIMEOUT,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Workgroup-ID': group.id
+                }
+            });
+            
+            return {
+                groupId: group.id,
+                semanticDomain: group.semanticDomain,
+                data: response.data,
+                responseTime: response.headers['x-response-time'] || 0
+            };
+        } catch (error) {
+            lastError = error;
+            console.warn(`请求工作组 ${group.id} 端口 ${port} 失败:`, error.message);
+        }
+    }
+    
+    // 所有端口都失败
+    throw new Error(`工作组 ${group.id} 的所有端口请求失败: ${lastError?.message}`);
+}
+
+// 聚合多个工作组的结果
+function aggregateResponses(responses, endpoint) {
+    if (responses.length === 0) {
+        return { error: "所有工作组都没有响应" };
+    }
+    
+    if (responses.length === 1) {
+        return responses[0].data;
+    }
+    
+    // 根据不同端点使用不同的聚合策略
+    switch (endpoint) {
+        case 'chat':
+            return aggregateChatResponses(responses);
+        case 'complete':
+            return aggregateCompletionResponses(responses);
+        case 'analyze':
+            return aggregateAnalysisResponses(responses);
+        default:
+            // 默认策略：按响应时间和置信度加权
+            return responses.sort((a, b) => {
+                const scoreA = (a.data.confidence || 0.5) / (parseInt(a.responseTime) || 1000);
+                const scoreB = (b.data.confidence || 0.5) / (parseInt(b.responseTime) || 1000);
+                return scoreB - scoreA;
+            })[0].data;
+    }
+}
+
+function aggregateChatResponses(responses) {
+    // 按置信度排序
+    responses.sort((a, b) => 
+        (b.data.confidence || 0.5) - (a.data.confidence || 0.5)
+    );
+    
+    // 取最高置信度的回复，但附上其他组的补充信息
+    const primaryResponse = responses[0].data;
+    const otherResponses = responses.slice(1);
+    
+    if (otherResponses.length > 0) {
+        primaryResponse.alternativeResponses = otherResponses.map(r => ({
+            response: r.data.response,
+            confidence: r.data.confidence,
+            semanticDomain: r.semanticDomain
+        }));
+    }
+    
+    return primaryResponse;
+}
+
+function aggregateCompletionResponses(responses) {
+    // 简单策略：选择最长且最高置信度的补全
+    const bestResponse = responses.sort((a, b) => {
+        const scoreA = (a.data.completion?.length || 0) * (a.data.confidence || 0.5);
+        const scoreB = (b.data.completion?.length || 0) * (b.data.confidence || 0.5);
+        return scoreB - scoreA;
+    })[0];
+    
+    return bestResponse.data;
+}
+
+function aggregateAnalysisResponses(responses) {
+    // 合并所有分析结果
+    const combinedAnalysis = {
+        topics: [],
+        entities: [],
+        sentiments: [],
+        summaries: []
+    };
+    
+    responses.forEach(resp => {
+        const data = resp.data;
+        if (data.topics) combinedAnalysis.topics.push(...data.topics);
+        if (data.entities) combinedAnalysis.entities.push(...data.entities);
+        if (data.sentiments) combinedAnalysis.sentiments.push(data.sentiments);
+        if (data.summary) combinedAnalysis.summaries.push(data.summary);
+    });
+    
+    // 去重并排序
+    combinedAnalysis.topics = [...new Set(combinedAnalysis.topics)];
+    
+    // 合并实体并去重
+    const uniqueEntities = new Map();
+    combinedAnalysis.entities.forEach(entity => {
+        const key = `${entity.name}:${entity.type}`;
+        if (!uniqueEntities.has(key) || 
+            uniqueEntities.get(key).confidence < entity.confidence) {
+            uniqueEntities.set(key, entity);
+        }
+    });
+    combinedAnalysis.entities = Array.from(uniqueEntities.values());
+    
+    // 计算平均情感
+    if (combinedAnalysis.sentiments.length > 0) {
+        const avgSentiment = combinedAnalysis.sentiments.reduce((acc, s) => acc + s, 0) / 
+                             combinedAnalysis.sentiments.length;
+        combinedAnalysis.sentiment = avgSentiment;
+        delete combinedAnalysis.sentiments;
+    }
+    
+    // 选择最长的摘要
+    if (combinedAnalysis.summaries.length > 0) {
+        combinedAnalysis.summary = combinedAnalysis.summaries.sort(
+            (a, b) => b.length - a.length
+        )[0];
+        delete combinedAnalysis.summaries;
+    }
+    
+    return combinedAnalysis;
+}
+
+// API路由
+app.post('/api/:endpoint', async (req, res) => {
+    const endpoint = req.params.endpoint;
+    const startTime = Date.now();
+    
+    try {
+        // 获取请求内容
+        const requestData = req.body;
+        
+        // 确定目标工作组
+        let targetGroups;
+        if (requestData.message || requestData.text || requestData.content) {
+            const text = requestData.message || requestData.text || requestData.content;
+            targetGroups = await determineTargetGroups(text);
+        } else {
+            // 没有文本内容，选择默认组
+            const allGroups = (await getWorkgroups()).groups;
+            targetGroups = allGroups.length > 0 ? [allGroups[0]] : [];
+        }
+        
+        if (targetGroups.length === 0) {
+            return res.status(503).json({
+                error: "没有可用的工作组",
+                status: "error"
+            });
+        }
+        
+        // 向所有目标工作组发送请求
+        const requests = targetGroups.map(group => 
+            requestWorkgroup(group, endpoint, requestData)
+                .catch(error => ({
+                    groupId: group.id,
+                    error: error.message,
+                    data: { error: error.message }
+                }))
+        );
+        
+        // 等待所有响应
+        const responses = await Promise.all(requests);
+        const successResponses = responses.filter(r => !r.error);
+        
+        if (successResponses.length === 0) {
+            return res.status(502).json({
+                error: "所有工作组请求失败",
+                details: responses.map(r => r.error)
+            });
+        }
+        
+        // 聚合响应
+        const finalResponse = aggregateResponses(successResponses, endpoint);
+        
+        // 添加元数据
+        finalResponse.meta = {
+            processingTime: Date.now() - startTime,
+            groupsConsulted: targetGroups.map(g => g.id),
+            timestamp: new Date().toISOString()
+        };
+        
+        res.json(finalResponse);
+        
+        // 记录请求
+        console.log(`[API:${endpoint}] 处理完成，耗时 ${Date.now() - startTime}ms, 咨询了 ${targetGroups.length} 个工作组`);
+    } catch (error) {
+        console.error(`处理 ${endpoint} 请求时出错:`, error);
+        res.status(500).json({
+            error: error.message,
+            status: "error"
+        });
+    }
+});
+
+// 工作组状态API
+app.get('/api/workgroups/status', async (req, res) => {
+    try {
+        const status = await getWorkgroups();
+        res.json(status);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// 健康检查
+app.get('/health', (req, res) => {
+    res.json({ status: 'ok', uptime: process.uptime() });
+});
+
+// 启动服务器
+async function start() {
+    try {
+        await initRedis();
+        
+        app.listen(PORT, () => {
+            console.log(`增强型转发器运行在 http://localhost:${PORT}`);
+            console.log(`系统信息: ${os.platform()} ${os.release()}, ${os.cpus().length} CPU, ${Math.round(os.totalmem()/1024/1024/1024)}GB RAM`);
+        });
+    } catch (error) {
+        console.error('启动增强型转发器失败:', error);
+        process.exit(1);
+    }
+}
+
+// 启动入口
+if (require.main === module) {
+    start();
+}
+
+module.exports = { app, start };