alemonjs 2.1.0 → 2.1.1

package/lib/cbp/core/load-balancer.js

@@ -0,0 +1,119 @@
+import { getHealthyConnectionIds } from './connection-manager.js';
+
+const LoadBalanceStrategyEnum = {
+    ROUND_ROBIN: 'round-robin',
+    LEAST_CONNECTIONS: 'least-connections',
+    RANDOM: 'random',
+    FIRST_AVAILABLE: 'first-available'
+};
+const createLoadBalancerState = (strategy = 'round-robin') => ({
+    strategy,
+    roundRobinIndex: 0,
+    bindingCounts: new Map()
+});
+const selectByRoundRobin = (availableIds, currentIndex) => {
+    if (availableIds.length === 0) {
+        return { selectedId: null, nextIndex: currentIndex };
+    }
+    const selectedId = availableIds[currentIndex % availableIds.length];
+    const nextIndex = (currentIndex + 1) % availableIds.length;
+    return { selectedId, nextIndex };
+};
+const selectByLeastConnections = (availableIds, bindingCounts) => {
+    if (availableIds.length === 0) {
+        return null;
+    }
+    let selectedId = availableIds[0];
+    let minConnections = bindingCounts.get(selectedId) || 0;
+    for (let i = 1; i < availableIds.length; i++) {
+        const id = availableIds[i];
+        const connections = bindingCounts.get(id) || 0;
+        if (connections < minConnections) {
+            minConnections = connections;
+            selectedId = id;
+        }
+    }
+    return selectedId;
+};
+const selectByRandom = (availableIds) => {
+    if (availableIds.length === 0) {
+        return null;
+    }
+    const randomIndex = Math.floor(Math.random() * availableIds.length);
+    return availableIds[randomIndex];
+};
+const selectFirstAvailable = (availableIds) => {
+    return availableIds.length > 0 ? availableIds[0] : null;
+};
+const selectConnection = (connectionState, balancerState) => {
+    const availableIds = getHealthyConnectionIds(connectionState);
+    if (availableIds.length === 0) {
+        return { selectedId: null, newBalancerState: balancerState };
+    }
+    let selectedId = null;
+    const newBalancerState = { ...balancerState };
+    switch (balancerState.strategy) {
+        case 'round-robin': {
+            const result = selectByRoundRobin(availableIds, balancerState.roundRobinIndex);
+            selectedId = result.selectedId;
+            newBalancerState.roundRobinIndex = result.nextIndex;
+            break;
+        }
+        case 'least-connections': {
+            selectedId = selectByLeastConnections(availableIds, balancerState.bindingCounts);
+            break;
+        }
+        case 'random': {
+            selectedId = selectByRandom(availableIds);
+            break;
+        }
+        case 'first-available': {
+            selectedId = selectFirstAvailable(availableIds);
+            break;
+        }
+        default: {
+            const result = selectByRoundRobin(availableIds, balancerState.roundRobinIndex);
+            selectedId = result.selectedId;
+            newBalancerState.roundRobinIndex = result.nextIndex;
+            break;
+        }
+    }
+    return { selectedId, newBalancerState };
+};
+const incrementBindingCount = (balancerState, connectionId) => {
+    const newBindingCounts = new Map(balancerState.bindingCounts);
+    const currentCount = newBindingCounts.get(connectionId) || 0;
+    newBindingCounts.set(connectionId, currentCount + 1);
+    return {
+        ...balancerState,
+        bindingCounts: newBindingCounts
+    };
+};
+const decrementBindingCount = (balancerState, connectionId) => {
+    const newBindingCounts = new Map(balancerState.bindingCounts);
+    const currentCount = newBindingCounts.get(connectionId) || 0;
+    if (currentCount > 0) {
+        newBindingCounts.set(connectionId, currentCount - 1);
+    }
+    else {
+        newBindingCounts.delete(connectionId);
+    }
+    return {
+        ...balancerState,
+        bindingCounts: newBindingCounts
+    };
+};
+const getLoadBalancerStats = (balancerState) => {
+    const totalBindings = Array.from(balancerState.bindingCounts.values())
+        .reduce((sum, count) => sum + count, 0);
+    return {
+        strategy: balancerState.strategy,
+        roundRobinIndex: balancerState.roundRobinIndex,
+        totalConnections: balancerState.bindingCounts.size,
+        totalBindings,
+        bindingCounts: Object.fromEntries(balancerState.bindingCounts),
+        lastUpdate: Date.now()
+    };
+};
+
+export { LoadBalanceStrategyEnum, createLoadBalancerState, decrementBindingCount, getLoadBalancerStats, incrementBindingCount, selectByLeastConnections, selectByRandom, selectByRoundRobin, selectConnection, selectFirstAvailable };

