oox 0.3.0-beta6 → 0.3.0-beta9

package/app.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execute = exports.call = exports.on = exports.getMethods = exports.setMethods = exports.sourceKVMethods = exports.kvMethods = exports.eventHub = exports.asyncStore = exports.Context = exports.logger = void 0;
+exports.execute = exports.call = exports.emit = exports.off = exports.once = exports.on = exports.getMethods = exports.setMethods = exports.sourceKVMethods = exports.kvMethods = exports.eventHub = exports.asyncStore = exports.Context = exports.logger = void 0;
 const node_events_1 = require("node:events");
 const node_async_hooks_1 = require("node:async_hooks");
 const utils_1 = require("./utils");
-// import { wrappedActions, actionMiddlewares, middlewares } from './middleware'
 exports.logger = require("./logger");
 class Context {
     // 请求溯源ID
@@ -34,9 +33,21 @@ function getMethods() {
 }
 exports.getMethods = getMethods;
 function on(event, listener) {
-    return exports.eventHub.on(event, listener);
+    exports.eventHub.on(event, listener);
 }
 exports.on = on;
+function once(event, listener) {
+    exports.eventHub.once(event, listener);
+}
+exports.once = once;
+function off(event, listener) {
+    exports.eventHub.off(event, listener);
+}
+exports.off = off;
+function emit(event, ...args) {
+    return exports.eventHub.emit(event, ...args);
+}
+exports.emit = emit;
 /**
  * Call an Function on RPC server
  * @param action
@@ -126,18 +137,6 @@ async function execute(action, params, context) {
     // ============================= PROXY END =============================
     // make sure target action execute after all proxies
     if (target) {
-        /*
-        const sourceMethod = wrappedActions.get ( action )
-
-        const middlewareNames = actionMiddlewares.get ( sourceMethod )
-
-        if ( middlewareNames && middlewareNames.length ) for ( const name of middlewareNames ) {
-
-            const middleware = middlewares.get ( name )
-
-            await middleware ( action, params, context )
-        }
-        */
         return await target(...params);
     }
 }

package/bin/configurer.js

@@ -25,17 +25,30 @@ function mergeFlatEnv(env) {
         }
     }
 }
