oox 0.2.0 → 0.3.0-beta10

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.listening && 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,17 +1,40 @@
 {
-  "name": "oox",
-  "version": "0.2.0",
-  "description": "distributed api service",
-  "main": "index.js",
-  "bin": {
-    "oox": "bin/cli.js"
-  },
-  "author": "lipingruan",
-  "homepage": "https://github.com/lipingruan/oox",
-  "license": "MIT",
-  "dependencies": {
-    "chalk": "^4.1.0",
-    "socket.io": "^4.4.0",
-    "socket.io-client": "^4.4.0"
-  }
-}
+    "name": "oox",
+    "version": "0.3.0-beta10",
+    "description": "Graceful NodeJS distributed application solution",
+    "keywords": [
+        "http",
+        "websocket",
+        "socket.io",
+        "rpc",
+        "framework",
+        "microservice",
+        "distributed",
+        "tracing"
+    ],
+    "type": "commonjs",
+    "main": "index.js",
+    "types": "types/index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./index.mjs",
+            "require": "./index.js"
+        },
+        "./loader": "./bin/loader.mjs",
+        "./cli": "./bin/cli.js"
+    },
+    "bin": {
+        "oox": "bin/cli.js"
+    },
+    "author": "lipingruan",
+    "homepage": "https://github.com/lipingruan/oox",
+    "license": "MIT",
+    "dependencies": {
+        "chalk": "^4.1.0",
+        "socket.io": "^4.4.0",
+        "socket.io-client": "^4.4.0"
+    },
+    "engines": {
+        "node": ">=14.17.0"
+    }
+}

package/types/app.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+import { AsyncLocalStorage } from 'node:async_hooks';
+export * as logger from './logger';
+export interface ReturnsBody {
+    traceId: string;
+    success: boolean;
+    body?: any;
+    error?: {
+        message: string;
+        stack: string;
+    };
+}
+export declare class Context {
+    [x: string]: any;
+    traceId?: string;
+}
+export declare const asyncStore: AsyncLocalStorage<Context>;
+export declare const eventHub: EventEmitter;
+/**
+ * the kvMethods is all actions refs [has bind this]
+ */
+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, 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
+ * @param params
+ * @param context
+ * @returns
+ */
+export declare function call(action: string, params: any[], context: Context): Promise<ReturnsBody>;
+export declare function execute(action: string, params: Array<any>, context: Context): Promise<any>;

package/types/bin/argv.d.ts

@@ -0,0 +1,8 @@
+export declare function getAllEnvArgs(): {
+    [x: string]: any;
+};
+export declare function getEnvArgs(names: string[]): {
+    [x: string]: any;
+};
+export declare function getEnvArg(name: string): any;
+export declare function parseEnvArg(value: string): any;

package/types/bin/cli.d.ts

@@ -0,0 +1,4 @@
+#! /usr/bin/env node
+import { startup } from './starter';
+export declare const version: string;
+export { startup };

package/types/bin/configurer.d.ts

@@ -0,0 +1,3 @@
+export declare function configure(mergeEnv?: {
+    [x: string]: any;
+}): Promise<any>;

package/types/bin/proxyer.d.ts

@@ -0,0 +1 @@
+export declare function proxyGroup(groupDirectory: string, excludes?: any[]): void;

package/types/bin/register.d.ts

@@ -0,0 +1 @@
+export declare function registry(urls: string | string[]): Promise<void>;

package/types/bin/starter.d.ts

@@ -0,0 +1,3 @@
+export declare function startup(env?: {
+    [x: string]: any;
+}, entryFilename?: string): Promise<void>;