package/lib/cbp/processor/actions.d.ts

@@ -1,3 +1,6 @@
 import { Result } from '../../core';
 import type { Actions } from '../../types';
 export declare const sendAction: (data: Actions) => Promise<Result[]>;
+export declare const handleActionResponse: (actionId: string, results: Result[]) => void;
+export declare const getPendingActionCount: () => number;
+export declare const destroyActionHandler: () => void;

package/lib/cbp/processor/actions.js

@@ -1,28 +1,17 @@
-import * as flattedJSON from 'flatted';
-import { ResultCode } from '../../core/variable.js';
-import 'fs';
-import 'path';
-import 'yaml';
-import { createResult } from '../../core/utils.js';
-import { generateUniqueId, deviceId, actionResolves, actionTimeouts, timeoutTime } from './config.js';
+import { handleRequestResponse, sendRequest, getPendingRequestCount, destroyRequestHandler, createRequestHandlerState } from './request-handler.js';
 
+const actionHandlerState = createRequestHandlerState('行为', 'actionId');
 const sendAction = (data) => {
-    const actionId = generateUniqueId();
-    return new Promise(resolve => {
-        data.actionId = actionId;
-        data.DeviceId = deviceId;
-        global.chatbotClient.send(flattedJSON.stringify(data));
-        actionResolves.set(actionId, resolve);
-        const timeout = setTimeout(() => {
-            if (!actionResolves.has(actionId) || !actionTimeouts.has(actionId)) {
-                return;
-            }
-            actionResolves.delete(actionId);
-            actionTimeouts.delete(actionId);
-            resolve([createResult(ResultCode.Fail, '行为超时', null)]);
-        }, timeoutTime);
-        actionTimeouts.set(actionId, timeout);
-    });
+    return sendRequest(actionHandlerState, data);
+};
+const handleActionResponse = (actionId, results) => {
+    handleRequestResponse(actionHandlerState, actionId, results);
+};
+const getPendingActionCount = () => {
+    return getPendingRequestCount(actionHandlerState);
+};
+const destroyActionHandler = () => {
+    destroyRequestHandler(actionHandlerState);
 };
 
-export { sendAction };
+export { destroyActionHandler, getPendingActionCount, handleActionResponse, sendAction };

package/lib/cbp/processor/api.d.ts

@@ -1,3 +1,6 @@
 import { Result } from '../../core';
 import type { Apis } from '../../types';
 export declare const sendAPI: (data: Apis) => Promise<Result[]>;
+export declare const handleApiResponse: (apiId: string, results: Result[]) => void;
+export declare const getPendingApiCount: () => number;
+export declare const destroyApiHandler: () => void;

package/lib/cbp/processor/api.js

@@ -1,28 +1,17 @@
-import { ResultCode } from '../../core/variable.js';
-import 'fs';
-import 'path';
-import 'yaml';
-import { createResult } from '../../core/utils.js';
-import { generateUniqueId, deviceId, apiResolves, apiTimeouts, timeoutTime } from './config.js';
-import * as flattedJSON from 'flatted';
+import { handleRequestResponse, sendRequest, getPendingRequestCount, destroyRequestHandler, createRequestHandlerState } from './request-handler.js';
 
