oox 0.3.4 → 0.3.6

package/keepalive-connection.js

@@ -1,5 +1,15 @@
 import EventEmitter from 'node:events';
+import { getContext } from './context.js';
+export class KeepAliveConnectionError extends Error {
+    connection;
+    constructor(message, connection) {
+        super(message);
+        this.connection = connection;
+    }
+}
 export class KeepAliveConnection extends EventEmitter {
+    // 是否为注册服务连接
+    isRegistry = false;
     // 连接是否可用
     #enabled = false;
     data;
@@ -49,6 +59,10 @@ export class KeepAliveConnection extends EventEmitter {
         keepAliveConnections.add(this);
         this.enabled = true;
     }
+    disconnect() {
+        this.enabled = false;
+        this.nativeConnection.disconnect();
+    }
 }
 export class KeepAliveConnectionStore {
     #map = new Map();
@@ -91,6 +105,65 @@ export class KeepAliveConnectionStore {
         }
     }
 }
+/**
+ * 添加长连接
+ * @throws {KeepAliveConnectionError} 连接已存在
+ * @param connection
+ */
+export function addKeepAliveConnection(connection) {
+    if (keepAliveConnections.has(connection.data.name, connection.data.id)) {
+        connection.disconnect();
+        throw new KeepAliveConnectionError('Connection already exists', connection);
+    }
+    keepAliveConnections.add(connection);
+}
+export function removeKeepAliveConnection(arg1, arg2) {
+    if (typeof arg1 === 'string') {
+        const connection = keepAliveConnections.get(arg1, arg2);
+        if (connection)
+            connection.disconnect();
+        keepAliveConnections.remove(arg1, arg2);
+        enabledKeepAliveConnections.remove(arg1, arg2);
+    }
+    else {
+        arg1.disconnect();
+        keepAliveConnections.remove(arg1);
+        enabledKeepAliveConnections.remove(arg1);
+    }
+}
+/**
+ * random connection select for default load balance policy
+ * @param name service name
+ * @returns selected connection
+ */
+let loadBalancePolicy = (name) => {
+    const connections = enabledKeepAliveConnections.getConnectionsOfService(name);
+    if (!connections || !connections.size)
+        return null;
+    const arrayConnections = Array.from(connections.values());
+    const index = Math.floor(Math.random() * arrayConnections.length);
+    return arrayConnections[index];
+};
+export function setLoadBalancePolicy(policy) {
+    loadBalancePolicy = policy;
+}
+export async function rpc(arg1, action, params, context) {
+    if (!context || !context.traceId) {
+        context = getContext();
+    }
+    let connection = null;
+    if (arg1 instanceof KeepAliveConnection) {
+        connection = arg1;
+    }
+    else if ('string' === typeof arg1) {
+        connection = loadBalancePolicy(arg1);
+    }
+    else
+        throw new Error(`Unknown rpc arg1<${arg1}>`);
+    if (!connection)
+        throw new Error(`Connection<${arg1}> not found`);
+    return connection.adapter.rpc(connection, action, params, context);
+}
 export const keepAliveConnectionAdapters = new Map();
 export const keepAliveConnections = new KeepAliveConnectionStore();
 export const enabledKeepAliveConnections = new KeepAliveConnectionStore();

package/logger.js

