pao-aop-server
Version:
基于pao-aop的服务端框架
750 lines (748 loc) • 38.1 kB
JavaScript
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
}
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports", "net", "util", "pao-aop", "../net/socket", "../buffer/index", "../base"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var TCP = require("net");
var util_1 = require("util");
var pao_aop_1 = require("pao-aop");
var socket_1 = require("../net/socket");
var index_1 = require("../buffer/index");
var base_1 = require("../base");
/*
* 版权: Copyright (c) 2018 red
*
* 文件: proxyServer.ts
* 创建日期: Thursday September 20th 2018
* 作者: pao
* 说明:
* 1、反向代理
* 2、外网：从Internet发来请求的端口
* 3、内网：面向内网的端口
* 4、代理：代理服务器的内网端口
* 5、目标：最终提供服务的服务器
*/
/**
* 默认字符串编码
*/
var StringEncoding = 'UTF8';
/**
* 命令
*/
var Command;
(function (Command) {
Command[Command["CommandConnect"] = 0] = "CommandConnect";
Command[Command["CommandProxy"] = 1] = "CommandProxy";
Command[Command["CommandEnd"] = 2] = "CommandEnd";
})(Command = exports.Command || (exports.Command = {}));
/**
* 等待端口的建立
* @param outerAddress 外部地址
*/
function waitForSocketCreated(outerAddress, socketList) {
/**
* 等待目标端口创建完毕
*/
pao_aop_1.wait(function () {
if (socketList && socketList[outerAddress]) {
return true;
}
else {
return false;
}
}, 60 * 1000, 10);
}
/**
* Socket 缓存队列
*/
var SocketBufferQueueList = /** @class */ (function () {
function SocketBufferQueueList() {
/**
* 缓存队列
*/
this.bufferQueueList = {};
}
SocketBufferQueueList.prototype.setBufferQueue = function (outerAddress) {
this.bufferQueueList[outerAddress] = [];
};
SocketBufferQueueList.prototype.pushBuffer = function (outerAddress, data) {
if (!this.bufferQueueList[outerAddress]) {
this.bufferQueueList[outerAddress] = [];
}
this.bufferQueueList[outerAddress].push(data);
};
SocketBufferQueueList.prototype.shiftBuffer = function (outerAddress) {
if (this.bufferQueueList[outerAddress]) {
return this.bufferQueueList[outerAddress].shift();
}
return undefined;
};
SocketBufferQueueList.prototype.sendAll = function (address, socketList) {
var socket = socketList[address];
var bufferQueue = this.bufferQueueList[address];
if (socket && bufferQueue) {
while (bufferQueue.length > 0) {
var data = bufferQueue.shift();
if (typeof data === "string" && data === 'end') {
socket.end();
}
else if (util_1.isError(data)) {
socket.destroy(data);
}
else {
pao_aop_1.log('data', "Send Data(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740=" + address);
socket.write(data);
}
}
}
};
return SocketBufferQueueList;
}());
/**
* 插件：透明分发器
* 分发所有数据的数据分发器
*/
var TransparentDistributor = /** @class */ (function (_super) {
__extends(TransparentDistributor, _super);
function TransparentDistributor() {
return _super !== null && _super.apply(this, arguments) || this;
}
/**
* 分发套接字
* @param distributeServerID 分发服务器ID
* @param incommingSocket 传入的套接字
*/
TransparentDistributor.prototype.distributorCheck = function (distributeServerID, incommingSocket) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, true];
});
});
};
TransparentDistributor = __decorate([
pao_aop_1.addon('TransparentDistributor', '透明分发器', '分发所有数据的数据分发器')
], TransparentDistributor);
return TransparentDistributor;
}(pao_aop_1.BaseAddon));
exports.TransparentDistributor = TransparentDistributor;
/**
* 代理服务器信息
*/
var ProxyServerInfo = /** @class */ (function () {
function ProxyServerInfo() {
}
return ProxyServerInfo;
}());
exports.ProxyServerInfo = ProxyServerInfo;
/**
* 分发服务器信息
*/
var DistributeServerInfo = /** @class */ (function () {
function DistributeServerInfo() {
}
return DistributeServerInfo;
}());
exports.DistributeServerInfo = DistributeServerInfo;
/**
* 分发服务器细节
*/
var DistributeServerDetail = /** @class */ (function () {
function DistributeServerDetail() {
}
return DistributeServerDetail;
}());
/**
* 反向代理内网监听服务
*/
var ReverseProxyListenServer = /** @class */ (function (_super) {
__extends(ReverseProxyListenServer, _super);
function ReverseProxyListenServer() {
var _this = _super !== null && _super.apply(this, arguments) || this;
/**
* 代理服务实例
*/
_this.proxyServerInstances = {};
/**
* 服务明细
*/
_this.distributeServerDetails = {};
return _this;
}
ReverseProxyListenServer.prototype.onCreated = function () {
/**
* 启动时开启代理服务监听
*/
if (!this.proxyServers) {
throw new Error("未设置代理服务器列表。");
}
pao_aop_1.log('proxyServer', "\u4EE3\u7406\u670D\u52A1\u5668\u6570\u76EE: " + this.proxyServers.length);
for (var _i = 0, _a = this.proxyServers; _i < _a.length; _i++) {
var proxyServerInfo = _a[_i];
var proxyServer = new ReverseProxyServer("外网监听服务器", proxyServerInfo.serverPort, this.hostName);
proxyServer.proxyServerInfo = proxyServerInfo;
proxyServer.start();
this.proxyServerInstances[proxyServerInfo.serverPort] = proxyServer;
}
};
/**
* 连接建立
* @param socket 套接字
*/
ReverseProxyListenServer.prototype.onConnected = function (socket) {
var _this = this;
var innerAddress = socket_1.getSocketRemoteAddress(socket);
socket.on('error', function (error) {
pao_aop_1.log('proxyServer', new Error("\u6765\u81EA" + innerAddress + "\u7684\u5185\u7F51\u8FDE\u63A5\u53D1\u751F\u5F02\u5E38: " + error));
});
socket.on('timeout', function () {
pao_aop_1.log('proxyServer', new Error("\u6765\u81EA" + innerAddress + "\u7684\u5185\u7F51\u8FDE\u63A5\u8D85\u65F6"));
});
socket.on('close', function (had_error) {
pao_aop_1.log('proxyServer', "\u6765\u81EA" + innerAddress + "\u7684\u5185\u7F51\u8FDE\u63A5\u5173\u95ED");
});
// 首次连接根据发过来的连接消息来判断端口是主端口还是代理端口，如果是代理端口，则创建一个代理通道
socket.once('data', function (data) {
try {
pao_aop_1.log('proxyServer', "Inner => Data(\u5927\u5C0F=" + data.length + ")");
var dataReader = new index_1.BufferReader(data);
var command = dataReader.readUInt32BE();
if (command === Command.CommandConnect) {
// 读取代理服务ID
var distributeServerID = dataReader.readString(StringEncoding);
var distributeServerPassword = dataReader.readString(StringEncoding);
pao_aop_1.log('proxyServer', "\u8FDE\u63A5\u8BF7\u6C42\u5230\u8FBE(ServerID=" + distributeServerID + ", Password=" + distributeServerPassword + ")");
_this.connectServer(distributeServerID, distributeServerPassword, socket);
}
else if (command === Command.CommandProxy) {
var distributeServerID_1 = dataReader.readString(StringEncoding);
var outerAddress_1 = dataReader.readString(StringEncoding);
pao_aop_1.log('proxyServer', "\u4EE3\u7406\u8BF7\u6C42\u5230\u8FBE(ServerID=" + distributeServerID_1 + ", OuterAddress=" + outerAddress_1 + ")");
_this.distributeServers.forEach(function (distributeServerInfo) {
if (distributeServerInfo.serverID === distributeServerID_1) {
pao_aop_1.log('proxyServer', "Inner => Proxy(\u5916\u7F51\u5730\u5740=" + outerAddress_1);
_this.distributeServerDetails[distributeServerID_1].proxyServer.connectInnerPort(outerAddress_1, socket, distributeServerID_1);
}
});
}
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
};
ReverseProxyListenServer.prototype.connectServer = function (distributeServerID, distributeServerPassword, socket) {
var _this = this;
if (!this.distributeServers) {
throw new Error("\u672A\u8BBE\u7F6E\u5206\u5E03\u5F0F\u670D\u52A1\u5668\u5217\u8868\uFF0C\u670D\u52A1:" + distributeServerID + "\u8FDE\u63A5\u5931\u8D25");
}
this.distributeServers.forEach(function (distributeServerInfo) {
if (distributeServerInfo.serverID === distributeServerID && distributeServerInfo.password === distributeServerPassword) {
var port = distributeServerInfo.serverPort;
pao_aop_1.log('proxyServer', "Inner => Connect(\u7AEF\u53E3=" + port + "})");
var proxyServer_1 = _this.proxyServerInstances[port];
if (!proxyServer_1) {
throw new Error("\u670D\u52A1" + distributeServerID + "\u8981\u4EE3\u7406\u7684\u7AEF\u53E3" + port + "\u6CA1\u6709\u8BBE\u7F6E\uFF0C\u5982\u679C\u9700\u8981\u5F00\u542F\u67D0\u4E2A\u7AEF\u53E3\uFF0C\u8BF7\u8BBE\u7F6EproxyServers\u5C5E\u6027");
}
_this.distributeServerDetails[distributeServerID] = {
innerMainSocket: socket,
proxyServer: proxyServer_1
};
/**
* 如果是主连接，端口关闭后应当删除服务
*/
socket.on('close', function (had_error) {
var innerAddress = socket_1.getSocketRemoteAddress(socket);
pao_aop_1.log('proxyServer', "\u6765\u81EA" + innerAddress + "\u7684\u5185\u7F51\u4E3B\u8FDE\u63A5\u5173\u95ED");
proxyServer_1.disconnectInnerMainPort(distributeServerID);
delete _this.distributeServerDetails[distributeServerID];
});
proxyServer_1.connetInnerMainPort(distributeServerInfo, _this.distributeServerDetails[distributeServerID]);
}
});
};
return ReverseProxyListenServer;
}(socket_1.SocketServer));
exports.ReverseProxyListenServer = ReverseProxyListenServer;
/**
* 反向代理服务
* 反向代理服务在有IP地址公网中运行，模拟开启某个服务，并将接收到的信息转发给目标服务器
*/
var ReverseProxyServer = /** @class */ (function (_super) {
__extends(ReverseProxyServer, _super);
function ReverseProxyServer() {
var _this = _super !== null && _super.apply(this, arguments) || this;
/**
* 外网Socket列表
*/
_this.outerSocketList = {};
/**
* 内网Socket列表
*/
_this.innerSocketList = {};
/**
* 待发送的数据缓存
*/
_this.bufferList = new SocketBufferQueueList();
/**
* 服务明细
*/
_this.distributeServers = {};
return _this;
}
/**
* 连接内网主端口
* @param innerMainSocket 内网主端口
* @param serverInfo 服务器信息
*/
ReverseProxyServer.prototype.connetInnerMainPort = function (serverInfo, serverDetail) {
this.distributeServers[serverInfo.serverID] = {
serverInfo: serverInfo,
serverDetail: serverDetail
};
};
/**
* 断开内网主连接端口
* @param serverID 服务ID
*/
ReverseProxyServer.prototype.disconnectInnerMainPort = function (serverID) {
delete this.distributeServers[serverID];
};
/**
* 连接内网端口
* @param outerAddress 外网地址
* @param innerSocket 内部端口
*/
ReverseProxyServer.prototype.connectInnerPort = function (outerAddress, innerSocket, serverID) {
var _this = this;
innerSocket.on('error', function (error) {
pao_aop_1.log('proxyServer', new Error("\u5185\u7F51\u8FDE\u63A5" + outerAddress + "\u5F02\u5E38: " + error));
var outerSocket = _this.outerSocketList[outerAddress];
if (outerSocket) {
pao_aop_1.log('proxyServer', "Error => Outer(\u5916\u7F51\u5730\u5740=" + outerAddress);
outerSocket.destroy(error);
}
});
innerSocket.on('timeout', function () {
pao_aop_1.log('proxyServer', new Error("\u5185\u7F51\u8FDE\u63A5" + outerAddress + "\u8D85\u65F6"));
});
innerSocket.on('close', function (had_error) {
pao_aop_1.log('proxyServer', "\u5185\u7F51\u8FDE\u63A5" + outerAddress + "\u5173\u95ED");
var outerSocketList = _this.outerSocketList[outerAddress];
if (outerSocketList) {
outerSocketList.destroy();
}
delete _this.outerSocketList[outerAddress];
delete _this.innerSocketList[outerAddress];
});
// 内网数据转发到外网
innerSocket.on('data', function (data) {
try {
pao_aop_1.log('proxyServer', "Inner => Data(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740=" + outerAddress + ")");
waitForSocketCreated(outerAddress, _this.outerSocketList);
var outerSocket = _this.outerSocketList[outerAddress];
if (outerSocket) {
pao_aop_1.log('proxyServer', "Data => Outer(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740=" + outerAddress);
outerSocket.write(data);
}
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
innerSocket.on('end', function () {
try {
pao_aop_1.log('proxyServer', "Inner => End(\u5916\u7F51\u5730\u5740=" + outerAddress);
var outerSocket = _this.outerSocketList[outerAddress];
if (outerSocket) {
pao_aop_1.log('proxyServer', "End => Outer(\u5916\u7F51\u5730\u5740=" + outerAddress);
outerSocket.end();
}
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
this.innerSocketList[outerAddress] = innerSocket;
this.bufferList.sendAll(outerAddress, this.innerSocketList);
};
/**
* 来自外网的连接建立
* @param outerSocket 套接字
*/
ReverseProxyServer.prototype.onConnected = function (outerSocket) {
var _this = this;
var outerAddress = socket_1.getSocketRemoteAddress(outerSocket);
this.outerSocketList[outerAddress] = outerSocket;
var _loop_1 = function (distributeServerID) {
if (distributeServerID) {
var distributeServer_1 = this_1.distributeServers[distributeServerID];
// 只有生效的分发服务器才转发数据
if (distributeServer_1.serverInfo.enabled) {
if (this_1.proxyServerInfo.distributor) {
this_1.proxyServerInfo.distributor.distributorCheck(distributeServerID, outerSocket).then(function (ok) {
if (ok) {
var distributeServerDetail = distributeServer_1.serverDetail;
socket_1.writeDataToSocket(distributeServerDetail.innerMainSocket, function (bufferWriter) {
bufferWriter.writeUInt32BE(Command.CommandConnect);
bufferWriter.writeString(outerAddress, StringEncoding);
pao_aop_1.log('proxyServer', "Connect => Inner(\u5927\u5C0F=" + bufferWriter.bufferSize + ", \u5916\u7F51\u5730\u5740=" + outerAddress + ")");
});
}
});
}
}
}
};
var this_1 = this;
// 根据转发规则建立连接
for (var distributeServerID in this.distributeServers) {
_loop_1(distributeServerID);
}
outerSocket.on('error', function (error) {
pao_aop_1.log('proxyServer', new Error("\u5916\u7F51\u8FDE\u63A5" + outerAddress + "\u5F02\u5E38: " + error));
_this.bufferList.pushBuffer(outerAddress, error);
_this.bufferList.sendAll(outerAddress, _this.innerSocketList);
});
outerSocket.on('timeout', function () {
pao_aop_1.log('proxyServer', new Error("\u5916\u7F51\u8FDE\u63A5" + outerAddress + "\u8D85\u65F6"));
});
outerSocket.on('close', function (had_error) {
pao_aop_1.log('proxyServer', "\u5916\u7F51\u8FDE\u63A5" + outerAddress + "\u5173\u95ED");
var innerSocket = _this.innerSocketList[outerAddress];
if (innerSocket) {
innerSocket.destroy();
}
delete _this.innerSocketList[outerAddress];
delete _this.outerSocketList[outerAddress];
});
// 外网数据转发到内网
outerSocket.on('data', function (data) {
try {
pao_aop_1.log('proxyServer', "Outer => Data(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740=" + outerAddress + ")");
_this.bufferList.pushBuffer(outerAddress, data);
waitForSocketCreated(outerAddress, _this.innerSocketList);
_this.bufferList.sendAll(outerAddress, _this.innerSocketList);
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
outerSocket.on('end', function () {
try {
pao_aop_1.log('proxyServer', "Outer => End(\u5916\u7F51\u5730\u5740=" + outerAddress);
_this.bufferList.pushBuffer(outerAddress, 'end');
_this.bufferList.sendAll(outerAddress, _this.innerSocketList);
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
};
return ReverseProxyServer;
}(socket_1.SocketServer));
exports.ReverseProxyServer = ReverseProxyServer;
/**
* 反向代理客户端
*/
var ReverseProxyClient = /** @class */ (function (_super) {
__extends(ReverseProxyClient, _super);
/**
* 构造函数
* @param proxyPort 要代理的端口
* @param proxyServer 代理服务器地址
* @param proxyServerPort 代理服务端口
* @param targetServer 目标服务器
* @param targetServerPort 目标端口
*/
function ReverseProxyClient(serverID, password, proxyPort, proxyServer, proxyServerPort, targetServer, targetServerPort) {
var _this = _super.call(this) || this;
_this.serverID = serverID;
_this.password = password;
_this.proxyPort = proxyPort;
_this.proxyServer = proxyServer;
_this.proxyServerPort = proxyServerPort;
_this.targetServer = targetServer;
_this.targetServerPort = targetServerPort;
/**
* 发送到Target的缓冲区
*/
_this.bufferListToTarget = new SocketBufferQueueList();
/**
* 代理服务列表
*/
_this.proxySocketList = {};
/**
* 目标服务列表
*/
_this.targetSocketList = {};
return _this;
}
/**
* 等待结束
*/
ReverseProxyClient.prototype.waitForExit = function () {
return __awaiter(this, void 0, void 0, function () {
var intervalID, reconnectTime, that;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
reconnectTime = 1000 * 30;
that = this;
return [4 /*yield*/, new Promise(function (resolve, reject) {
var reconnect = function () {
// 每30秒检测一次客户端是否断开，如果断开则重新连接
if (!that.proxyServerMainSocket) {
that.connectProxyServer();
}
setTimeout(reconnect, reconnectTime);
};
setTimeout(reconnect, reconnectTime);
})];
case 1:
_a.sent();
clearInterval(intervalID);
return [2 /*return*/];
}
});
});
};
/**
* 连接代理服务器
*/
ReverseProxyClient.prototype.connectProxyServer = function () {
var _this = this;
this.proxyServerMainSocket = new TCP.Socket();
var proxyAddress = socket_1.getSocketRemoteAddress(this.proxyServerMainSocket);
// 数据转发
this.proxyServerMainSocket.on('data', function (data) {
try {
pao_aop_1.log('proxyClient', "ProxyMain => Data(\u5927\u5C0F=" + data.length + ")");
var bufferReader = new index_1.BufferReader(data);
while (!bufferReader.isEnd) {
var command = bufferReader.readUInt32BE();
if (command === Command.CommandConnect) {
var outerAddress = bufferReader.readString(StringEncoding);
_this.connectSockets(outerAddress);
}
}
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
this.proxyServerMainSocket.on('error', function (error) {
pao_aop_1.log('proxyClient', new Error("\u4EE3\u7406\u8FDE\u63A5" + proxyAddress + "\u5F02\u5E38: " + error));
});
this.proxyServerMainSocket.on('timeout', function () {
pao_aop_1.log('proxyClient', new Error("\u4EE3\u7406\u8FDE\u63A5" + proxyAddress + "\u8D85\u65F6"));
});
this.proxyServerMainSocket.on('close', function (had_error) {
pao_aop_1.log('proxyClient', "\u4EE3\u7406\u8FDE\u63A5" + proxyAddress + "\u5173\u95ED");
_this.proxyServerMainSocket = undefined;
});
this.proxyServerMainSocket.once('connect', function () {
pao_aop_1.log('proxyClient', "\u4EE3\u7406\u670D\u52A1\u5668" + socket_1.getSocketRemoteAddress(_this.proxyServerMainSocket) + "\u8FDE\u63A5\u6210\u529F");
// 向代理服务器通发送服务ID，准备启动代理
socket_1.writeDataToSocket(_this.proxyServerMainSocket, function (bufferWriter) {
bufferWriter.writeUInt32BE(Command.CommandConnect);
bufferWriter.writeString(_this.serverID); // serverID
bufferWriter.writeString(_this.password); // password
pao_aop_1.log('proxyClient', "Connect => ProxyMain(\u5927\u5C0F=" + bufferWriter.bufferSize + ")");
});
});
pao_aop_1.log('proxyClient', "\u5F00\u59CB\u8FDE\u63A5\u4EE3\u7406\u670D\u52A1\u5668" + this.proxyServer + ":" + this.proxyServerPort);
this.proxyServerMainSocket.connect(this.proxyServerPort, this.proxyServer);
};
ReverseProxyClient.prototype.onStart = function () {
this.connectProxyServer();
this.waitForExit();
};
ReverseProxyClient.prototype.connectSockets = function (outerAddress) {
var _this = this;
var proxySocket = new TCP.Socket();
proxySocket.on('error', function (error) {
pao_aop_1.log('proxyClient', new Error("\u4EE3\u7406\u8FDE\u63A5\u5F02\u5E38: " + error + ", \u5916\u7F51\u5730\u5740:" + outerAddress));
_this.bufferListToTarget.pushBuffer(outerAddress, error);
waitForSocketCreated(outerAddress, _this.targetSocketList);
_this.bufferListToTarget.sendAll(outerAddress, _this.targetSocketList);
});
proxySocket.on('timeout', function () {
pao_aop_1.log('proxyClient', new Error("\u4EE3\u7406\u8FDE\u63A5\u8D85\u65F6, \u5916\u7F51\u5730\u5740:" + outerAddress));
});
proxySocket.on('close', function (had_error) {
pao_aop_1.log('proxyClient', "\u4EE3\u7406\u8FDE\u63A5\u5173\u95ED, \u5916\u7F51\u5730\u5740:" + outerAddress);
var targetSocket = _this.targetSocketList[outerAddress];
if (targetSocket) {
targetSocket.destroy();
}
delete _this.targetSocketList[outerAddress];
delete _this.proxySocketList[outerAddress];
});
// 数据转发 TargetServer -> ProxyServer
proxySocket.on('data', function (data) {
try {
pao_aop_1.log('proxyClient', "Proxy => Data(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740:" + outerAddress);
_this.bufferListToTarget.pushBuffer(outerAddress, data);
waitForSocketCreated(outerAddress, _this.targetSocketList);
_this.bufferListToTarget.sendAll(outerAddress, _this.targetSocketList);
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
proxySocket.on('end', function () {
try {
pao_aop_1.log('proxyClient', "Proxy => End(\u5916\u7F51\u5730\u5740=" + outerAddress + ")");
_this.bufferListToTarget.pushBuffer(outerAddress, 'end');
waitForSocketCreated(outerAddress, _this.targetSocketList);
_this.bufferListToTarget.sendAll(outerAddress, _this.targetSocketList);
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
proxySocket.once('connect', function () {
try {
pao_aop_1.log('proxyClient', "\u4EE3\u7406\u670D\u52A1\u5668" + socket_1.getSocketRemoteAddress(proxySocket) + "\u8FDE\u63A5\u6210\u529F, \u5916\u7F51\u5730\u5740:" + outerAddress);
// 向代理服务器通知建立代理端口
socket_1.writeDataToSocket(proxySocket, function (bufferWriter) {
bufferWriter.writeUInt32BE(Command.CommandProxy);
bufferWriter.writeString(_this.serverID);
bufferWriter.writeString(outerAddress);
pao_aop_1.log('proxyClient', "Connect => Proxy(\u5927\u5C0F=" + bufferWriter.bufferSize + ")");
});
// 代理服务器连接成功后连接目标服务器
_this.connectTargetSocket(outerAddress);
// 代理连接建立后转发数据
_this.proxySocketList[outerAddress] = proxySocket;
waitForSocketCreated(outerAddress, _this.targetSocketList);
_this.bufferListToTarget.sendAll(outerAddress, _this.targetSocketList);
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
// 连接目标服务器
pao_aop_1.log('proxyClient', "\u5F00\u59CB\u8FDE\u63A5\u4EE3\u7406\u670D\u52A1\u5668" + this.proxyServer + ":" + this.proxyServerPort + ", \u5916\u7F51\u5730\u5740:" + outerAddress);
proxySocket.connect(this.proxyServerPort, this.proxyServer);
};
/**
* 连接目标服务器
*/
ReverseProxyClient.prototype.connectTargetSocket = function (outerAddress) {
var _this = this;
var targetSocket = new TCP.Socket();
targetSocket.on('error', function (error) {
pao_aop_1.log('proxyClient', "\u76EE\u6807\u8FDE\u63A5\u5F02\u5E38: " + error + ", \u5916\u7F51\u5730\u5740:" + outerAddress);
var proxySocket = _this.proxySocketList[outerAddress];
if (proxySocket) {
pao_aop_1.log('proxyClient', "Error => Proxy(\u5916\u7F51\u5730\u5740=" + outerAddress + ")");
proxySocket.destroy(error);
}
});
targetSocket.on('timeout', function () {
pao_aop_1.log('proxyClient', "\u76EE\u6807\u8FDE\u63A5\u8D85\u65F6, \u5916\u7F51\u5730\u5740:" + outerAddress);
});
targetSocket.on('close', function (had_error) {
pao_aop_1.log('proxyClient', "\u76EE\u6807\u8FDE\u63A5\u5173\u95ED(\u5916\u7F51\u5730\u5740:" + outerAddress + ")");
var proxySocket = _this.proxySocketList[outerAddress];
if (proxySocket) {
proxySocket.destroy();
}
delete _this.proxySocketList[outerAddress];
delete _this.targetSocketList[outerAddress];
});
// 数据转发 TargetServer -> ProxyServer
targetSocket.on('data', function (data) {
pao_aop_1.log('proxyClient', "Target => Data(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740=" + outerAddress + ")");
var proxySocket = _this.proxySocketList[outerAddress];
pao_aop_1.log('proxyClient', "Data => Proxy(\u5927\u5C0F=" + data.length + ", \u5916\u7F51\u5730\u5740=" + outerAddress + ")");
waitForSocketCreated(outerAddress, _this.proxySocketList);
proxySocket.write(data);
});
targetSocket.on('end', function () {
pao_aop_1.log('proxyClient', "Target => End(\u5916\u7F51\u5730\u5740=" + outerAddress + ")");
var proxySocket = _this.proxySocketList[outerAddress];
if (proxySocket) {
pao_aop_1.log('proxyClient', "End => Proxy(\u5916\u7F51\u5730\u5740=" + outerAddress + ")");
proxySocket.end();
}
});
targetSocket.once('connect', function () {
try {
pao_aop_1.log('proxyClient', "\u76EE\u6807\u670D\u52A1\u5668" + socket_1.getSocketRemoteAddress(targetSocket) + "\u8FDE\u63A5\u6210\u529F, \u5916\u7F51\u5730\u5740:" + outerAddress);
_this.targetSocketList[outerAddress] = targetSocket;
}
catch (error) {
pao_aop_1.log('proxyServer', error, 'error');
}
});
// 连接目标服务器
pao_aop_1.log('proxyClient', "\u5F00\u59CB\u8FDE\u63A5\u76EE\u6807\u670D\u52A1\u5668" + this.targetServer + ":" + this.targetServerPort + ", \u5916\u7F51\u5730\u5740:" + outerAddress);
targetSocket.connect(this.targetServerPort, this.targetServer);
};
return ReverseProxyClient;
}(base_1.BaseServer));
exports.ReverseProxyClient = ReverseProxyClient;
});
//# sourceMappingURL=reverseProxy.js.map