+const apiHandlerState = createRequestHandlerState('接口', 'apiId');
 const sendAPI = (data) => {
-    const ApiId = generateUniqueId();
-    return new Promise(resolve => {
-        data.apiId = ApiId;
-        data.DeviceId = deviceId;
-        global.chatbotClient.send(flattedJSON.stringify(data));
-        apiResolves.set(ApiId, resolve);
-        const timeout = setTimeout(() => {
-            if (!apiResolves.has(ApiId) || !apiTimeouts.has(ApiId)) {
-                return;
-            }
-            apiResolves.delete(ApiId);
-            apiTimeouts.delete(ApiId);
-            resolve([createResult(ResultCode.Fail, '接口超时', null)]);
-        }, timeoutTime);
-        apiTimeouts.set(ApiId, timeout);
-    });
+    return sendRequest(apiHandlerState, data);
+};
+const handleApiResponse = (apiId, results) => {
+    handleRequestResponse(apiHandlerState, apiId, results);
+};
+const getPendingApiCount = () => {
+    return getPendingRequestCount(apiHandlerState);
+};
+const destroyApiHandler = () => {
+    destroyRequestHandler(apiHandlerState);
 };
 
-export { sendAPI };
+export { destroyApiHandler, getPendingApiCount, handleApiResponse, sendAPI };

package/lib/cbp/processor/config.d.ts

@@ -1,26 +1,54 @@
 import { WebSocket } from 'ws';
 import { Result } from '../../core';
-export declare const childrenClient: Map<string, WebSocket>;
-export declare const platformClient: Map<string, WebSocket>;
-export declare const fullClient: Map<string, WebSocket>;
-export declare const deviceId: string;
-export declare const USER_AGENT_HEADER = "user-agent";
-export declare const USER_AGENT_HEADER_VALUE_MAP: {
-    platform: string;
-    client: string;
-    testone: string;
-};
-export declare const DEVICE_ID_HEADER = "x-device-id";
-export declare const FULL_RECEIVE_HEADER = "x-full-receive";
+import { LoadBalanceStrategy } from '../core/load-balancer';
+import { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER } from '../core/constants';
 type actionResolvesValue = Result[] | PromiseLike<Result[]>;
 type actionResolvesValueFunc = (value: actionResolvesValue) => void;
 export declare const actionResolves: Map<string, actionResolvesValueFunc>;
 export declare const apiResolves: Map<string, actionResolvesValueFunc>;
 export declare const actionTimeouts: Map<string, NodeJS.Timeout>;
 export declare const apiTimeouts: Map<string, NodeJS.Timeout>;
-export declare const childrenBind: Map<string, string>;
-export declare const generateUniqueId: () => string;
+export declare const deviceId: string;
+export { USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, DEVICE_ID_HEADER, FULL_RECEIVE_HEADER };
 export declare const timeoutTime: number;
 export declare const reconnectInterval: number;
-export declare const HEARTBEAT_INTERVAL: number;
-export {};
+export declare const addChildrenClient: (id: string, ws: WebSocket) => void;
+export declare const removeChildrenClient: (id: string) => boolean;
+export declare const getChildrenClient: (id: string) => WebSocket | undefined;
+export declare const hasChildrenClient: (id: string) => boolean;
+export declare const clearChildrenClients: () => void;
+export declare const getChildrenClientCount: () => number;
+export declare const forEachChildrenClient: (callback: (ws: WebSocket, id: string) => void) => void;
+export declare const getChildrenClientIds: () => string[];
+export declare const getAllChildrenClients: () => Map<string, WebSocket>;
+export declare const addPlatformClient: (id: string, ws: WebSocket) => void;
+export declare const removePlatformClient: (id: string) => boolean;
+export declare const getPlatformClient: (id: string) => WebSocket | undefined;
+export declare const getPlatformClientCount: () => number;
+export declare const clearPlatformClients: () => void;
+export declare const forEachPlatformClient: (callback: (ws: WebSocket, id: string) => void) => void;
+export declare const addFullClient: (id: string, ws: WebSocket) => void;
+export declare const removeFullClient: (id: string) => boolean;
+export declare const getFullClient: (id: string) => WebSocket | undefined;
+export declare const getFullClientCount: () => number;
+export declare const clearFullClients: () => void;
+export declare const forEachFullClient: (callback: (ws: WebSocket, id: string) => void) => void;
+export declare const getHealthyClients: () => string[];
+export declare const selectClientByStrategy: (_sessionId: string, _key?: string) => string | null;
+export declare const bindSessionToClient: (sessionId: string, key?: string) => string | null;
+export declare const unbindSession: (sessionId: string) => void;
+export declare const setLoadBalanceStrategy: (strategy: LoadBalanceStrategy) => void;
+export declare const getLoadBalanceStats: () => {
+    totalClients: number;
+    healthyClients: number;
+    totalBindings: number;
+    bindingCounts: {
+        [k: string]: number;
+    };
+    strategy: LoadBalanceStrategy;
+    uptime: number;
+};
+export declare const performHealthCheck: () => void;
+export declare const startHealthCheckTimer: () => void;
+export declare const stopHealthCheckTimer: () => void;
+export declare const destroyLoadBalancer: () => void;