package/types/index.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import * as app from './app';
+import Module, { ModuleConfig } from './modules/module';
+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, 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?(): {} & this;
+}
+export declare class Config {
+    [x: string]: any;
+    name: string;
+    entryFile: {
+        path: string;
+        group: string;
+    };
+    host: string;
+    port: number;
+    origin: string;
+}
+export declare const config: Config;
+export declare function setGenTraceIdFunction(fn: () => string): void;
+/**
+ * 生成随机不重复id
+ */
+export declare function genTraceId(): string;
+/**
+ * 获取链路跟踪上下文
+ */
+export declare function genContext(context?: Context): Context;
+export declare function getContext(): Context;
+export declare function serve(): Promise<void>;
+export declare function stop(): Promise<void>;
+export interface RPCConnectionAdapter {
+    rpc(connection: any, action: string, params: any[], context: Context): Promise<any>;
+}
+export interface RPCKeepAliveConnectionData {
+    /**
+     * 是否连接成功
+     */
+    connected: boolean;
+    /**
+     * 连接主机地址
+     */
+    host: string;
+    /**
+     * 连接服务名称
+     */
+    name: string;
+    /**
+     * 目标服务网络唯一ID
+     */
+    id: string;
+}
+export declare class RPCKeepAliveConnection {
+    data: RPCKeepAliveConnectionData;
+    nativeConnection: any;
+    adapter: RPCConnectionAdapter;
+    constructor(adapter: RPCConnectionAdapter, nativeConnection: any, data?: RPCKeepAliveConnectionData);
+}
+export declare const keepAliveConnections: Map<string, Map<string, RPCKeepAliveConnection>>;
+export declare function getKeepAliveConnections(name: string): Map<string, RPCKeepAliveConnection>;
+export declare function getKeepAliveConnection(name: string, id: string): RPCKeepAliveConnection | null;
+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

@@ -0,0 +1,4 @@
+export declare function info(...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/index.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import * as http from 'node:http';
+import * as oox from '../../index';
+import Module, { ModuleConfig } from '../module';
+export declare class HTTPConfig extends ModuleConfig {
+    port: number;
+    path: string;
+    origin: string;
+}
+export default class HTTPModule extends Module {
+    name: string;
+    config: HTTPConfig;
+    server: http.Server;
+    setConfig(config: HTTPConfig): void;
+    getConfig(): HTTPConfig;
+    /**
+     * start http service
+     */
+    serve(): Promise<void>;
+    /**
+     * stop http service
+     */
+    stop(): Promise<void>;
+    /**
+     * browser cross origin
+     */
+    cors(request: http.IncomingMessage, response: http.ServerResponse): boolean;
+    /**
+     * HTTP-RPC服务器请求监听方法
+     */
+    call(request: http.IncomingMessage, response: http.ServerResponse): Promise<void>;
+    /**
+     * HTTP Response Catch
+     */
+    respond(request: http.IncomingMessage, response: http.ServerResponse, format: {
+        body?: any;
+        success: boolean;
+        error?: {
+            message: any;
+            stack: any;
+        };
+    }): void;
+    /**
+     * HTTP RPC
+     */
+    rpc(url: string | URL, action: string, params: Array<any>, context?: oox.Context): Promise<any>;
+}

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'node:http';
+import { Readable } from 'node:stream';
+/**
+ * Stream => Buffer
+ */
+export declare function stream2buffer(stream: Readable, totalLength?: number): Promise<Buffer>;
+/**
+ * Request => JSONObject
+ */
+export declare function parseHTTPBody(request: http.IncomingMessage): Promise<any>;
+/**
+ * http request
+ */
+export declare function httpRequest(url: URL | string, options: http.RequestOptions, body: string): Promise<any>;

package/types/modules/index.d.ts

@@ -0,0 +1,24 @@
+import Module from './module';
+import HTTP from './http';
+import SocketIO from './socketio';
+export default class Modules extends Module {
+    #private;
+    /**
+     * the module unique name
+     */
+    name: string;
+    /**
+     * all builtin modules
+     */
+    builtins: {
+        http: HTTP;
+        socketio: SocketIO;
+    };
+    constructor();
+    add(module: Module): this;
+    get(name: string): Module;
+    remove(name: string): Promise<void>;
+    setConfig(config: any): void;
+    serve(): Promise<void>;
+    stop(): Promise<void>;
+}

package/types/modules/module.d.ts

@@ -0,0 +1,13 @@
+export declare class ModuleConfig {
+    [x: string]: any;
+    disabled: boolean;
+}
+export default class Module {
+    [x: string]: any;
+    config: ModuleConfig;
+    name: string;
+    setConfig(config: any): void;
+    getConfig(): ModuleConfig;
+    serve(): Promise<void>;
+    stop(): Promise<void>;
+}

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>;
+}