pao-aop-server/lib/net/reverseProxy.d.ts

基于pao-aop的服务端框架

/// <reference types="node" />
import * as TCP from 'net';
import { BaseAddon } from 'pao-aop';
import { SocketServer } from '../net/socket';
import { BaseServer } from '../base';
/**
 * 命令
 */
export declare enum Command {
    CommandConnect = 0,
    CommandProxy = 1,
    CommandEnd = 2
}
/**
 * Socket 缓存队列
 */
declare class SocketBufferQueueList {
    /**
     * 缓存队列
     */
    bufferQueueList: {
        [index: string]: (Buffer | 'end' | Error)[];
    };
    setBufferQueue(outerAddress: string): void;
    pushBuffer(outerAddress: string, data: Buffer | 'end' | Error): void;
    shiftBuffer(outerAddress: string): Error | Buffer | "end";
    sendAll(address: string, socketList: {
        [index: string]: TCP.Socket;
    }): void;
}
/**
 * 分发器接口
 */
export interface IDistributor {
    /**
     * 分发器检测
     * @param distributeServerID 分发服务器ID
     * @param incommingSocket 传入的套接字
     */
    distributorCheck?(distributeServerID: string, incommingSocket: TCP.Socket): Promise<boolean>;
}
/**
 * 插件：透明分发器
 * 分发所有数据的数据分发器
 */
export declare class TransparentDistributor extends BaseAddon implements IDistributor {
    /**
     * 分发套接字
     * @param distributeServerID 分发服务器ID
     * @param incommingSocket 传入的套接字
     */
    distributorCheck?(distributeServerID: string, incommingSocket: TCP.Socket): Promise<boolean>;
}
/**
 * 代理服务器信息
 */
export declare class ProxyServerInfo {
    /**
     * 要代理的服务器端口
     */
    serverPort?: number;
    /**
     * 服务器名称
     */
    name?: string;
    /**
     * 备注
     */
    comment?: string;
    /**
     * 分发器
     */
    distributor?: IDistributor;
}
/**
 * 分发服务器信息
 */
export declare class DistributeServerInfo {
    /**
     * 服务器ID
     */
    serverID?: string;
    /**
     * 服务端口
     */
    serverPort?: number;
    /**
     * 密码
     */
    password?: string;
    /**
     * 是否生效
     */
    enabled?: boolean;
    /**
     * 备注
     */
    comment?: string;
}
/**
 * 分发服务器细节
 */
declare class DistributeServerDetail {
    /**
     * 对应的内部主端口
     */
    innerMainSocket: TCP.Socket;
    /**
     * 代理服务器
     */
    proxyServer: ReverseProxyServer;
}
/**
 * 反向代理内网监听服务
 */
export declare class ReverseProxyListenServer extends SocketServer {
    /**
     * 代理服务器列表(配置)
     */
    proxyServers?: ProxyServerInfo[];
    /**
     * 分发服务器列表(配置)
     */
    distributeServers?: DistributeServerInfo[];
    /**
     * 代理服务实例
     */
    private proxyServerInstances?;
    /**
     * 服务明细
     */
    private distributeServerDetails?;
    protected onCreated?(): void;
    /**
     * 连接建立
     * @param socket 套接字
     */
    protected onConnected?(socket: TCP.Socket): void;
    connectServer?(distributeServerID: string, distributeServerPassword: string, socket: TCP.Socket): void;
}
/**
 * 反向代理服务
 * 反向代理服务在有IP地址公网中运行，模拟开启某个服务，并将接收到的信息转发给目标服务器
 */
export declare class ReverseProxyServer extends SocketServer {
    /**
     * 代理服务器信息
     */
    proxyServerInfo?: ProxyServerInfo;
    /**
     * 外网Socket列表
     */
    outerSocketList?: {
        [index: string]: TCP.Socket;
    };
    /**
     * 内网Socket列表
     */
    innerSocketList?: {
        [index: string]: TCP.Socket;
    };
    /**
     * 待发送的数据缓存
     */
    bufferList?: SocketBufferQueueList;
    /**
     * 服务明细
     */
    distributeServers?: {
        [serverID: string]: {
            serverInfo: DistributeServerInfo;
            serverDetail: DistributeServerDetail;
        };
    };
    /**
     * 连接内网主端口
     * @param innerMainSocket 内网主端口
     * @param serverInfo 服务器信息
     */
    connetInnerMainPort?(serverInfo: DistributeServerInfo, serverDetail: DistributeServerDetail): void;
    /**
     * 断开内网主连接端口
     * @param serverID 服务ID
     */
    disconnectInnerMainPort?(serverID: string): void;
    /**
     * 连接内网端口
     * @param outerAddress 外网地址
     * @param innerSocket 内部端口
     */
    connectInnerPort?(outerAddress: string, innerSocket: TCP.Socket, serverID: string): void;
    /**
     * 来自外网的连接建立
     * @param outerSocket 套接字
     */
    protected onConnected?(outerSocket: TCP.Socket): void;
}
/**
 * 反向代理客户端
 */
export declare class ReverseProxyClient extends BaseServer {
    serverID?: string;
    password?: string;
    proxyPort?: number;
    proxyServer?: string;
    proxyServerPort?: number;
    targetServer?: string;
    targetServerPort?: number;
    /**
     * 代理服务端主端口
     */
    proxyServerMainSocket?: TCP.Socket;
    /**
     * 发送到Target的缓冲区
     */
    bufferListToTarget?: SocketBufferQueueList;
    /**
     * 代理服务列表
     */
    proxySocketList?: {
        [index: string]: TCP.Socket;
    };
    /**
     * 目标服务列表
     */
    targetSocketList?: {
        [index: string]: TCP.Socket;
    };
    /**
     * 构造函数
     * @param proxyPort 要代理的端口
     * @param proxyServer 代理服务器地址
     * @param proxyServerPort 代理服务端口
     * @param targetServer 目标服务器
     * @param targetServerPort 目标端口
     */
    constructor(serverID?: string, password?: string, proxyPort?: number, proxyServer?: string, proxyServerPort?: number, targetServer?: string, targetServerPort?: number);
    /**
     * 等待结束
     */
    waitForExit?(): Promise<void>;
    /**
     * 连接代理服务器
     */
    connectProxyServer?(): void;
    protected onStart?(): void;
    connectSockets?(outerAddress: string): void;
    /**
     * 连接目标服务器
     */
    connectTargetSocket?(outerAddress: string): void;
}
export {};
//# sourceMappingURL=reverseProxy.d.ts.map