package/lib/cbp/processor/config.js

@@ -1,27 +1,278 @@
-import { v4 } from 'uuid';
+import { WebSocket } from 'ws';
+import { getConnectionStats, createConnectionState, addConnection, getConnection, removeConnection, clearAllConnections, getHealthyConnectionIds } from '../core/connection-manager.js';
+import { getLoadBalancerStats, createLoadBalancerState, incrementBindingCount, decrementBindingCount, selectConnection } from '../core/load-balancer.js';
+import { generateUniqueId, TIME_CONFIG } from '../core/constants.js';
+export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP } from '../core/constants.js';
 
-const childrenClient = new Map();
-const platformClient = new Map();
-const fullClient = new Map();
-const deviceId = v4();
-const USER_AGENT_HEADER = 'user-agent';
-const USER_AGENT_HEADER_VALUE_MAP = {
-    platform: 'platform',
-    client: 'client',
-    testone: 'testone'
-};
-const DEVICE_ID_HEADER = 'x-device-id';
-const FULL_RECEIVE_HEADER = 'x-full-receive';
+let childrenConnectionState = createConnectionState();
+let platformConnectionState = createConnectionState();
+let fullConnectionState = createConnectionState();
+let loadBalancerState = createLoadBalancerState('least-connections');
+const sessionBindings = new Map();
 const actionResolves = new Map();
 const apiResolves = new Map();
 const actionTimeouts = new Map();
 const apiTimeouts = new Map();