-function configure() {
-    let env = Object.create(null);
-    const defaultEnvPath = argv.getEnvArg('default-env');
-    if (defaultEnvPath && fs.existsSync(defaultEnvPath)) {
-        Object.assign(env, require(path.resolve(defaultEnvPath)));
+async function readEnvFile(filePath) {
+    let env = {};
+    if (filePath && fs.existsSync(filePath)) {
+        if (filePath.endsWith('.json')) {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            env = JSON.parse(raw);
+        }
+        else {
+            const finalPath = path.resolve(filePath).replace(/\\/g, '/');
+            env = await eval(`import('file://${finalPath}')`);
+        }
     }
-    const envPath = argv.getEnvArg('env');
-    if (envPath && fs.existsSync(envPath)) {
-        Object.assign(env, require(path.resolve(envPath)));
+    else {
+        throw new Error('Env file not found: ' + filePath);
     }
-    Object.assign(env, argv.getAllEnvArgs());
+    return env.default || env;
+}
+async function configure() {
+    const env = Object.create(null);
+    const defaultEnvPath = argv.getEnvArg('default-env');
+    const targetEnvPath = argv.getEnvArg('env');
+    const defaultEnv = defaultEnvPath ? await readEnvFile(defaultEnvPath) : {};
+    const targetEnv = targetEnvPath ? await readEnvFile(targetEnvPath) : {};
+    Object.assign(env, defaultEnv, targetEnv, argv.getAllEnvArgs());
     mergeFlatEnv(env);
     if ('string' === typeof env.ignore)
         env.ignore = env.ignore.split(',');

package/bin/starter.js

@@ -7,10 +7,6 @@ const oox = require("../index");
 const proxyer_1 = require("./proxyer");
 const configurer_1 = require("./configurer");
 const register_1 = require("./register");
-const module_socketio_1 = require("@oox/module-socketio");
-// preload modules
-const socketio = new module_socketio_1.default();
-oox.modules.add(socketio);
 function getEntryFile(env) {
     const args = process.argv.slice(2);
     var [entryFilename] = args.filter(arg => !arg.includes('=') && arg.endsWith('.js'));
@@ -32,7 +28,7 @@ async function loadEntry(name, entryPath) {
 }
 async function startup() {
     // 加载环境变量
-    const env = (0, configurer_1.configure)();
+    const env = await (0, configurer_1.configure)();
     Object.assign(oox.config, env);
     // 获取服务入口地址
     const entryFile = getEntryFile(env);
@@ -51,9 +47,11 @@ async function startup() {
     await loadEntry(entryFile.name, entryFile.path);
     // 模块配置
     oox.modules.setConfig(oox.config);
-    const httpConfig = oox.modules.builtins.http.config, socketioConfig = socketio.config;
+    oox.emit('app:configured');
+    const { http: { config: httpConfig }, socketio: { config: socketioConfig } } = oox.modules.builtins;
     // 服务启动
     await oox.serve();
+    oox.emit('app:served');
     console.log();
     console.log('Service', (0, chalk_1.bold) `${oox.config.name}`, 'running.');
     if (!httpConfig.disabled)

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rpc = exports.removeKeepAliveConnection = exports.addKeepAliveConnection = exports.getKeepAliveConnection = exports.getKeepAliveConnections = exports.keepAliveConnections = exports.RPCKeepAliveConnection = exports.stop = exports.serve = exports.getContext = exports.genContext = exports.genTraceId = exports.setGenTraceIdFunction = exports.config = exports.Config = exports.Context = exports.on = exports.execute = exports.call = exports.sourceKVMethods = exports.kvMethods = exports.getMethods = exports.setMethods = exports.asyncStore = exports.modules = exports.ModuleConfig = exports.Module = void 0;
+exports.rpc = exports.setLoadBalancePolicy = exports.removeKeepAliveConnection = exports.addKeepAliveConnection = exports.getKeepAliveConnection = exports.getKeepAliveConnections = exports.keepAliveConnections = exports.RPCKeepAliveConnection = exports.stop = exports.serve = exports.getContext = exports.genContext = exports.genTraceId = exports.setGenTraceIdFunction = exports.config = exports.Config = exports.Context = exports.emit = exports.off = exports.once = exports.on = exports.logger = exports.execute = exports.call = exports.sourceKVMethods = exports.kvMethods = exports.getMethods = exports.setMethods = exports.asyncStore = exports.modules = exports.ModuleConfig = exports.Module = void 0;
 const node_crypto_1 = require("node:crypto");
 const app = require("./app");
 const utils_1 = require("./utils");
@@ -9,7 +9,7 @@ exports.Module = module_1.default;
 Object.defineProperty(exports, "ModuleConfig", { enumerable: true, get: function () { return module_1.ModuleConfig; } });
 const modules_1 = require("./modules");
 exports.modules = new modules_1.default;
-exports.asyncStore = app.asyncStore, exports.setMethods = app.setMethods, exports.getMethods = app.getMethods, exports.kvMethods = app.kvMethods, exports.sourceKVMethods = app.sourceKVMethods, exports.call = app.call, exports.execute = app.execute, exports.on = app.on;
+exports.asyncStore = app.asyncStore, exports.setMethods = app.setMethods, exports.getMethods = app.getMethods, exports.kvMethods = app.kvMethods, exports.sourceKVMethods = app.sourceKVMethods, exports.call = app.call, exports.execute = app.execute, exports.logger = app.logger, exports.on = app.on, exports.once = app.once, exports.off = app.off, exports.emit = app.emit;
 class Context extends app.Context {
     // 请求溯源IP
     sourceIP = '';
@@ -24,7 +24,7 @@ class Context extends app.Context {
     toJSON() {
         const context = Object.assign({}, this);
         delete context.connection;
-        return JSON.stringify(context);
+        return context;
     }
 }
 exports.Context = Context;
@@ -131,6 +131,23 @@ function removeKeepAliveConnection(name, id) {
     }
 }
 exports.removeKeepAliveConnection = removeKeepAliveConnection;
+/**
+ * random connection select for default load balance policy
+ * @param name service name
+ * @returns selected connection
+ */
+let loadBalancePolicy = (name) => {
+    const connections = exports.keepAliveConnections.get(name);
+    if (!connections || !connections.size)
+        return null;
+    const arrayConnections = Array.from(connections.values());
+    const index = Math.floor(Math.random() * arrayConnections.length);
+    return arrayConnections[index];
+};
+function setLoadBalancePolicy(policy) {
+    loadBalancePolicy = policy;
+}
+exports.setLoadBalancePolicy = setLoadBalancePolicy;
 async function rpc(arg1, action, params, context) {
     if (!context || !context.traceId) {
         context = getContext();
@@ -140,10 +157,9 @@ async function rpc(arg1, action, params, context) {
         connection = arg1;
     }
     else if ('string' === typeof arg1) {
-        const connections = exports.keepAliveConnections.get(arg1);
-        if (!connections || !connections.size)
+        connection = loadBalancePolicy(arg1);
+        if (!connection)
             throw new Error(`Connection<${arg1}> not found`);
-        connection = connections.values().next().value;
     }
     else
         throw new Error(`Unknown rpc arg1<${arg1}>`);

package/logger.js

@@ -1,20 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.error = exports.warning = exports.info = void 0;
+exports.trace = exports.error = exports.warn = exports.info = void 0;
 const app_1 = require("./app");
-function log(tag, ...msgs) {
-    const context = app_1.asyncStore.getStore();
-    app_1.eventHub.emit('log', context, { tag, msgs });
-}
 function info(...msgs) {
-    return log('info', ...msgs);
+    const context = app_1.asyncStore.getStore();
+    if (context)
+        app_1.eventHub.emit('log', context, 'info', msgs);
+    else
+        console.info('[INFO]', ...msgs);
 }
 exports.info = info;
-function warning(...msgs) {
-    return log('warning', ...msgs);
+function warn(...msgs) {
+    const context = app_1.asyncStore.getStore();
+    if (context)
+        app_1.eventHub.emit('log', context, 'warn', msgs);
+    else
+        console.warn('[WARN]', ...msgs);
 }
-exports.warning = warning;
+exports.warn = warn;
 function error(...msgs) {
-    return log('error', ...msgs);
+    const context = app_1.asyncStore.getStore();
+    if (context)
+        app_1.eventHub.emit('log', context, 'error', msgs);
+    else
+        console.error('[ERROR]', ...msgs);
 }
 exports.error = error;
+function trace(name) {
+    const context = app_1.asyncStore.getStore();
+    const trace = { stack: '' };
+    Error.captureStackTrace(trace);
+    const stack = trace.stack
+        .replace(/.*\n.*logger.js.*\n/, name || 'Untitle\n');
+    if (context)
+        app_1.eventHub.emit('log', context, 'trace', stack);
+    else
+        console.log('[TRACE]', stack);
+}
+exports.trace = trace;

package/modules/http/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTTPConfig = void 0;
 const http = require("node:http");
+const node_querystring_1 = require("node:querystring");
 const utils_1 = require("./utils");
 const oox = require("../../index");
 const module_1 = require("../module");
@@ -104,7 +105,12 @@ class HTTPModule extends module_1.default {
             return;
         let body = Object.create(null);
         try {
-            body = await (0, utils_1.parseHTTPBody)(request);
+            if ('GET' === request.method) {
+                body = (0, node_querystring_1.parse)(request.url.split('?').pop());
+            }
+            else {
+                body = await (0, utils_1.parseHTTPBody)(request);
+            }
             if (!body || 'object' !== typeof body)
                 throw new Error('Content Invalid');
         }
@@ -125,7 +131,7 @@ class HTTPModule extends module_1.default {
         const ip = String(request.headers['x-ip'] || request.socket.remoteAddress || '');
         // startup client ip
         const sourceIP = String(request.headers['x-real-ip'] || '');
-        const { action, params = [] } = body;
+        const { action = 'index', params = [] } = body;
         const context = oox.genContext({ traceId, caller, sourceIP, ip, callerId: '' });
         const format = await oox.call(action, params, context);
         this.respond(request, response, format);

package/modules/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const module_1 = require("./module");
 const http_1 = require("./http");
+const socketio_1 = require("./socketio");
 class Modules extends module_1.default {
     /**
      * the module unique name
@@ -20,10 +21,12 @@ class Modules extends module_1.default {
      */
     builtins = {
         http: new http_1.default,
+        socketio: new socketio_1.default,
     };
     constructor() {
         super();
         this.add(this.builtins.http);
+        this.add(this.builtins.socketio);
     }
     add(module) {
         if (!module.name || 'string' !== typeof module.name)

package/modules/socketio/client.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SocketIOClient = require("socket.io-client");
+const socket_1 = require("./socket");
+const server_1 = require("./server");
+const oox = require("../../index");
+class SocketIOCore extends server_1.default {
+    /**
+     * connect to <SocketIO RPC> service
+     */
+    async connect(url) {
+        let socket = socket_1.sockets.get(url);
+        // 已经连接的直接返回
+        if (socket) {
+            try {
+                await this.clientWaitConnection(socket);
+            }
+            catch (error) {
+                this.clientOnSocketDisconnect(socket, error.message);
+                throw error;
+            }
+            return socket;
+        }
+        const headers = {
+            'x-caller': oox.config.name
+        };
+        const { host } = oox.config;
+        const { port, path } = this.config;
+        headers['x-ip'] = host;
+        headers['x-caller-id'] = `ws://${host}:${port}${path}`;
+        // create socket handler
+        const mURL = new URL(url);
+        socket = SocketIOClient.io(mURL.origin, {
+            extraHeaders: headers,
+            path: mURL.pathname
+        });
+        socket.data = { name: 'anonymous', connected: false, id: url, host: mURL.host };
+        socket_1.sockets.set(url, socket);
+        try {
+            await this.clientWaitConnection(socket);
+        }
+        catch (error) {
+            this.clientOnSocketDisconnect(socket, error);
+            throw error;
+        }
+        return socket;
+    }
+    /**
+     * 客户端Socket连接事件
+     */
+    clientOnSocketConnection(socket) {
+        socket.data.connected = true;
+        socket.once('disconnect', reason => this.clientOnSocketDisconnect(socket, reason));
+        this.clientOnConnection(socket);
+    }
+    clientOnDisconnect(socket, reason) { }
+    clientOnConnection(socket) { }
+    /**
+     * 客户端Socket断开事件
+     * @param {Socket} socket
+     */
+    clientOnSocketDisconnect(socket, reason) {
+        socket.data.connected = false;
+        socket.disconnect();
+        socket_1.sockets.delete(socket.data.id);
+        this.clientOnDisconnect(socket, reason);
+    }
+    /**
+     * 等待socket连接
+     */
+    async clientWaitConnection(socket) {
+        if (socket.data.connected)
+            return;
+        if (socket.connect)
+            socket.connect();
+        try {
+            await new Promise((resolve, reject) => {
+                const onError = (reason) => {
+                    socket.offAny(onError);
+                    const message = 'string' === typeof reason ? reason : reason instanceof Error ? reason.message : 'connect error';
+                    reject(new Error(message));
+                };
+                socket.once('disconnect', onError);
+                socket.once('connect_error', onError);
+                socket.once('connect_timeout', onError);
+                socket.once('reconnect_error', onError);
+                socket.once('reconnect_failed', onError);
+                socket.once('oox_connected', ({ name }) => {
+                    socket.offAny(onError);
+                    socket.data.name = name;
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+        this.clientOnSocketConnection(socket);
+    }
+}
+exports.default = SocketIOCore;

package/modules/socketio/index.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sockets = void 0;
+const path = require("node:path");
+const client_1 = require("./client");
+const oox = require("../../index");
+const index_1 = require("../../index");
+const socket_1 = require("./socket");
+Object.defineProperty(exports, "sockets", { enumerable: true, get: function () { return socket_1.sockets; } });
+class SocketIOModule extends client_1.default {
+    sockets = socket_1.sockets;
+    async serve() {
+        await this.stop();
+        const _http = oox.modules.builtins.http;
+        const httpConfig = _http.getConfig(), config = this.getConfig();
+        let isShareServer = false;
+        // 都没设置端口
+        isShareServer = !httpConfig.port && !config.port;
+        // 都设置相同端口
+        isShareServer = isShareServer || httpConfig.port === config.port;
+        // http 模块未被禁用
+        isShareServer = isShareServer && !httpConfig.disabled;
+        if (isShareServer) {
+            config.path = path.posix.join(httpConfig.path, config.path);
+            this.server = _http.server;
+        }
+        await super.serve();
+    }
+    onSyncConnection(socket) {
+        const mSockets = Array.from(socket_1.sockets.values())
+            .filter(s => s !== socket &&
+            s.data.name !== socket.data.name &&
+            s.data.id.startsWith('ws://'));
+        return mSockets.map(s => s.data);
+    }
+    serverOnDisconnect(socket, reason) {
+        super.serverOnDisconnect(socket, reason);
+        (0, index_1.removeKeepAliveConnection)(socket.data.name, socket.data.id);
+    }
+    clientOnDisconnect(socket, reason) {
+        super.clientOnDisconnect(socket, reason);
+        (0, index_1.removeKeepAliveConnection)(socket.data.name, socket.data.id);
+    }
+    /**
+     *
+     * @param socket 是由哪个通道发送过来的
+     * @param connectionDatas
+     */
+    clientOnSyncConnection(socket, connectionDatas) {
+        for (const data of connectionDatas)
+            if (!socket_1.sockets.has(data.id))
+                this.connect(data.id).catch((error) => console.error(error));
+    }
+    onFetchActions(socket, search) {
+        const data = [];
+        for (const key of oox.kvMethods.keys())
+            if (!key.endsWith('_proxy') && key.includes(search))
+                data.push(key);
+        return data;
+    }
+    fetchActions(id, search = '') {
+        let socket = socket_1.sockets.get(id);
+        if (!socket) {
+            const connections = (0, index_1.getKeepAliveConnections)(id);
+            if (!connections || !connections.size)
+                throw new Error(`Unknown service identify<${id}>`);
+            id = connections.keys().next().value;
+            socket = socket_1.sockets.get(id);
+        }
+        if (!socket)
+            throw new Error(`Unknown service identify<${id}>`);
+        return this.emit(socket.data.id, 'fetchActions', [search]);
+    }
+    onConnection(socket) {
+        const { id, name, host } = socket.data;
+        const connection = new index_1.RPCKeepAliveConnection(this, id, socket.data);
+        (0, index_1.addKeepAliveConnection)(connection);
+        const connectionContext = {
+            sourceIP: '',
+            ip: host,
+            caller: name,
+            callerId: id,
+            connection
+        };
+        socket.on('fetchActions', async (search, fn) => {
+            if ('function' !== typeof fn)
+                return;
+            const data = await this.onFetchActions(socket, search);
+            fn(data);
+        });
+        socket.on('call', async (action, params, context, callback) => {
+            if ('object' !== typeof context)
+                context = oox.genContext(connectionContext);
+            else
+                context = oox.genContext(Object.assign(context, connectionContext));
+            this.call(action, params, context, callback);
+        });
+    }
+    /**
+     *
+     * @param {Socket} socket
+     */
+    serverOnConnection(socket) {
+        super.serverOnConnection(socket);
+        socket.setMaxListeners(0);
+        socket.on('syncConnection', async (fn) => {
+            if ('function' !== typeof fn)
+                return;
+            const data = this.onSyncConnection(socket);
+            fn(data);
+        });
+        this.onConnection(socket);
+    }
+    async call(action, params, context, callback) {
+        const returns = await oox.call(action, params, context);
+        'function' === typeof callback && callback(returns);
+        return returns;
+    }
+    clientOnConnection(socket) {
+        super.clientOnConnection(socket);
+        socket.emit('syncConnection', (socketDatas) => this.clientOnSyncConnection(socket, socketDatas));
+        this.onConnection(socket);
+    }
+    /**
+     * socketio emit
+     */
+    async emit(url, action, params) {
+        let socket = null;
+        try {
+            socket = await this.connect(url);
+        }
+        catch (error) {
+            // try again
+            socket = await this.connect(url);
+        }
+        try {
+            return await new Promise((resolve, reject) => {
+                const onError = (reason) => {
+                    const message = 'string' === typeof reason ? reason : reason instanceof Error ? reason.message : 'connect error';
+                    reject(new Error(message));
+                };
+                // RPC 执行时中断连接
+                socket.once('disconnect', onError);
+                socket.emit(action, ...params, (returns) => {
+                    socket.off('disconnect', onError);
+                    resolve(returns);
+                });
+            });
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+    }
+    /**
+     * RPC
+     */
+    async rpc(url, action, params, context) {
+        if (!context || !context.traceId) {
+            context = oox.getContext();
+        }
+        const { error, body } = await this.emit(url, 'call', [action, params, context]);
+        if (error)
+            throw new Error(error.message);
+        else
+            return body;
+    }
+}
+exports.default = SocketIOModule;

package/modules/socketio/server.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIOConfig = void 0;
+const http = require("node:http");
+const socket_io_1 = require("socket.io");
+const oox = require("../../index");
+const index_1 = require("../../index");
+const socket_1 = require("./socket");
+class SocketIOConfig extends index_1.ModuleConfig {
+    // listen port
+    port = 0;
+    // service path
+    path = '/socket.io';
+    // browser cross origin
+    origin = '';
+}
+exports.SocketIOConfig = SocketIOConfig;
+class SocketIOServer extends index_1.Module {
+    name = 'socketio';
+    config = new SocketIOConfig;
+    /**
+     * means this.server created by myself<SocketIOServer>
+     */
+    #isSelfServer = false;
+    server = null;
+    socketServer = null;
+    setConfig(config) {
+        Object.assign(this.config, config);
+        if (!config.hasOwnProperty('port')) {
+            this.config.port = oox.config.port;
+        }
+        if (!config.hasOwnProperty('origin')) {
+            this.config.origin = oox.config.origin;
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+    async serve() {
+        await this.stop();
+        const port = this.config.port;
+        const isSelfServer = this.#isSelfServer = this.server ? true : false;
+        const server = this.server = isSelfServer ? this.server :
+            http.createServer((request, response) => response.end('No HTTP Gateway'));
+        if (!server.listening)
+            server.listen(port);
+        const address = server.address();
+        if (!address || 'object' !== typeof address)
+            throw new Error('Cannot read socket.io server port');
+        this.config.port = address.port;
+        this.createSocketIOServer();
+    }
+    async stop() {
+        if (this.socketServer)
+            await new Promise((resolve, reject) => this.socketServer.close(error => error ? reject(error) : resolve()));
+        if (this.#isSelfServer)
+            await new Promise((resolve, reject) => this.server.close(error => error ? reject(error) : resolve()));
+    }
+    genSocketIOServerOptions() {
+        const options = {
+            /**
+             * name of the path to capture
+             * @default "/socket.io"
+             */
+            path: this.config.path,
+            /**
+             * how many ms before a client without namespace is closed
+             * @default 45000
+             */
+            connectTimeout: 5000,
+            /**
+             * how many ms without a pong packet to consider the connection closed
+             * @default 5000
+             */
+            pingTimeout: 2000,
+            /**
+             * how many ms before sending a new ping packet
+             * @default 25000
+             */
+            pingInterval: 10000,
+            /**
+             * how many bytes or characters a message can be, before closing the session (to avoid DoS).
+             * @default 1e5 (100 KB)
+             */
+            maxHttpBufferSize: 1e5
+        };
+        const { origin } = this.config;
+        if (origin)
+            options.cors = { origin };
+        return options;
+    }
+    createSocketIOServer() {
+        const socketServer = this.socketServer = new socket_io_1.Server(this.server, this.genSocketIOServerOptions());
+        socketServer.on('connection', async (socket) => {
+            try {
+                this.serverOnSocketConnection(socket);
+            }
+            catch (error) {
+                socket.send(error.message).disconnect(true);
+            }
+        });
+    }
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket) {
+        const headers = socket.handshake.headers;
+        const callerId = String(headers['x-caller-id'] || '') || socket.id;
+        // 已经存在相同的连接
+        if (socket_1.sockets.has(callerId))
+            throw new Error('Connection Exists');
+        // client ip or caller service ip
+        const ip = String(headers['x-real-ip'] || headers['x-ip'] || socket.handshake.address);
+        // service name
+        const caller = String(headers['x-caller'] || 'anonymous');
+        socket.data = { connected: true, host: ip, name: caller, id: callerId };
+        // 保存 callerId 与 socket 对应关系
+        socket_1.sockets.set(callerId, socket);
+        socket.on('disconnect', reason => this.serverOnSocketDisconnect(socket, reason));
+        socket.emit('oox_connected', { name: oox.config.name });
+        this.serverOnConnection(socket);
+    }
+    serverOnConnection(socket) { }
+    /**
+     * 服务端Socket断开事件
+     * @param {Socket} socket
+     * @param {Error} reason
+     */
+    serverOnSocketDisconnect(socket, reason) {
+        socket.data.connected = false;
+        socket_1.sockets.delete(socket.data.id);
+        this.serverOnDisconnect(socket, reason);
+    }
+    serverOnDisconnect(socket, reason) { }
+}
+exports.default = SocketIOServer;

package/modules/socketio/socket.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sockets = void 0;
+exports.sockets = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.0-beta6",
+    "version": "0.3.0-beta9",
     "description": "Graceful NodeJS distributed application solution",
     "keywords": [
         "http",
@@ -29,8 +29,9 @@
     "homepage": "https://github.com/lipingruan/oox",
     "license": "MIT",
     "dependencies": {
-        "@oox/module-socketio": "../oox-module-socketio/dist/",
-        "chalk": "^4.1.0"
+        "chalk": "^4.1.0",
+        "socket.io": "^4.4.0",
+        "socket.io-client": "^4.4.0"
     },
     "engines": {
         "node": ">=12.0.0"

package/types/app.d.ts

@@ -25,10 +25,21 @@ export declare const kvMethods: Map<string, Function>;
 export declare const sourceKVMethods: Map<string, Function>;
 export declare function setMethods(methods: any): void;
 export declare function getMethods(): any;
+export declare function on(event: 'app:configured' | 'app:served' | 'app:stopped', listener: () => void): void;
 export declare function on(event: 'request', listener: (action: string, params: any[], context: Context) => void): void;
 export declare function on(event: 'success', listener: (action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
 export declare function on(event: 'fail', listener: (action: string, params: any[], context: Context, error: Error) => void): void;
-export declare function on(event: 'log', listener: (context: Context, ...msgs: any[]) => void): void;
+export declare function on(event: 'log', listener: (context: Context, tag: string, msgs: any[]) => void): void;
+export declare function on(event: string, listener: (...args: any[]) => void): void;
+export declare function once(event: 'app:configured' | 'app:served' | 'app:stopped', listener: (...args: any[]) => void): void;
+export declare function once(event: 'request', listener: (action: string, params: any[], context: Context) => void): void;
+export declare function once(event: 'success', listener: (action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
+export declare function once(event: 'fail', listener: (action: string, params: any[], context: Context, error: Error) => void): void;
+export declare function once(event: 'log', listener: (context: Context, tag: string, msgs: any[]) => void): void;
+export declare function once(event: string, listener: (...args: any[]) => void): void;
+export declare function off(event: 'app:configured' | 'app:served' | 'app:stopped' | 'request' | 'success' | 'fail' | 'log', listener: (...args: any[]) => void): void;
+export declare function off(event: string, listener: (...args: any[]) => void): void;
+export declare function emit(event: string, ...args: any[]): boolean;
 /**
  * Call an Function on RPC server
  * @param action

package/types/bin/configurer.d.ts

@@ -1 +1 @@
-export declare function configure(): any;
+export declare function configure(): Promise<any>;

package/types/index.d.ts

@@ -5,14 +5,14 @@ import Modules from './modules';
 export { ReturnsBody } from './app';
 export { Module, ModuleConfig };
 export declare const modules: Modules;
-export declare const asyncStore: import("async_hooks").AsyncLocalStorage<app.Context>, setMethods: typeof app.setMethods, getMethods: typeof app.getMethods, kvMethods: Map<string, Function>, sourceKVMethods: Map<string, Function>, call: typeof app.call, execute: typeof app.execute, on: typeof app.on;
+export declare const asyncStore: import("async_hooks").AsyncLocalStorage<app.Context>, setMethods: typeof app.setMethods, getMethods: typeof app.getMethods, kvMethods: Map<string, Function>, sourceKVMethods: Map<string, Function>, call: typeof app.call, execute: typeof app.execute, logger: typeof app.logger, on: typeof app.on, once: typeof app.once, off: typeof app.off, emit: typeof app.emit;
 export declare class Context extends app.Context {
     sourceIP: string;
     ip: string;
     caller: string;
     callerId: string;
     connection?: RPCKeepAliveConnection;
-    toJSON?(): string;
+    toJSON?(): {} & this;
 }
 export declare class Config {
     [x: string]: any;
@@ -71,5 +71,6 @@ export declare function getKeepAliveConnection(name: string, id: string): RPCKee
 export declare function addKeepAliveConnection(connection: RPCKeepAliveConnection): void;
 export declare function removeKeepAliveConnection(connection: RPCKeepAliveConnection): void;
 export declare function removeKeepAliveConnection(name: string, id: string): void;
+export declare function setLoadBalancePolicy(policy: (name: string) => RPCKeepAliveConnection): void;
 export declare function rpc(appName: string, action: string, params: any[], context?: Context): Promise<any>;
 export declare function rpc(connection: RPCKeepAliveConnection, action: string, params: any[], context?: Context): Promise<any>;

package/types/logger.d.ts

@@ -1,3 +1,4 @@
 export declare function info(...msgs: any[]): void;
-export declare function warning(...msgs: any[]): void;
+export declare function warn(...msgs: any[]): void;
 export declare function error(...msgs: any[]): void;
+export declare function trace(name?: string): void;

package/types/modules/http/utils.d.ts

@@ -2,11 +2,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import * as http from 'node:http';
-import * as stream from 'node:stream';
+import { Readable } from 'node:stream';
 /**
  * Stream => Buffer
  */
-export declare function stream2buffer(stream: stream.Readable, totalLength?: number): Promise<Buffer>;
+export declare function stream2buffer(stream: Readable, totalLength?: number): Promise<Buffer>;
 /**
  * Request => JSONObject
  */

package/types/modules/index.d.ts

@@ -1,5 +1,6 @@
 import Module from './module';
 import HTTP from './http';
+import SocketIO from './socketio';
 export default class Modules extends Module {
     #private;
     /**
@@ -11,6 +12,7 @@ export default class Modules extends Module {
      */
     builtins: {
         http: HTTP;
+        socketio: SocketIO;
     };
     constructor();
     add(module: Module): this;

package/types/modules/socketio/client.d.ts

@@ -0,0 +1,23 @@
+import { ClientSocket as Socket } from './socket';
+import SocketIOServer from './server';
+export default class SocketIOCore extends SocketIOServer {
+    /**
+     * connect to <SocketIO RPC> service
+     */
+    connect(url: string): Promise<Socket>;
+    /**
+     * 客户端Socket连接事件
+     */
+    clientOnSocketConnection(socket: Socket): void;
+    clientOnDisconnect(socket: Socket, reason: any): void;
+    clientOnConnection(socket: Socket): void;
+    /**
+     * 客户端Socket断开事件
+     * @param {Socket} socket
+     */
+    clientOnSocketDisconnect(socket: Socket, reason: any): void;
+    /**
+     * 等待socket连接
+     */
+    clientWaitConnection(socket: Socket): Promise<void>;
+}

package/types/modules/socketio/index.d.ts

@@ -0,0 +1,37 @@
+import SocketIOClient from './client';
+import * as oox from '../../index';
+import { RPCKeepAliveConnectionData, RPCConnectionAdapter } from '../../index';
+import { Socket, sockets, ServerSocket, ClientSocket } from './socket';
+export { Socket, sockets };
+export default class SocketIOModule extends SocketIOClient implements RPCConnectionAdapter {
+    sockets: Map<string, Socket>;
+    serve(): Promise<void>;
+    onSyncConnection(socket: Socket): oox.RPCKeepAliveConnectionData[];
+    serverOnDisconnect(socket: ServerSocket, reason: string): void;
+    clientOnDisconnect(socket: ClientSocket, reason: any): void;
+    /**
+     *
+     * @param socket 是由哪个通道发送过来的
+     * @param connectionDatas
+     */
+    clientOnSyncConnection(socket: Socket, connectionDatas: RPCKeepAliveConnectionData[]): void;
+    onFetchActions(socket: Socket, search: string): string[];
+    fetchActions(url: string, search?: string): Promise<RPCKeepAliveConnectionData[]>;
+    fetchActions(name: string, search?: string): Promise<RPCKeepAliveConnectionData[]>;
+    onConnection(socket: Socket): void;
+    /**
+     *
+     * @param {Socket} socket
+     */
+    serverOnConnection(socket: ServerSocket): void;
+    call(action: string, params: any[], context: oox.Context, callback?: (returns: any) => void): Promise<oox.ReturnsBody>;
+    clientOnConnection(socket: ClientSocket): void;
+    /**
+     * socketio emit
+     */
+    emit(url: string, action: string, params: any[]): Promise<unknown>;
+    /**
+     * RPC
+     */
+    rpc(url: string, action: string, params: [], context?: oox.Context): Promise<any>;
+}

package/types/modules/socketio/server.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import { Server, ServerOptions } from 'socket.io';
+import { Module, ModuleConfig } from '../../index';
+import { ServerSocket as Socket } from './socket';
+export declare class SocketIOConfig extends ModuleConfig {
+    port: number;
+    path: string;
+    origin: string;
+}
+export default class SocketIOServer extends Module {
+    #private;
+    name: string;
+    config: SocketIOConfig;
+    server: http.Server;
+    socketServer: Server;
+    setConfig(config: SocketIOConfig): void;
+    getConfig(): SocketIOConfig;
+    serve(): Promise<void>;
+    stop(): Promise<void>;
+    genSocketIOServerOptions(): Partial<ServerOptions>;
+    createSocketIOServer(): void;
+    /**
+     * 服务端Socket连接事件
+     */
+    serverOnSocketConnection(socket: Socket): void;
+    serverOnConnection(socket: Socket): void;
+    /**
+     * 服务端Socket断开事件
+     * @param {Socket} socket
+     * @param {Error} reason
+     */
+    serverOnSocketDisconnect(socket: Socket, reason: string): void;
+    serverOnDisconnect(socket: Socket, reason: string): void;
+}

package/types/modules/socketio/socket.d.ts

@@ -0,0 +1,11 @@
+import { Socket as _ServerSocket } from 'socket.io';
+import { Socket as _ClientSocket } from 'socket.io-client';
+import { RPCKeepAliveConnectionData } from '../../index';
+export interface ServerSocket extends _ServerSocket {
+    data: RPCKeepAliveConnectionData;
+}
+export interface ClientSocket extends _ClientSocket {
+    data: RPCKeepAliveConnectionData;
+}
+export declare type Socket = ServerSocket | ClientSocket;
+export declare const sockets: Map<string, Socket>;