oox 0.3.4 → 0.3.6

package/modules/socketio/server.js

@@ -2,10 +2,12 @@ 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 '../module.js';
 import SocketIOAdapter from './adapter.js';
 import { OOXEvent } from './utils.js';
-export class SocketIOConfig extends ModuleConfig {
+import { randomUUID } from 'node:crypto';
+export class SocketIOConfig {
+    enabled = true;
     // listen port
     port = 0;
     // service path
@@ -34,6 +36,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 +59,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 +95,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 +135,12 @@ 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);
@@ -143,24 +156,32 @@ export default class SocketIOServer extends Module {
      */
     serverOnSocketConnection(socket) {
         const headers = socket.handshake.headers;
-        const callerId = String(headers['x-caller-id'] || '') || socket.id;
+        const callerId = String(headers['x-caller-id'] || randomUUID());
         // 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 +189,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

@@ -1,10 +1,15 @@
-export var OOXEvent;
-(function (OOXEvent) {
-    OOXEvent["READY"] = "oox:ready";
-    OOXEvent["ENABLED"] = "oox:enabled";
-    OOXEvent["DISABLED"] = "oox:disabled";
-    OOXEvent["SYNC_CONNECTIONS"] = "oox:sync_connections";
-})(OOXEvent || (OOXEvent = {}));
+export const OOXEvent = {
+    CONNECT: 'connect',
+    DISCONNECT: 'disconnect',
+    ERROR: 'error',
+    CALL: 'call',
+    READY: 'oox:ready',
+    ENABLED: 'oox:enabled',
+    DISABLED: 'oox:disabled',
+    REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+    REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+    REGISTRY_NOTIFY: 'oox:registry:notify',
+};
 export function isWebSocketURL(url) {
     if ('string' === typeof url) {
         return /^wss?:\/\/.+$/.test(url);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "oox",
-    "version": "0.3.4",
+    "version": "0.3.6",
     "description": "OOX Service Engine",
     "keywords": [
         "http",
@@ -10,7 +10,9 @@
         "framework",
         "microservice",
         "distributed",
-        "tracing"
+        "tracing",
+        "service-discovery",
+        "load-balancing"
     ],
     "type": "module",
     "main": "./index.js",
@@ -22,15 +24,20 @@
             "types": "./types/index.d.ts"
         },
         "./loader": "./bin/loader.mjs",
-        "./cli": "./bin/cli.js",
-        "./samples": "./samples/index.js",
-        "./samples/types": "./types/samples/index.d.ts"
+        "./cli": {
+            "default": "./bin/cli.js",
+            "types": "./types/bin/cli.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",

package/proxy.js

@@ -0,0 +1,30 @@
+import { rpc } from './keepalive-connection.js';
+/**
+ * 为了不重复创建Proxy，这个对象用于保存各个RPC服务的各个属性Proxy
+ */
+const rpcServiceAttrMap = Object.create(null);
+export function proxy(name, action = '') {
+    return new Proxy(function () { }, {
+        get(target, key) {
+            if (typeof key !== 'string')
+                return undefined;
+            const attrKey = action ? action + '.' + key : key;
+            const attrKeyPath = name + '.' + attrKey;
+            if (attrKeyPath in rpcServiceAttrMap) {
+                // 不重复创建Proxy
+                return rpcServiceAttrMap[attrKeyPath];
+            }
+            const attrProxy = proxy(name, attrKey);
+            rpcServiceAttrMap[attrKeyPath] = attrProxy;
+            return attrProxy;
+        },
+        has(target, key) {
+            if (typeof key !== 'string')
+                return false;
+            return true;
+        },
+        apply(target, thisArg, args) {
+            return rpc(name, action, args);
+        }
+    });
+}

package/registry.js

@@ -1,5 +1,71 @@
-import { config } from './index.js';
+import { config } from './config.js';
 import { enabledKeepAliveConnections, keepAliveConnectionAdapters, keepAliveConnections } from './keepalive-connection.js';
+const unsubscribeListeners = new Map();
+const subscribes = new Map();
+let broadcastTimer = null;
+/**
+ * 取消订阅连接列表
+ * @param connection
+ */
+export function unsubscribe(connection) {
+    subscribes.delete(connection);
+}
+/**
+ * 订阅连接列表
+ * @param connection
+ * @param query
+ * @returns
+ */
+export function subscribe(connection, query) {
+    if (!config.isRegistry)
+        return;
+    if (!unsubscribeListeners.has(connection)) {
+        const listener = () => {
+            unsubscribe(connection);
+        };
+        unsubscribeListeners.set(connection, listener);
+        connection.once('disconnect', listener);
+    }
+    subscribes.set(connection, query);
+}
+/**
+ * 停止广播连接列表
+ */
+export function stopBroadcastTimer() {
+    if (!broadcastTimer)
+        return;
+    clearInterval(broadcastTimer);
+    broadcastTimer = null;
+}
+/**
+ * 开始广播连接列表
+ */
+export function startBroadcastTimer() {
+    if (!config.isRegistry)
+        return;
+    if (broadcastTimer)
+        clearInterval(broadcastTimer);
+    broadcastTimer = setInterval(broadcast, 1000);
+}
+/**
+ * 广播连接列表
+ */
+export function broadcast() {
+    if (!config.isRegistry)
+        return;
+    for (const [connection, query] of subscribes.entries()) {
+        try {
+            onSyncConnections(connection, query, returns => {
+                if (!returns.success)
+                    return;
+                connection.adapter['registry:notify'](connection, returns.body || []);
+            });
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+}
 /**
  * 服务器发送连接列表
  * @param connection
@@ -8,8 +74,16 @@ import { enabledKeepAliveConnections, keepAliveConnectionAdapters, keepAliveConn
  */
 export function onSyncConnections(connection, query, callback) {
     // 检查是否开启服务注册功能
-    if (!config.isRegistry)
-        return callback([]);
+    if (!config.isRegistry) {
+        const returns = {
+            success: false,
+            error: {
+                message: 'Service registration is not enabled',
+            }
+        };
+        callback(returns);
+        return;
+    }
     const datas = [];
     if (query.name) {
         const names = Array.isArray(query.name) ? query.name : [query.name];
@@ -34,14 +108,24 @@ export function onSyncConnections(connection, query, callback) {
             }
         }
     }
-    callback(datas);
+    const returns = {
+        success: true,
+        body: datas,
+    };
+    callback(returns);
 }
 /**
  * 同步连接列表
  * @param datas 连接参数列表
  */
-export function syncConnections(datas) {
-    for (const data of datas) {
+export function syncConnections(returns) {
+    if (!returns.success) {
+        if (returns.error) {
+            console.error(new Error(returns.error.message || 'Sync connections failed'));
+        }
+        return;
+    }
+    for (const data of returns.body || []) {
         // 获取适配器
         const adapter = keepAliveConnectionAdapters.get(data.adapter);
         if (!adapter)
@@ -56,6 +140,6 @@ export function syncConnections(datas) {
         if (keepAliveConnections.has(data.name, data.id))
             continue;
         // 建立连接
-        adapter.open(data.url).catch((error) => console.error(error));
+        adapter.open(data).catch((error) => console.error(error));
     }
 }

package/samples/index.js

@@ -1 +1 @@
-export { SampleKeepAliveConnectionAdapter } from './keepalive-connection-sample.js';
+export * from './keepalive-connection-sample.js';

package/samples/keepalive-connection-sample.js

@@ -1,22 +1,44 @@
-import * as oox from '../index.js';
+import * as registry from '../registry.js';
+import { config } from '../config.js';
+import { getContext, genContext, } from '../context.js';
+import { KeepAliveConnectionError, addKeepAliveConnection, removeKeepAliveConnection, } from '../keepalive-connection.js';
+import { call, } from '../app.js';
 export class SampleKeepAliveConnectionAdapter {
-    name;
     OOXEvent = {
-        READY: 'oox:ready',
-        ENABLED: 'oox:enabled',
-        DISABLED: 'oox:disabled',
-        SYNC_CONNECTIONS: 'oox:sync_connections',
-    };
-    nativeEvent = {
         CONNECT: 'connect',
         DISCONNECT: 'disconnect',
         ERROR: 'error',
+        CALL: 'call',
+        READY: 'oox:ready',
+        ENABLED: 'oox:enabled',
+        DISABLED: 'oox:disabled',
+        REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+        REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+        REGISTRY_NOTIFY: 'oox:registry:notify',
     };
+    /**
+     * 通知连接列表
+     */
+    ['registry:notify'](connection, datas) {
+        connection.nativeConnection.emit(this.OOXEvent.REGISTRY_NOTIFY, datas);
+    }
+    /**
+     * 订阅连接列表
+     */
+    ['registry:subscribe'](connection, query) {
+        connection.nativeConnection.emit(this.OOXEvent.REGISTRY_SUBSCRIBE, query);
+    }
     bindConnectionEvents(connection) {
         const socket = connection.nativeConnection;
         socket.on(this.OOXEvent.READY, (params) => {
             connection.ready(params);
-            socket.emit(this.OOXEvent.SYNC_CONNECTIONS, oox.registry.syncConnections);
+            socket.emit(this.OOXEvent.REGISTRY_SYNC_CONNECTIONS, registry.syncConnections);
+        });
+        socket.on(this.OOXEvent.REGISTRY_NOTIFY, (datas) => {
+            registry.syncConnections({
+                success: true,
+                body: datas,
+            });
         });
         socket.on(this.OOXEvent.ENABLED, () => {
             connection.enabled = true;
@@ -24,25 +46,23 @@ export class SampleKeepAliveConnectionAdapter {
         socket.on(this.OOXEvent.DISABLED, () => {
             connection.enabled = false;
         });
-        socket.on(this.nativeEvent.DISCONNECT, (reason) => {
-            connection.emit('disconnect');
-            oox.removeKeepAliveConnection(connection);
+        socket.on(this.OOXEvent.DISCONNECT, () => {
+            removeKeepAliveConnection(connection);
             socket.removeAllListeners();
-            socket.disconnect();
+            connection.emit('disconnect');
         });
-        socket.on(this.nativeEvent.CONNECT, () => {
+        socket.on(this.OOXEvent.CONNECT, () => {
             connection.emit('connect');
         });
-        socket.on(this.nativeEvent.ERROR, (error) => {
-            connection.emit('error', error);
-            oox.removeKeepAliveConnection(connection);
+        socket.on(this.OOXEvent.ERROR, (error) => {
+            removeKeepAliveConnection(connection);
             socket.removeAllListeners();
-            socket.disconnect();
+            connection.emit('error', new KeepAliveConnectionError(error.message, connection));
         });
     }
-    async open(url) {
-        const connection = this.newConnection(url);
-        oox.addKeepAliveConnection(connection);
+    async open(identify) {
+        const connection = this.newConnection(identify);
+        addKeepAliveConnection(connection);
         this.bindConnectionEvents(connection);
         this.bindCall(connection);
         await new Promise((resolve, reject) => {
@@ -76,9 +96,9 @@ export class SampleKeepAliveConnectionAdapter {
                 reject(new Error(message));
             };
             // RPC 执行时中断连接
-            socket.once(this.nativeEvent.DISCONNECT, onError);
+            socket.once(this.OOXEvent.DISCONNECT, onError);
             socket.emit(event, ...params, (returns) => {
-                socket.off(this.nativeEvent.DISCONNECT, onError);
+                socket.off(this.OOXEvent.DISCONNECT, onError);
                 resolve(returns);
             });
         });
@@ -88,8 +108,12 @@ export class SampleKeepAliveConnectionAdapter {
      */
     async rpc(connection, action, params, context) {
         if (!context)
-            context = oox.getContext();
-        const { success, error, body } = await this.emit(connection.nativeConnection, 'call', [action, params, context]);
+            context = getContext();
+        const miniContext = {
+            sourceIP: context.sourceIP,
+            traceId: context.traceId,
+        };
+        const { success, error, body } = await this.emit(connection.nativeConnection, this.OOXEvent.CALL, [action, params, miniContext]);
         if (success)
             return body;
         else if (error)
@@ -102,25 +126,22 @@ export class SampleKeepAliveConnectionAdapter {
      * @param connection
      */
     bindCall(connection) {
-        const { id, name, host } = connection.data;
-        const connectionContext = {
-            sourceIP: '',
-            ip: host,
-            caller: name,
-            callerId: id,
-            connection
-        };
-        connection.nativeConnection.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);
+        const { id, name, ip } = connection.data;
+        connection.nativeConnection.on(this.OOXEvent.CALL, async (action, params, context, callback) => {
+            const validContext = genContext({
+                sourceIP: ip,
+                ...context,
+                ip: ip,
+                caller: name,
+                callerId: id,
+                connection
+            });
+            this.call(action, params, validContext, callback);
         });
     }
     async call(action, params, context, callback) {
-        const returns = await oox.call(action, params, context);
-        if (returns.error && !oox.config.errorStack) {
+        const returns = await call(action, params, context);
+        if (returns.error && !config.errorStack) {
             // 不返回错误调用栈信息
             delete returns.error.stack;
         }

package/types/app.d.ts

@@ -1,20 +1,14 @@
 import { EventEmitter } from 'node:events';
-import { AsyncLocalStorage } from 'node:async_hooks';
-export * as logger from './logger.js';
-export interface ReturnsBody {
-    traceId: string;
+import { AppContext } from './context.js';
+export interface ReturnsBody<T = any> {
+    traceId?: string;
     success: boolean;
-    body?: any;
+    body?: T;
     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<[never]>;
 /**
  * the kvMethods is all actions refs [has bind this]
@@ -24,21 +18,21 @@ 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: 'call:start', listener: (timestamp: number, action: string, params: any[], context: Context) => void): void;
-export declare function on(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
-export declare function on(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: Context, error: Error) => void): void;
-export declare function on(event: 'log', listener: (timestamp: number, context: Context | null, level: string, msgs: any[]) => void): void;
+export declare function on(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: AppContext) => void): void;
+export declare function on(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: AppContext, result: ReturnsBody) => void): void;
+export declare function on(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: AppContext, error: Error) => void): void;
+export declare function on(event: 'log', listener: (timestamp: number, context: AppContext | null, level: string, msgs: any[]) => void): void;
 export declare function once(event: 'app:configured' | 'app:served' | 'app:stopped', listener: (...args: any[]) => void): void;
-export declare function once(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: Context) => void): void;
-export declare function once(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: Context, result: ReturnsBody) => void): void;
-export declare function once(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: Context, error: Error) => void): void;
-export declare function once(event: 'log', listener: (timestamp: number, context: Context | null, level: string, msgs: any[]) => void): void;
+export declare function once(event: 'call:start', listener: (timestamp: number, action: string, params: any[], context: AppContext) => void): void;
+export declare function once(event: 'call:success', listener: (timestamp: number, action: string, params: any[], context: AppContext, result: ReturnsBody) => void): void;
+export declare function once(event: 'call:fail', listener: (timestamp: number, action: string, params: any[], context: AppContext, error: Error) => void): void;
+export declare function once(event: 'log', listener: (timestamp: number, context: AppContext | null, level: string, msgs: any[]) => void): void;
 export declare function off(event: 'app:configured' | 'app:served' | 'app:stopped' | 'call:start' | 'call:success' | 'call:fail' | 'log', listener: (...args: any[]) => void): void;
 export declare function emit(event: 'app:configured' | 'app:served' | 'app:stopped'): boolean;
-export declare function emit(event: 'call:start', timestamp: number, action: string, params: any[], context: Context): boolean;
-export declare function emit(event: 'call:success', timestamp: number, action: string, params: any[], context: Context, result: ReturnsBody): boolean;
-export declare function emit(event: 'call:fail', timestamp: number, action: string, params: any[], context: Context, error: Error): boolean;
-export declare function emit(event: 'log', timestamp: number, context: Context | null, level: string, content: any): boolean;
+export declare function emit(event: 'call:start', timestamp: number, action: string, params: any[], context: AppContext): boolean;
+export declare function emit(event: 'call:success', timestamp: number, action: string, params: any[], context: AppContext, result: ReturnsBody): boolean;
+export declare function emit(event: 'call:fail', timestamp: number, action: string, params: any[], context: AppContext, error: Error): boolean;
+export declare function emit(event: 'log', timestamp: number, context: AppContext | null, level: string, content: any): boolean;
 /**
  * Call an Function on RPC server
  * @param action
@@ -46,5 +40,5 @@ export declare function emit(event: 'log', timestamp: number, context: Context |
  * @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>;
+export declare function call(action: string, params: any[] | undefined, context: AppContext): Promise<ReturnsBody>;
+export declare function execute(action: string, params: Array<any>, context: AppContext): Promise<any>;

package/types/bin/configurer.d.ts

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

package/types/bin/register.d.ts

@@ -1 +1,2 @@
-export declare function registry(urls: string | string[]): Promise<void>;
+import * as oox from '../index.js';
+export declare function registry(identifies: string[] | oox.KeepAliveConnectionData[]): Promise<void>;

package/types/config.d.ts

@@ -0,0 +1,66 @@
+import { KeepAliveConnectionData } from "./keepalive-connection.js";
+export interface ConfigAllow {
+    untrusted: boolean;
+    ip: string[];
+    caller: string[];
+}
+interface ConfigInterface {
+    id: string;
+    name: string;
+    group: string;
+    ignore: string[];
+    entryInfo: {
+        path: string;
+        group: string;
+    };
+    host: string;
+    port: number;
+    origin: string | string[];
+    errorStack: boolean;
+    isRegistry: boolean;
+    registry: string[] | KeepAliveConnectionData[];
+    registryToken: string;
+    registryAdapter: string;
+    token: string;
+    allow: ConfigAllow;
+}
+export declare class Config implements ConfigInterface {
+    [x: string]: any;
+    id: string;
+    name: string;
+    group: string;
+    ignore: string[];
+    entryInfo: {
+        path: string;
+        group: string;
+    };
+    host: string;
+    port: number;
+    origin: string | string[];
+    errorStack: boolean;
+    isRegistry: boolean;
+    registry: string[] | KeepAliveConnectionData[];
+    registryToken: string;
+    registryAdapter: string;
+    token: string;
+    allow: ConfigAllow;
+}
+type StrictFormatter<T> = {
+    [K in keyof T]: (value: any) => T[K];
+};
+export declare const configFormatters: StrictFormatter<ConfigInterface> & {
+    [x: string]: (v: any) => any;
+};
+/**
+ * 检查连接是否被允许
+ * @param ip 连接主机 IP
+ * @param caller 连接服务名称
+ * @param token 令牌
+ * @returns 是否被允许
+ */
+export declare function checkAllow(ip: string, caller: string, token: string): {
+    allow: boolean;
+    reason?: string;
+};
+export declare const config: Config;
+export {};