-const childrenBind = new Map();
-const generateUniqueId = () => {
-    return Date.now().toString(36) + Math.random().toString(36).substring(2);
+const deviceId = generateUniqueId();
+const timeoutTime = TIME_CONFIG.TIMEOUT;
+const reconnectInterval = TIME_CONFIG.RECONNECT_INTERVAL;
+const addChildrenClient = (id, ws) => {
+    childrenConnectionState = addConnection(childrenConnectionState, id, ws);
+    loadBalancerState = incrementBindingCount(loadBalancerState, id);
+    logger.debug({
+        code: 200,
+        message: `子客户端已添加: ${id}`,
+        data: { totalClients: childrenConnectionState.connections.size }
+    });
+};
+const removeChildrenClient = (id) => {
+    const existed = getConnection(childrenConnectionState, id) !== undefined;
+    if (existed) {
+        childrenConnectionState = removeConnection(childrenConnectionState, id);
+        loadBalancerState = decrementBindingCount(loadBalancerState, id);
+        const bindingsToRemove = [];
+        for (const [sessionId, boundClientId] of sessionBindings.entries()) {
+            if (boundClientId === id) {
+                bindingsToRemove.push(sessionId);
+            }
+        }
+        bindingsToRemove.forEach(sessionId => sessionBindings.delete(sessionId));
+        logger.debug({
+            code: 200,
+            message: `子客户端已移除: ${id}`,
+            data: { cleanedBindings: bindingsToRemove.length }
+        });
+    }
+    return existed;
+};
+const getChildrenClient = (id) => {
+    return getConnection(childrenConnectionState, id);
+};
+const hasChildrenClient = (id) => {
+    return getConnection(childrenConnectionState, id) !== undefined;
+};
+const clearChildrenClients = () => {
+    childrenConnectionState = clearAllConnections(childrenConnectionState);
+    loadBalancerState = createLoadBalancerState(loadBalancerState.strategy);
+    sessionBindings.clear();
+};
+const getChildrenClientCount = () => {
+    return childrenConnectionState.connections.size;
+};
+const forEachChildrenClient = (callback) => {
+    childrenConnectionState.connections.forEach(callback);
+};
+const getChildrenClientIds = () => {
+    return Array.from(childrenConnectionState.connections.keys());
+};
+const getAllChildrenClients = () => {
+    return new Map(childrenConnectionState.connections);
+};
+const addPlatformClient = (id, ws) => {
+    platformConnectionState = addConnection(platformConnectionState, id, ws);
+    logger.debug({
+        code: 200,
+        message: `平台客户端已添加: ${id}`,
+        data: { totalClients: platformConnectionState.connections.size }
+    });
+};
+const removePlatformClient = (id) => {
+    const existed = getConnection(platformConnectionState, id) !== undefined;
+    if (existed) {
+        platformConnectionState = removeConnection(platformConnectionState, id);
+        logger.debug({
+            code: 200,
+            message: `平台客户端已移除: ${id}`,
+            data: null
+        });
+    }
+    return existed;
+};
+const getPlatformClient = (id) => {
+    return getConnection(platformConnectionState, id);
+};
+const getPlatformClientCount = () => {
+    return platformConnectionState.connections.size;
+};
+const clearPlatformClients = () => {
+    platformConnectionState = clearAllConnections(platformConnectionState);
+};
+const forEachPlatformClient = (callback) => {
+    platformConnectionState.connections.forEach(callback);
+};
+const addFullClient = (id, ws) => {
+    fullConnectionState = addConnection(fullConnectionState, id, ws);
+    logger.debug({
+        code: 200,
+        message: `全接收客户端已添加: ${id}`,
+        data: { totalClients: fullConnectionState.connections.size }
+    });
+};
+const removeFullClient = (id) => {
+    const existed = getConnection(fullConnectionState, id) !== undefined;
+    if (existed) {
+        fullConnectionState = removeConnection(fullConnectionState, id);
+        logger.debug({
+            code: 200,
+            message: `全接收客户端已移除: ${id}`,
+            data: null
+        });
+    }
+    return existed;
+};
+const getFullClient = (id) => {
+    return getConnection(fullConnectionState, id);
+};
+const getFullClientCount = () => {
+    return fullConnectionState.connections.size;
+};
+const clearFullClients = () => {
+    fullConnectionState = clearAllConnections(fullConnectionState);
+};
+const forEachFullClient = (callback) => {
+    fullConnectionState.connections.forEach(callback);
+};
+const getHealthyClients = () => {
+    return getHealthyConnectionIds(childrenConnectionState);
+};
+const selectClientByStrategy = (_sessionId, _key) => {
+    const result = selectConnection(childrenConnectionState, loadBalancerState);
+    if (result.selectedId) {
+        loadBalancerState = result.newBalancerState;
+        return result.selectedId;
+    }
+    return null;
+};
+const bindSessionToClient = (sessionId, key) => {
+    if (sessionBindings.has(sessionId)) {
+        const clientId = sessionBindings.get(sessionId);
+        const ws = getChildrenClient(clientId);
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            return clientId;
+        }
+        else {
+            unbindSession(sessionId);
+        }
+    }
+    const selectedClient = selectClientByStrategy();
+    if (selectedClient) {
+        sessionBindings.set(sessionId, selectedClient);
+        loadBalancerState = incrementBindingCount(loadBalancerState, selectedClient);
+        logger.debug({
+            code: 200,
+            message: `会话已绑定: ${sessionId} -> ${selectedClient}`,
+            data: {
+                strategy: loadBalancerState.strategy,
+                connections: loadBalancerState.bindingCounts.get(selectedClient) || 0
+            }
+        });
+    }
+    return selectedClient;
+};
+const unbindSession = (sessionId) => {
+    const clientId = sessionBindings.get(sessionId);
+    if (clientId) {
+        sessionBindings.delete(sessionId);
+        loadBalancerState = decrementBindingCount(loadBalancerState, clientId);
+        logger.debug({
+            code: 200,
+            message: `会话已解绑: ${sessionId}`,
+            data: {
+                clientId,
+                remainingConnections: loadBalancerState.bindingCounts.get(clientId) || 0
+            }
+        });
+    }
+};
+const setLoadBalanceStrategy = (strategy) => {
+    loadBalancerState = { ...loadBalancerState, strategy, roundRobinIndex: 0 };
+    logger.info(`负载均衡策略已切换: ${strategy}`);
+};
+const getLoadBalanceStats = () => {
+    const connectionStats = getConnectionStats(childrenConnectionState);
+    const balancerStats = getLoadBalancerStats(loadBalancerState);
+    return {
+        totalClients: connectionStats.total,
+        healthyClients: connectionStats.healthy,
+        totalBindings: sessionBindings.size,
+        bindingCounts: balancerStats.bindingCounts,
+        strategy: balancerStats.strategy,
+        uptime: Date.now() - balancerStats.lastUpdate
+    };
+};
+const performHealthCheck = () => {
+    const now = Date.now();
+    const healthCheckPromises = [];
+    forEachChildrenClient((ws, clientId) => {
+        const healthCheckPromise = (async () => {
+            try {
+                if (ws.readyState === WebSocket.OPEN) {
+                    const pingPromise = new Promise((resolve) => {
+                        const timeout = setTimeout(() => resolve(false), 5000);
+                        ws.ping();
+                        ws.once('pong', () => {
+                            clearTimeout(timeout);
+                            resolve(true);
+                        });
+                    });
+                    const isResponding = await pingPromise;
+                    if (!isResponding) {
+                        logger.warn({
+                            code: 503,
+                            message: `客户端健康检查失败: ${clientId}`,
+                            data: { timestamp: now }
+                        });
+                    }
+                }
+                else {
+                    logger.warn({
+                        code: 503,
+                        message: `客户端连接已断开: ${clientId}`,
+                        data: { readyState: ws.readyState }
+                    });
+                }
+            }
+            catch (error) {
+                logger.error({
+                    code: 500,
+                    message: `客户端健康检查异常: ${clientId}`,
+                    data: error
+                });
+            }
+        })();
+        healthCheckPromises.push(healthCheckPromise);
+    });
+    Promise.all(healthCheckPromises).catch(error => {
+        logger.error({
+            code: 500,
+            message: '健康检查批量执行失败',
+            data: error
+        });
+    });
+};
+let healthCheckTimer = null;
+const startHealthCheckTimer = () => {
+    if (healthCheckTimer) {
+        clearInterval(healthCheckTimer);
+    }
+    healthCheckTimer = setInterval(() => {
+        performHealthCheck();
+    }, 30000);
+};
+const stopHealthCheckTimer = () => {
+    if (healthCheckTimer) {
+        clearInterval(healthCheckTimer);
+        healthCheckTimer = null;
+    }
+};
+const destroyLoadBalancer = () => {
+    stopHealthCheckTimer();
+    clearChildrenClients();
+    platformConnectionState = clearAllConnections(platformConnectionState);
+    fullConnectionState = clearAllConnections(fullConnectionState);
+    sessionBindings.clear();
+    loadBalancerState = createLoadBalancerState(loadBalancerState.strategy);
+    logger.info('负载均衡器已清理');
 };