@@ -1,4 +1,5 @@
-import { emit, asyncStore } from './app.js';
+import { emit } from './app.js';
+import { asyncStore } from './context.js';
 export function info(...content) {
     const context = asyncStore.getStore() || null;
     emit('log', Date.now(), context, 'info', content);

package/modules/http/index.js

@@ -1,10 +1,11 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
-import { httpRequest, parseHTTPBody } from './utils.js';
+import { parseHTTPBody } from './utils.js';
 import Router from './router.js';
 import * as oox from '../../index.js';
-import Module, { ModuleConfig } from '../module.js';
-export class HTTPConfig extends ModuleConfig {
+import { Module } from '../module.js';
+export class HTTPConfig {
+    enabled = true;
     // listen port
     port = 0;
     // service path
@@ -80,9 +81,9 @@ export default class HTTPModule extends Module {
         if (ssl.enabled) {
             const fs = await import('node:fs');
             const options = {
-                key: ssl.key ? fs.readFileSync(ssl.key) : null,
-                cert: ssl.cert ? fs.readFileSync(ssl.cert) : null,
-                ca: ssl.ca ? fs.readFileSync(ssl.ca) : null
+                key: ssl.key ? fs.readFileSync(ssl.key) : undefined,
+                cert: ssl.cert ? fs.readFileSync(ssl.cert) : undefined,
+                ca: ssl.ca ? fs.readFileSync(ssl.ca) : undefined
             };
             if (!options.key || !options.cert) {
                 throw new Error('HTTPS enabled but missing key or cert');
@@ -101,16 +102,18 @@ export default class HTTPModule extends Module {
     /**
      * stop http service
      */
-    stop() {
-        if (this.server && this.server.listening)
-            return new Promise((resolve, reject) => {
-                this.server.close(function (error) {
-                    if (error)
-                        reject(error);
-                    else
-                        resolve();
-                });
+    async stop() {
+        const { server } = this;
+        if (!server || !server.listening)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            server.close(function (error) {
+                if (error)
+                    reject(error);
+                else
+                    resolve();
             });
+        });
     }
     /**
      * browser cross origin
@@ -120,9 +123,14 @@ export default class HTTPModule extends Module {
         const origin = this.config.origin;
         const requestOrigin = request.headers.origin;
         if (origin && requestOrigin) {
-            if (origin === '*' ||
-                origin === requestOrigin ||
-                (Array.isArray(origin) && origin.includes(requestOrigin))) {
+            let allow = false;
+            if ('string' === typeof origin) {
+                allow = origin === '*' || new RegExp(origin).test(requestOrigin);
+            }
+            else if (Array.isArray(origin)) {
+                allow = origin.some(item => item === '*' || new RegExp(item).test(requestOrigin));
+            }
+            if (allow) {
                 response.setHeader('Access-Control-Allow-Origin', requestOrigin);
                 response.setHeader('Vary', 'Origin');
             }
@@ -132,7 +140,7 @@ export default class HTTPModule extends Module {
                 return false;
             }
             response.setHeader('Access-Control-Max-Age', 3600);
-            response.setHeader('Access-Control-Allow-Headers', 'x-caller,content-type');
+            response.setHeader('Access-Control-Allow-Headers', 'x-caller,x-token,content-type');
             response.setHeader('Access-Control-Allow-Methods', '*');
         }
         if (request.method === 'OPTIONS') {
@@ -143,9 +151,7 @@ export default class HTTPModule extends Module {
         return true;
     }
     async requestHandler(request, response) {
-        if (!this.cors(request, response))
-            return;
-        const url = new URL(request.url, `http://${request.headers.host || 'localhost'}`);
+        const url = new URL(request.url || '', `http://${request.headers.host || 'localhost'}`);
         const method = request.method || 'GET';
         // 尝试匹配路由
         const matched = this.router.match(method, url.pathname);
@@ -170,6 +176,9 @@ export default class HTTPModule extends Module {
             await this.router.handleRoute(matched.route, matched.params, req, res);
             return;
         }
+        // 内置cors仅处理RPC请求
+        if (!this.cors(request, response))
+            return;
         // 回退到RPC调用
         if (url.pathname === this.config.path) {
             await this.call(request, response);
@@ -199,6 +208,24 @@ export default class HTTPModule extends Module {
      * HTTP-RPC服务器请求监听方法
      */
     async call(request, response) {
+        // global unique id
+        const traceId = String(request.headers['x-trace-id'] || '');
+        // service name, required
+        const caller = String(request.headers['x-caller'] || 'anonymous');
+        // client ip or caller service ip
+        const ip = String(request.headers['x-real-ip'] || request.socket.remoteAddress || '');
+        // startup client ip
+        const sourceIP = String(request.headers['x-source-ip'] || request.socket.remoteAddress || '');
+        // check token
+        const token = String(request.headers['x-token'] || '');
+        const { allow, reason } = oox.checkAllow(ip, caller, token);
+        if (!allow)
+            return this.respond(request, response, {
+                success: false,
+                error: {
+                    message: reason
+                }
+            });
         let callArgs = Object.create(null);
         try {
             callArgs = await this.getCallArgsFromRequest(request);
@@ -212,14 +239,6 @@ export default class HTTPModule extends Module {
                 }
             });
         }
-        // global unique id
-        const traceId = String(request.headers['x-trace-id'] || '');
-        // service name, required
-        const caller = String(request.headers['x-caller'] || 'anonymous');
-        // client ip or caller service ip
-        const ip = String(request.headers['x-ip'] || request.socket.remoteAddress || '');
-        // startup client ip
-        const sourceIP = String(request.headers['x-real-ip'] || '');
         const { action, params = [] } = callArgs;
         const context = oox.genContext({ traceId, caller, sourceIP, ip, callerId: '' });
         const format = await oox.call(action, params, context);
@@ -237,15 +256,15 @@ export default class HTTPModule extends Module {
         try {
             returnsString = JSON.stringify(returns);
         }
-        catch ({ message, stack }) {
+        catch (error) {
             delete returns.body;
             returns.success = false;
             returns.error = {
-                message
+                message: error.message
             };
             if (oox.config.errorStack) {
                 // 返回错误调用栈信息
-                returns.error.stack = stack;
+                returns.error.stack = error.stack;
             }
             returnsString = JSON.stringify(returns);
         }
@@ -253,34 +272,4 @@ export default class HTTPModule extends Module {
         response.setHeader('Content-Length', Buffer.byteLength(returnsString));
         response.end(returnsString);
     }
-    /**
-     * HTTP RPC
-     */
-    async rpc(url, action, params, context) {
-        if (!context || !context.traceId) {
-            context = oox.getContext();
-        }
-        const { traceId, caller, sourceIP } = context;
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-trace-id': String(traceId),
-        };
-        if (caller)
-            headers['x-caller'] = String(caller);
-        if (sourceIP)
-            headers['x-real-ip'] = sourceIP;
-        // headers [ 'x-ip' ] = getIPAddress ( 4 ) [ 0 ]
-        const format = await httpRequest(url, {
-            headers
-        }, JSON.stringify({ action, params }));
-        if ('string' === typeof format)
-            throw new Error(format);
-        const { success, error, body } = format;
-        if (success)
-            return body;
-        else if (error)
-            throw new Error(error.message);
-        else
-            throw new Error('[RPC] Unknown Error');
-    }
 }

package/modules/http/router.js

@@ -84,12 +84,17 @@ export default class Router {
     }
     // 添加路由
     addRoute(method, path, handler, middleware = []) {
-        if (!this.routes.has(method)) {
-            this.routes.set(method, []);
-        }
         // 编译路径为正则表达式，支持路径参数
         const { regex, paramNames } = this.compilePath(path);
-        this.routes.get(method).push({
+        let routes = [];
+        if (this.routes.has(method)) {
+            routes = this.routes.get(method) || [];
+        }
+        else {
+            routes = [];
+            this.routes.set(method, routes);
+        }
+        routes.push({
             path,
             method,
             handler,

package/modules/index.js

@@ -1,86 +1,90 @@
-import Module from './module.js';
 import HTTP from './http/index.js';
 import SocketIO from './socketio/index.js';
-export default class Modules extends Module {
-    /**
-     * the module unique name
-     */
-    name = 'oox:modules';
-    /**
-     * FIFO queue for modules starting
-     */
-    #queue = [];
-    /**
-     * all modules map
-     */
-    #map = new Map();
-    /**
-     * all builtin modules
-     */
-    builtins = {
-        http: new HTTP,
-        socketio: new SocketIO,
-    };
-    constructor() {
-        super();
-        this.add(this.builtins.http);
-        this.add(this.builtins.socketio);
-    }
-    add(module) {
-        if (!module.name || 'string' !== typeof module.name)
-            throw new Error(`Module<${module.name}> has noname`);
-        if (this.#map.has(module.name))
-            throw new Error(`Module<${module.name}> has exists`);
-        this.#map.set(module.name, module);
-        this.#queue.push(module);
-        return this;
-    }
-    get(name) {
-        return this.#map.get(name);
-    }
-    async remove(name) {
-        const module = this.get(name);
-        if (!module)
-            return;
-        await module.stop();
-        const index = this.#queue.indexOf(module);
-        this.#queue.splice(index, 1);
-        this.#map.delete(name);
-    }
-    setConfig(config) {
-        for (const module of this.#queue) {
-            if (module.name in config) {
-                const moduleConfig = config[module.name];
-                if ('boolean' === typeof moduleConfig) {
-                    // eg: http=yes/no
-                    module.setConfig({ enabled: moduleConfig });
-                }
-                else {
-                    module.setConfig(moduleConfig);
-                }
+/**
+ * FIFO queue for modules starting
+ */
+export const queue = [];
+/**
+ * all modules map
+ */
+export const map = new Map();
+/**
+ * add module to modules queue
+ */
+export function add(module) {
+    if (!module.name || 'string' !== typeof module.name)
+        throw new Error(`Module<${module.name}> has noname`);
+    if (map.has(module.name))
+        throw new Error(`Module<${module.name}> has exists`);
+    map.set(module.name, module);
+    queue.push(module);
+}
+/**
+ * get module by name
+ */
+export function get(name) {
+    return map.get(name) || null;
+}
+export async function remove(name) {
+    const module = map.get(name);
+    if (!module)
+        return;
+    await module.stop();
+    const index = queue.indexOf(module);
+    queue.splice(index, 1);
+    map.delete(name);
+}
+/**
+ * set modules config
+ */
+export function setConfig(config) {
+    for (const module of queue) {
+        if (module.name in config) {
+            const moduleConfig = config[module.name];
+            if ('boolean' === typeof moduleConfig) {
+                // eg: http=yes/no
+                module.setConfig({ enabled: moduleConfig });
             }
             else {
-                module.setConfig({ enabled: true });
+                module.setConfig(moduleConfig);
             }
-            config[module.name] = module.getConfig();
         }
+        else {
+            module.setConfig({ enabled: true });
+        }
+        config[module.name] = module.getConfig();
     }
-    async serve() {
-        try {
-            for (const module of this.#queue) {
-                if (module.getConfig().enabled) {
-                    await module.serve();
-                }
+}
+/**
+ * serve modules
+ */
+export async function serve() {
+    try {
+        for (const module of queue) {
+            if (module.getConfig().enabled) {
+                await module.serve();
             }
         }
-        catch (error) {
-            await this.stop();
-            throw error;
-        }
     }
-    async stop() {
-        for (const module of this.#queue) {
-            await module.stop();
-        }
+    catch (error) {
+        await stop();
+        throw error;
+    }
+}
+/**
+ * stop all modules
+ */
+export async function stop() {
+    for (const module of queue) {
+        await module.stop();
     }
 }
+/**
+ * all builtin modules
+ */
+export const builtins = {
+    http: new HTTP,
+    socketio: new SocketIO,
+};
+add(builtins.http);
+add(builtins.socketio);

package/modules/module.js

@@ -1,11 +1,2 @@
-export class ModuleConfig {
-    enabled = true;
-}
-export default class Module {
-    config;
-    name;
-    setConfig(config) { }
-    getConfig() { return this.config; }
-    async serve() { }
-    async stop() { }
+export class Module {
 }

package/modules/socketio/adapter.js

@@ -6,32 +6,43 @@ import { SampleKeepAliveConnectionAdapter } from '../../samples/index.js';
 export default class SocketIOAdapter extends SampleKeepAliveConnectionAdapter {
     name = 'socketio';
     OOXEvent = OOXEvent;
-    nativeEvent = { CONNECT: 'connect', DISCONNECT: 'disconnect', ERROR: 'connect_error' };
-    newConnection(url) {
-        const { id, host, name } = oox.config;
+    newConnection(identify) {
+        const { id, name } = oox.config;
         const headers = {
-            'x-ip': host,
             'x-caller': name,
             'x-caller-id': id,
         };
         let mURL;
-        if ('string' === typeof url) {
-            mURL = genWebSocketURL(url);
+        const connectionData = {
+            name: 'anonymous',
+            id: randomUUID(),
+            adapter: this.name,
+            ip: '',
+            token: ''
+        };
+        if ('string' === typeof identify) {
+            mURL = genWebSocketURL(identify);
+        }
+        else if (identify instanceof URL) {
+            mURL = identify;
+        }
+        else if (identify.url) {
+            // KeepAliveConnectionData
+            Object.assign(connectionData, identify);
+            mURL = new URL(identify.url);
+            if (identify.token) {
+                headers['x-token'] = identify.token;
+            }
         }
         else {
-            mURL = url;
+            throw new Error('identify must be string, URL, or KeepAliveConnectionData');
         }
         const socket = SocketIOClient.io(mURL.origin, {
             extraHeaders: headers,
             path: mURL.pathname,
             autoConnect: false,
         });
-        const connection = new oox.KeepAliveConnection(this, socket, {
-            name: 'anonymous',
-            id: randomUUID(),
-            host: mURL.host,
-            url: mURL
-        });
+        const connection = new oox.KeepAliveConnection(this, socket, connectionData);
         return connection;
     }
 }