oox 0.3.4 → 0.3.5

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() { }
 }

package/modules/socketio/adapter.js

@@ -7,31 +7,43 @@ 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;
     }
 }

package/modules/socketio/server.js

@@ -2,10 +2,11 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { Server } from 'socket.io';
 import * as oox from '../../index.js';
-import { Module, ModuleConfig } from '../../index.js';
+import { Module } from '../../index.js';
 import SocketIOAdapter from './adapter.js';
 import { OOXEvent } from './utils.js';
-export class SocketIOConfig extends ModuleConfig {
+export class SocketIOConfig {
+    enabled = true;
     // listen port
     port = 0;
     // service path
@@ -34,6 +35,10 @@ export default class SocketIOServer extends Module {
     server = null;
     socketServer = null;
     adapter = new SocketIOAdapter();
+    constructor() {
+        super();
+        oox.keepAliveConnectionAdapters.set(this.name, this.adapter);
+    }
     getURL() {
         const { host } = oox.config;
         const { port, path } = this.config;
@@ -53,21 +58,22 @@ export default class SocketIOServer extends Module {
         return this.config;
     }
     async serve() {
-        oox.keepAliveConnectionAdapters.set(this.name, this.adapter);
         await this.stop();
         const { port, ssl } = this.config;
         const isSelfServer = this.#isSelfServer = this.server ? true : false;
-        let server;
+        let server = null;
         if (isSelfServer) {
+            if (!this.server)
+                throw new Error('HTTP Server is not created');
             server = this.server;
         }
         else {
             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');
@@ -88,10 +94,11 @@ export default class SocketIOServer extends Module {
         this.createSocketIOServer();
     }
     async stop() {
-        if (this.socketServer)
-            await new Promise((resolve, reject) => this.socketServer.close(error => error ? reject(error) : resolve()));
+        const { server, socketServer } = this;
+        if (socketServer)
+            await new Promise((resolve, reject) => socketServer.close(error => error ? reject(error) : resolve()));
         if (this.#isSelfServer)
-            await new Promise((resolve, reject) => this.server.listening && this.server.close(error => error ? reject(error) : resolve()));
+            await new Promise((resolve, reject) => server?.close(error => error ? reject(error) : resolve()));
     }
     genSocketIOServerOptions() {
         const options = {
@@ -127,7 +134,10 @@ export default class SocketIOServer extends Module {
         return options;
     }
     createSocketIOServer() {
-        const socketServer = this.socketServer = new Server(this.server, this.genSocketIOServerOptions());
+        const { server } = this;
+        if (!server)
+            throw new Error('HTTP Server is not created');
+        const socketServer = this.socketServer = new Server(server, this.genSocketIOServerOptions());
         socketServer.on('connection', async (socket) => {
             try {
                 this.serverOnSocketConnection(socket);
@@ -145,22 +155,30 @@ export default class SocketIOServer extends Module {
         const headers = socket.handshake.headers;
         const callerId = String(headers['x-caller-id'] || '') || socket.id;
         // client ip or caller service ip
-        const ip = String(headers['x-real-ip'] || headers['x-ip'] || socket.handshake.address);
+        const ip = String(headers['x-real-ip'] || socket.handshake.address);
         // service name
         const caller = String(headers['x-caller'] || 'anonymous');
+        const token = String(headers['x-token'] || '');
+        // check token
+        const { allow, reason } = oox.checkAllow(ip, caller, token);
+        if (!allow) {
+            socket.send(reason).disconnect(true);
+            return;
+        }
         const connection = new oox.KeepAliveConnection(this.adapter, socket, {
-            host: ip,
+            ip,
             name: caller,
             id: callerId,
+            token,
         });
         oox.addKeepAliveConnection(connection);
         this.bindServerConnectionEvents(connection);
         this.adapter.bindCall(connection);
-        connection.enabled = true;
         socket.emit(OOXEvent.READY, {
             id: oox.config.id,
             name: oox.config.name
         });
+        connection.enabled = true;
     }
     /**
      * 绑定服务器连接事件
@@ -168,7 +186,7 @@ export default class SocketIOServer extends Module {
      */
     bindServerConnectionEvents(connection) {
         const socket = connection.nativeConnection;
-        socket.on(OOXEvent.SYNC_CONNECTIONS, async (fn) => {
+        socket.on(OOXEvent.REGISTRY_SYNC_CONNECTIONS, async (fn) => {
             if ('function' !== typeof fn)
                 return;
             oox.registry.onSyncConnections(connection, {}, fn);

package/modules/socketio/utils.js

@@ -3,7 +3,9 @@ export var OOXEvent;
     OOXEvent["READY"] = "oox:ready";
     OOXEvent["ENABLED"] = "oox:enabled";
     OOXEvent["DISABLED"] = "oox:disabled";
-    OOXEvent["SYNC_CONNECTIONS"] = "oox:sync_connections";
+    OOXEvent["REGISTRY_SYNC_CONNECTIONS"] = "oox:registry:sync_connections";
+    OOXEvent["REGISTRY_SUBSCRIBE"] = "oox:registry:subscribe";
+    OOXEvent["REGISTRY_NOTIFY"] = "oox:registry:notify";
 })(OOXEvent || (OOXEvent = {}));
 export function isWebSocketURL(url) {
     if ('string' === typeof url) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.4",
+    "version": "0.3.5",
     "description": "OOX Service Engine",
     "keywords": [
         "http",
@@ -10,7 +10,9 @@
         "framework",
         "microservice",
         "distributed",
-        "tracing"
+        "tracing",
+        "service-discovery",
+        "load-balancing"
     ],
     "type": "module",
     "main": "./index.js",
@@ -23,14 +25,16 @@
         },
         "./loader": "./bin/loader.mjs",
         "./cli": "./bin/cli.js",
-        "./samples": "./samples/index.js",
-        "./samples/types": "./types/samples/index.d.ts"
+        "./samples": {
+            "types": "./types/samples/index.d.ts",
+            "default": "./samples/index.js"
+        }
     },
     "bin": {
         "oox": "./bin/cli.js"
     },
     "author": "lipingruan",
-    "homepage": "https://github.com/lipingruan/oox",
+    "homepage": "https://gitee.com/lipingruan/oox",
     "license": "MIT",
     "dependencies": {
         "chalk": "^5.6.2",