-const timeoutTime = 1000 * 60 * 3;
-const reconnectInterval = 1000 * 6;
-const HEARTBEAT_INTERVAL = 1000 * 18;
 
-export { DEVICE_ID_HEADER, FULL_RECEIVE_HEADER, HEARTBEAT_INTERVAL, USER_AGENT_HEADER, USER_AGENT_HEADER_VALUE_MAP, actionResolves, actionTimeouts, apiResolves, apiTimeouts, childrenBind, childrenClient, deviceId, fullClient, generateUniqueId, platformClient, reconnectInterval, timeoutTime };
+export { actionResolves, actionTimeouts, addChildrenClient, addFullClient, addPlatformClient, apiResolves, apiTimeouts, bindSessionToClient, clearChildrenClients, clearFullClients, clearPlatformClients, destroyLoadBalancer, deviceId, forEachChildrenClient, forEachFullClient, forEachPlatformClient, getAllChildrenClients, getChildrenClient, getChildrenClientCount, getChildrenClientIds, getFullClient, getFullClientCount, getHealthyClients, getLoadBalanceStats, getPlatformClient, getPlatformClientCount, hasChildrenClient, performHealthCheck, reconnectInterval, removeChildrenClient, removeFullClient, removePlatformClient, selectClientByStrategy, setLoadBalanceStrategy, startHealthCheckTimer, stopHealthCheckTimer, timeoutTime, unbindSession };

package/lib/cbp/processor/request-handler.d.ts

@@ -0,0 +1,17 @@
+import { Result } from '../../core';
+type ResolversValue = (value: Result[]) => void;
+export interface RequestHandlerState {
+    resolvers: Map<string, ResolversValue>;
+    timeouts: Map<string, NodeJS.Timeout>;
+    requestType: string;
+    idField: 'actionId' | 'apiId';
+}
+export declare const createRequestHandlerState: (requestType: string, idField: "actionId" | "apiId") => RequestHandlerState;
+export declare const sendRequest: <T>(state: RequestHandlerState, data: T & {
+    DeviceId?: string;
+}) => Promise<Result[]>;
+export declare const handleRequestResponse: (state: RequestHandlerState, requestId: string, results: Result[]) => void;
+export declare const handleRequestTimeout: (state: RequestHandlerState, requestId: string) => void;
+export declare const getPendingRequestCount: (state: RequestHandlerState) => number;
+export declare const destroyRequestHandler: (state: RequestHandlerState) => void;
+export {};

package/lib/cbp/processor/request-handler.js

@@ -0,0 +1,65 @@
+import * as flattedJSON from 'flatted';
+import { ResultCode } from '../../core/variable.js';
+import 'fs';
+import 'path';
+import 'yaml';
+import { createResult } from '../../core/utils.js';
+import { deviceId, timeoutTime } from './config.js';
+import { generateUniqueId } from '../core/constants.js';
+
+const createRequestHandlerState = (requestType, idField) => ({
+    resolvers: new Map(),
+    timeouts: new Map(),
+    requestType,
+    idField
+});
+const sendRequest = (state, data) => {
+    const requestId = generateUniqueId();
+    return new Promise(resolve => {
+        data[state.idField] = requestId;
+        data.DeviceId = deviceId;
+        global.chatbotClient.send(flattedJSON.stringify(data));
+        state.resolvers.set(requestId, resolve);
+        const timeout = setTimeout(() => {
+            handleRequestTimeout(state, requestId);
+        }, timeoutTime);
+        state.timeouts.set(requestId, timeout);
+    });
+};
+const handleRequestResponse = (state, requestId, results) => {
+    const resolver = state.resolvers.get(requestId);
+    const timeout = state.timeouts.get(requestId);
+    if (resolver) {
+        state.resolvers.delete(requestId);
+        if (timeout) {
+            clearTimeout(timeout);
+            state.timeouts.delete(requestId);
+        }
+        resolver(results);
+    }
+};
+const handleRequestTimeout = (state, requestId) => {
+    const resolver = state.resolvers.get(requestId);
+    if (resolver) {
+        state.resolvers.delete(requestId);
+        state.timeouts.delete(requestId);
+        const timeoutResult = createResult(ResultCode.Fail, `${state.requestType}请求超时`, null);
+        resolver([timeoutResult]);
+    }
+};
+const getPendingRequestCount = (state) => {
+    return state.resolvers.size;
+};
+const destroyRequestHandler = (state) => {
+    for (const timeout of state.timeouts.values()) {
+        clearTimeout(timeout);
+    }
+    for (const [_requestId, resolver] of state.resolvers.entries()) {
+        const cancelResult = createResult(ResultCode.FailInternal, `${state.requestType}请求已取消`, null);
+        resolver([cancelResult]);
+    }
+    state.resolvers.clear();
+    state.timeouts.clear();
+};
+
+export { createRequestHandlerState, destroyRequestHandler, getPendingRequestCount, handleRequestResponse, handleRequestTimeout, sendRequest };