619 lines
20 KiB
TypeScript
619 lines
20 KiB
TypeScript
/*
|
|
* @project: TERA
|
|
* @version: Development (beta)
|
|
* @license: MIT (not for evil)
|
|
* @copyright: Yuriy Ivanov (Vtools) 2017-2019 [progr76@gmail.com]
|
|
* Web: https://terafoundation.org
|
|
* Twitter: https://twitter.com/terafoundation
|
|
* Telegram: https://t.me/terafoundation
|
|
*/
|
|
|
|
"use strict";
|
|
import "./library"
|
|
import * as net from "net"
|
|
import { secp256k1, RBTree } from '../core/library'
|
|
var ConnectIDCount = 1;
|
|
export class TeraSocket extends net.Socket {
|
|
ConnectToServer: boolean;
|
|
Node: CNode;
|
|
ConnectID: string;
|
|
WasClose: number;
|
|
SocketStatus: number;
|
|
Buf: Buffer;
|
|
SocketNum: number;
|
|
SocketPrioritet: number;
|
|
}
|
|
export default class CNode {
|
|
addrStr
|
|
ip
|
|
port
|
|
StartFindList
|
|
WhiteConnect
|
|
GrayConnect
|
|
POW
|
|
FirstTime
|
|
FirstTimeStr
|
|
LastTime
|
|
LastTimeError
|
|
LastTimeTransfer
|
|
FromIP
|
|
FromPort
|
|
Active
|
|
Hot
|
|
CanHot
|
|
CountChildConnect
|
|
BlockProcessCount
|
|
VersionOK
|
|
VersionNum
|
|
Delete
|
|
DeltaBan
|
|
Name
|
|
Info
|
|
PrevInfo
|
|
StartTimeHot
|
|
NextHotDelta
|
|
LastTimeGetNode
|
|
DeltaGlobTime
|
|
CountDeltaTime
|
|
DeltaTime
|
|
SumDeltaTime
|
|
TransferCount
|
|
StopGetBlock
|
|
LevelCount
|
|
LevelEnum
|
|
TimeMap
|
|
bInit
|
|
INFO
|
|
DoubleConnectCount
|
|
StartTimeConnect
|
|
NextConnectDelta
|
|
StartTimeGetNodes
|
|
NextGetNodesDelta
|
|
PingStart
|
|
NextPing
|
|
SendBlockArr
|
|
LoadBlockArr
|
|
SendBlockCount
|
|
LoadBlockCount
|
|
SendBlockCountAll
|
|
LoadBlockCountAll
|
|
WantHardTrafficArr
|
|
WantHardTraffic
|
|
CanHardTraffic
|
|
BufWriteLength
|
|
BufWrite
|
|
SendPacket: RBTree<any>
|
|
ConnectCount
|
|
TrafficArr
|
|
SendTrafficCurrent
|
|
SendTrafficLimit
|
|
ErrCount
|
|
ErrCountAll
|
|
SendPacketNum
|
|
Socket: TeraSocket
|
|
Socket2: TeraSocket
|
|
ReconnectFromServer
|
|
SecretForReconnect
|
|
Self: boolean
|
|
addrStrTemp
|
|
DoubleConnection
|
|
PubKey
|
|
addrArr
|
|
SocketStart
|
|
WaitConnectFromServer
|
|
WaitConnectIP
|
|
constructor(addrStr, ip, port) {
|
|
this.addrStr = addrStr
|
|
this.ip = ip.trim()
|
|
this.port = port
|
|
this.StartFindList = 0
|
|
this.WhiteConnect = 0
|
|
this.GrayConnect = 0
|
|
this.POW = 0
|
|
this.FirstTime = 0
|
|
this.FirstTimeStr = ""
|
|
this.LastTime = 0
|
|
this.LastTimeError = 0
|
|
this.LastTimeTransfer = 0
|
|
this.FromIP = undefined
|
|
this.FromPort = undefined
|
|
this.Active = false
|
|
this.Hot = false
|
|
this.CanHot = false
|
|
this.CountChildConnect = 0
|
|
this.BlockProcessCount = 0
|
|
this.VersionOK = false
|
|
this.VersionNum = 0
|
|
this.Delete = 0
|
|
this.DeltaBan = 300
|
|
this.Name = ""
|
|
this.Info = ""
|
|
this.PrevInfo = ""
|
|
this.StartTimeHot = 0
|
|
this.NextHotDelta = 1000
|
|
this.ResetNode()
|
|
}
|
|
ResetNode() {
|
|
this.LastTimeGetNode = 0
|
|
this.DeltaGlobTime = 0
|
|
this.CountDeltaTime = 0
|
|
this.DeltaTime = 1000
|
|
this.SumDeltaTime = 0
|
|
this.TransferCount = 0
|
|
this.StopGetBlock = 0
|
|
this.LevelCount = 0
|
|
this.LevelEnum = 100
|
|
this.TimeMap = {}
|
|
this.bInit = 1
|
|
this.INFO = {}
|
|
this.DoubleConnectCount = 0
|
|
this.StartTimeConnect = 0
|
|
this.NextConnectDelta = 1000
|
|
this.StartTimeGetNodes = 0
|
|
this.NextGetNodesDelta = 1000
|
|
this.PingStart = 0
|
|
this.NextPing = global.MIN_PERIOD_PING
|
|
this.SendBlockArr = []
|
|
this.LoadBlockArr = []
|
|
this.SendBlockCount = 0
|
|
this.LoadBlockCount = 0
|
|
this.SendBlockCountAll = 0
|
|
this.LoadBlockCountAll = 0
|
|
this.WantHardTrafficArr = []
|
|
this.WantHardTraffic = 0
|
|
this.CanHardTraffic = 0
|
|
this.BufWriteLength = 0
|
|
this.BufWrite = Buffer.alloc(0)
|
|
this.SendPacket = new RBTree(function(a, b) {
|
|
return b.PacketNum - a.PacketNum;
|
|
} as any)
|
|
this.ConnectCount = 0
|
|
this.TrafficArr = []
|
|
this.SendTrafficCurrent = 0
|
|
this.SendTrafficLimit = 0
|
|
this.ErrCount = 0
|
|
this.ErrCountAll = 0
|
|
var Prioritet = this.BlockProcessCount;
|
|
global.SERVER.SetNodePrioritet(this, Prioritet)
|
|
this.SendPacketNum = 0
|
|
}
|
|
ConnectStatus() {
|
|
if (this.Socket)
|
|
return GetSocketStatus(this.Socket);
|
|
else
|
|
return 0;
|
|
}
|
|
CreateConnect() {
|
|
delete global.SERVER.BAN_IP[this.ip]
|
|
let NODE = this;
|
|
if (NODE.ConnectStatus()) {
|
|
if (NODE.ConnectStatus() === 100)
|
|
global.SERVER.AddNodeToActive(NODE)
|
|
return;
|
|
}
|
|
global.AddNodeInfo(NODE, "===CreateConnect===")
|
|
global.CloseSocket(NODE.Socket, "CreateConnect")
|
|
NODE.SocketStart = Date.now()
|
|
NODE.Socket = net.createConnection(NODE.port, NODE.ip, function() {
|
|
if (NODE.Socket) {
|
|
global.socketInit(NODE.Socket, "s")
|
|
global.AddNodeInfo(NODE, "OK connected *" + NODE.Socket.ConnectID)
|
|
NODE.Socket.ConnectToServer = true
|
|
SetSocketStatus(NODE.Socket, 2)
|
|
}
|
|
}) as TeraSocket
|
|
SetSocketStatus(NODE.Socket, 1)
|
|
NODE.Socket.Node = NODE
|
|
NODE.Socket.ConnectID = "~C" + ConnectIDCount
|
|
ConnectIDCount++
|
|
this.SetEventsProcessing(NODE.Socket, 0)
|
|
}
|
|
CreateReconnection() {
|
|
let NODE = this;
|
|
global.AddNodeInfo(NODE, "===CreateReconnection===")
|
|
global.CloseSocket(NODE.Socket2, "CreateReconnection")
|
|
NODE.SocketStart = Date.now()
|
|
NODE.Socket2 = net.createConnection(NODE.port, NODE.ip, function() {
|
|
if (NODE.Socket2) {
|
|
global.socketInit(NODE.Socket2, "s")
|
|
global.AddNodeInfo(NODE, "OK Reconnected *" + NODE.Socket2.ConnectID)
|
|
NODE.Socket2.ConnectToServer = true
|
|
SetSocketStatus(NODE.Socket2, 2)
|
|
}
|
|
}) as TeraSocket
|
|
SetSocketStatus(NODE.Socket2, 1)
|
|
NODE.Socket2.Node = NODE
|
|
NODE.Socket2.ConnectID = "~R" + ConnectIDCount
|
|
ConnectIDCount++
|
|
this.SetEventsProcessing(NODE.Socket2, 1)
|
|
}
|
|
SwapSockets() {
|
|
if (!this.Socket2)
|
|
return;
|
|
var SocketOld = this.Socket;
|
|
this.Socket = this.Socket2
|
|
this.Socket2 = undefined
|
|
this.Socket.Node = this
|
|
SetSocketStatus(this.Socket, 100)
|
|
this.Socket.Buf = SocketOld.Buf
|
|
global.SERVER.LoadBufSocketList.remove(SocketOld)
|
|
global.SERVER.LoadBufSocketList.insert(this.Socket)
|
|
SocketOld.Buf = undefined
|
|
SocketOld.WasClose = 1
|
|
SocketOld.Node = undefined
|
|
this.ErrCount = 0
|
|
}
|
|
SetEventsProcessing(Socket, Reconnection) {
|
|
let SOCKET = Socket;
|
|
let NODE = this;
|
|
let RECONNECTION = Reconnection;
|
|
SOCKET.on('data', function(data) {
|
|
if (Socket.WasClose)
|
|
return;
|
|
if (GetSocketStatus(SOCKET) === 2) {
|
|
SetSocketStatus(SOCKET, 3)
|
|
var Buf = global.SERVER.GetDataFromBuf(data);
|
|
if (Buf) {
|
|
var Res = NODE.SendPOWFromClientToServer(SOCKET, Buf.Data);
|
|
if (Res) {
|
|
return;
|
|
}
|
|
}
|
|
global.CloseSocket(SOCKET, Buf ? "Method=" + Buf.Method : "=CLIENT ON DATA=")
|
|
}
|
|
else
|
|
if (GetSocketStatus(SOCKET) === 3) {
|
|
var Buf = global.SERVER.GetDataFromBuf(data);
|
|
if (Buf) {
|
|
var Str = Buf.Data;
|
|
if (Str && Str.substr(0, 24) === "WAIT_CONNECT_FROM_SERVER") {
|
|
global.AddNodeInfo(NODE, "2. CLIENT OK POW")
|
|
global.CloseSocket(SOCKET, "WAIT_CONNECT_FROM_SERVER")
|
|
NODE.WaitConnectFromServer = 1
|
|
NODE.WaitConnectIP = NODE.ip
|
|
try {
|
|
NODE.SecretForReconnect = global.GetArrFromHex(Str.substr(25))
|
|
}
|
|
catch (e) {
|
|
NODE.SecretForReconnect = []
|
|
global.ToLog(e)
|
|
}
|
|
}
|
|
else
|
|
if (Str === "OK") {
|
|
NODE.NextConnectDelta = 1000
|
|
SetSocketStatus(SOCKET, 100)
|
|
global.AddNodeInfo(NODE, "4. CLIENT OK CONNECT")
|
|
if (RECONNECTION) {
|
|
if (NODE.Socket)
|
|
SetSocketStatus(NODE.Socket, 200)
|
|
}
|
|
else {
|
|
if (!NODE.Active)
|
|
global.SERVER.AddNodeToActive(NODE)
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
if (Str === "SELF") {
|
|
NODE.Self = true
|
|
}
|
|
else
|
|
if (Str === "DOUBLE") {
|
|
}
|
|
else {
|
|
global.AddNodeInfo(NODE, "ERROR:" + Str)
|
|
}
|
|
}
|
|
global.CloseSocket(SOCKET, Buf ? "Method=" + Buf.Method + ":" + Str : "=CLIENT ON DATA=")
|
|
}
|
|
else {
|
|
global.socketRead(Socket, data)
|
|
global.SERVER.OnGetFromTCP(NODE, Socket, data)
|
|
}
|
|
})
|
|
SOCKET.on('end', function() {
|
|
if (GetSocketStatus(SOCKET))
|
|
global.AddNodeInfo(NODE, "Get socket end *" + SOCKET.ConnectID + " Stat: " + SocketStatistic(SOCKET))
|
|
if (GetSocketStatus(SOCKET) === 200) {
|
|
NODE.SwapSockets()
|
|
SOCKET.WasClose = 1
|
|
}
|
|
})
|
|
SOCKET.on('close', function(err) {
|
|
if (SOCKET.ConnectID && GetSocketStatus(SOCKET))
|
|
global.AddNodeInfo(NODE, "Get socket close *" + SOCKET.ConnectID + " Stat: " + SocketStatistic(SOCKET))
|
|
if (!SOCKET.WasClose) {
|
|
if (GetSocketStatus(SOCKET) >= 2) {
|
|
global.CloseSocket(SOCKET, "GET CLOSE")
|
|
}
|
|
}
|
|
SetSocketStatus(SOCKET, 0)
|
|
})
|
|
SOCKET.on('error', function(err) {
|
|
if (GetSocketStatus(SOCKET) >= 2) {
|
|
global.SERVER.AddCheckErrCount(NODE, 1, "ERR##1 : socket")
|
|
global.ADD_TO_STAT("ERRORS")
|
|
}
|
|
})
|
|
}
|
|
SendPOWFromClientToServer(Socket, data) {
|
|
var Node = this;
|
|
if (Node.ReconnectFromServer) {
|
|
Node.ReconnectFromServer = 0
|
|
var Info = this.GetPOWClientData(0);
|
|
Info.Reconnect = 1
|
|
Info.SecretForReconnect = Node.SecretForReconnect
|
|
var BufWrite = global.BufLib.GetBufferFromObject(Info, global.FORMAT_POW_TO_SERVER, 1200, {});
|
|
var BufAll = global.SERVER.GetBufFromData("POW_CONNECT7", BufWrite, 1);
|
|
Socket.write(BufAll)
|
|
return 1;
|
|
}
|
|
try {
|
|
var Buf = global.BufLib.GetObjectFromBuffer(data, global.FORMAT_POW_TO_CLIENT, {});
|
|
} catch (e) {
|
|
global.SERVER.SendCloseSocket(Socket, "FORMAT_POW_TO_CLIENT")
|
|
return 0;
|
|
}
|
|
if (global.CompareArr(Buf.addrArr, global.SERVER.addrArr) === 0) {
|
|
Node.Self = true
|
|
global.AddNodeInfo(Node, "END: SELF")
|
|
global.SERVER.SendCloseSocket(Socket, "SELF")
|
|
return;
|
|
}
|
|
var addrStr = global.GetHexFromAddres(Buf.addrArr);
|
|
if (!Node.StartFindList && addrStr !== Node.addrStr) {
|
|
global.AddNodeInfo(Node, "END: CHANGED ADDR: " + Node.addrStr.substr(0, 16) + "->" + addrStr.substr(0, 16))
|
|
global.SERVER.SendCloseSocket(Socket, "ADDRESS_HAS_BEEN_CHANGED")
|
|
return;
|
|
}
|
|
if (Node.addrStrTemp) {
|
|
global.AddNodeInfo(Node, "Set Addr = " + addrStr)
|
|
Node.addrStr = addrStr
|
|
global.SERVER.CheckNodeMap(Node)
|
|
}
|
|
var Result = false;
|
|
if (Buf.PubKeyType === 2 || Buf.PubKeyType === 3) {
|
|
Result = secp256k1.verify(Buffer.from(global.shaarr(addrStr)), Buffer.from(Buf.Sign), Buffer.from([Buf.PubKeyType].concat(Buf.addrArr)))
|
|
if (!Result) {
|
|
Result = secp256k1.verify(Buffer.from(global.sha3(addrStr)), Buffer.from(Buf.Sign), Buffer.from([Buf.PubKeyType].concat(Buf.addrArr)))
|
|
}
|
|
}
|
|
if (!Result) {
|
|
global.ToLog("END: ERROR_SIGN_SERVER ADDR: " + addrStr.substr(0, 16) + " from ip: " + Socket.remoteAddress)
|
|
global.AddNodeInfo(Node, "END: ERROR_SIGN_SERVER ADDR: " + addrStr.substr(0, 16) + " from ip: " + Socket.remoteAddress)
|
|
global.SERVER.SendCloseSocket(Socket, "ERROR_SIGN_SERVER")
|
|
return;
|
|
}
|
|
if (Buf.MIN_POWER_POW_HANDSHAKE > 1 + global.MIN_POWER_POW_HANDSHAKE) {
|
|
global.ToLog("END: BIG_MIN_POWER_POW_HANDSHAKE ADDR: " + addrStr.substr(0, 16) + " from ip: " + Socket.remoteAddress)
|
|
return 0;
|
|
}
|
|
var TestNode = global.SERVER.NodesMap[addrStr];
|
|
if (TestNode && TestNode !== Node) {
|
|
if (GetSocketStatus(TestNode.Socket)) {
|
|
global.AddNodeInfo(Node, "DoubleConnection find")
|
|
Node.DoubleConnection = true
|
|
return 0;
|
|
}
|
|
else {
|
|
global.AddNodeInfo(Node, "DoubleConnection find")
|
|
TestNode.DoubleConnection = true
|
|
}
|
|
}
|
|
Node.PubKey = Buffer.from([Buf.PubKeyType].concat(Buf.addrArr))
|
|
Node.addrArr = Buf.addrArr
|
|
Node.addrStr = addrStr
|
|
if (global.CompareArr(global.SERVER.addrArr, Node.addrArr) === 0) {
|
|
Node.Self = true
|
|
return 0;
|
|
}
|
|
var Hash = global.shaarr2(Buf.addrArr, Buf.HashRND);
|
|
var nonce = global.CreateNoncePOWExternMinPower(Hash, 0, Buf.MIN_POWER_POW_HANDSHAKE);
|
|
var Info;
|
|
if (global.WALLET.WalletOpen && global.IsDeveloperAccount(global.WALLET.PubKeyArr)) {
|
|
Info = this.GetPOWClientData(0)
|
|
Info.Reconnect = 255
|
|
Info.Sign = secp256k1.sign(global.SHA3BUF(Hash), global.WALLET.KeyPair.getPrivateKey('')).signature
|
|
Result = global.CheckDevelopSign(Hash, Info.Sign)
|
|
if (!Result) {
|
|
throw "ERROR DEVELOPSIGN!";
|
|
}
|
|
}
|
|
else {
|
|
Info = this.GetPOWClientData(nonce)
|
|
Info.PubKeyType = global.SERVER.PubKeyType
|
|
Info.Sign = secp256k1.sign(Buffer.from(Hash), global.SERVER.KeyPair.getPrivateKey('')).signature
|
|
}
|
|
var BufWrite = global.BufLib.GetBufferFromObject(Info, global.FORMAT_POW_TO_SERVER, 1200, {});
|
|
var BufAll = global.SERVER.GetBufFromData("POW_CONNECT6", BufWrite, 1);
|
|
Socket.write(BufAll)
|
|
return 1;
|
|
}
|
|
GetPOWClientData(nonce) {
|
|
var Node = this;
|
|
var Info: any = {};
|
|
Info.DEF_NETWORK = global.GetNetworkName()
|
|
Info.DEF_VERSION = global.DEF_VERSION
|
|
Info.DEF_CLIENT = global.DEF_CLIENT
|
|
Info.addrArr = global.SERVER.addrArr
|
|
Info.ToIP = Node.ip
|
|
Info.ToPort = Node.port
|
|
Info.FromIP = global.SERVER.ip
|
|
Info.FromPort = global.SERVER.port
|
|
Info.nonce = nonce
|
|
Info.Reconnect = 0
|
|
Info.SendBytes = 0
|
|
Info.SecretForReconnect = []
|
|
Info.Reserv = []
|
|
if (global.GrayConnect())
|
|
Info.GrayConnect = 1
|
|
return Info;
|
|
}
|
|
write(BufWrite) {
|
|
if (!this.Socket)
|
|
return;
|
|
global.socketWrite(this.Socket, BufWrite)
|
|
try {
|
|
this.Socket.write(BufWrite)
|
|
}
|
|
catch (e) {
|
|
global.ToError(e)
|
|
this.Socket.WasClose = 1
|
|
this.Socket.SocketStatus = 0
|
|
this.Socket.Node = undefined
|
|
}
|
|
}
|
|
};
|
|
global.socketInit = function(Socket, Str) {
|
|
if (!Socket)
|
|
return;
|
|
Socket.GetBytes = 0;
|
|
Socket.SendBytes = 0;
|
|
Socket.ConnectID = "" + ConnectIDCount + Str;
|
|
ConnectIDCount++;
|
|
};
|
|
global.socketRead = function(Socket, Buf) {
|
|
Socket.GetBytes += Buf.length;
|
|
};
|
|
global.socketWrite = function(Socket, Buf) {
|
|
Socket.SendBytes += Buf.length;
|
|
};
|
|
global.CloseSocket = function(Socket, StrError?, bHide?) {
|
|
if (!Socket || Socket.WasClose) {
|
|
if (Socket)
|
|
Socket.SocketStatus = 0;
|
|
return;
|
|
}
|
|
var Node = Socket.Node;
|
|
if (Socket.Node && Socket.Node.Socket2 === Socket && Socket.Node.Socket && Socket.Node.Socket.SocketStatus === 200)
|
|
SetSocketStatus(Socket.Node.Socket, 100);
|
|
var StrNode = NodeInfo(Socket.Node);
|
|
Socket.WasClose = 1;
|
|
Socket.SocketStatus = 0;
|
|
Socket.Node = undefined;
|
|
Socket.end();
|
|
if (!bHide)
|
|
global.AddNodeInfo(Node, "CLOSE " + StrNode + " *" + Socket.ConnectID + " - " + StrError);
|
|
};
|
|
|
|
function SetSocketStatus(Socket, Status) {
|
|
if (Socket && Socket.SocketStatus !== Status) {
|
|
if (Status === 100 && (Socket.SocketStatus !== 3 && Socket.SocketStatus !== 200)) {
|
|
global.ToLogTrace("===================ERROR=================== " + Status);
|
|
return;
|
|
}
|
|
if (Status === 100 && Socket.Node)
|
|
Socket.Node.LastTime = global.GetCurrentTime() - 0;
|
|
Socket.SocketStatus = Status;
|
|
Socket.TimeStatus = Date.now();
|
|
}
|
|
};
|
|
|
|
function GetSocketStatus(Socket) {
|
|
if (Socket && Socket.SocketStatus) {
|
|
if (Socket.SocketStatus !== 100) {
|
|
var Delta = Date.now() - Socket.TimeStatus;
|
|
if (Delta > global.MAX_WAIT_PERIOD_FOR_STATUS) {
|
|
global.CloseSocket(Socket, "MAX_WAIT_PERIOD_FOR_STATUS = " + Socket.SocketStatus + " time = " + Delta);
|
|
}
|
|
}
|
|
return Socket.SocketStatus;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
function SocketInfo(Socket) {
|
|
if (Socket)
|
|
return "*" + Socket.ConnectID;
|
|
else
|
|
return "";
|
|
};
|
|
|
|
function SocketStatistic(Socket) {
|
|
if (!Socket)
|
|
return "";
|
|
var Str = "";
|
|
if (!Socket.SendBytes)
|
|
Socket.SendBytes = 0;
|
|
if (!Socket.GetBytes)
|
|
Socket.GetBytes = 0;
|
|
if (Socket.SendBytes)
|
|
Str += " Send=" + Socket.SendBytes;
|
|
if (Socket.GetBytes)
|
|
Str += " Get=" + Socket.GetBytes;
|
|
if (GetSocketStatus(Socket))
|
|
Str += " SocketStatus=" + GetSocketStatus(Socket);
|
|
if (Str === "")
|
|
Str = "0";
|
|
return Str;
|
|
};
|
|
|
|
function NodeInfo(Node) {
|
|
if (Node)
|
|
return "" + Node.ip + ":" + Node.port + " " + SocketInfo(Node.Socket);
|
|
else
|
|
return "";
|
|
};
|
|
|
|
function NodeName(Node) {
|
|
if (!Node)
|
|
return "";
|
|
if (Node.Name)
|
|
return Node.Name;
|
|
if (global.LOCAL_RUN)
|
|
return "" + Node.port;
|
|
else {
|
|
return "" + Node.ip + ":" + Node.addrStr.substr(0, 6);
|
|
}
|
|
};
|
|
|
|
function FindNodeByAddr(Addr, bConnect) {
|
|
var Node = global.SERVER.NodesMap[Addr.trim()];
|
|
if (Node && Node.ConnectStatus() === 100)
|
|
return Node;
|
|
if (Node && bConnect) {
|
|
Node.NextConnectDelta = 1000;
|
|
global.SERVER.StartConnectTry(Node);
|
|
return false;
|
|
}
|
|
return undefined;
|
|
};
|
|
|
|
function AddNodeInfo(Node, Str, bSet) {
|
|
if (!global.STAT_MODE)
|
|
return;
|
|
if (!Node)
|
|
return;
|
|
if (!Node.Info)
|
|
Node.Info = "";
|
|
if (bSet) {
|
|
Node.Info = "";
|
|
}
|
|
else {
|
|
if (Node.Socket && Node.Socket.Info) {
|
|
Node.Info += Node.Socket.Info + "\n";
|
|
Node.Socket.Info = "";
|
|
}
|
|
}
|
|
if (Node.Info.length > 1000) {
|
|
Node.PrevInfo = Node.Info;
|
|
Node.Info = "";
|
|
}
|
|
{
|
|
var timesend = global.GetStrOnlyTimeUTC();
|
|
Str = timesend + " " + Str;
|
|
Node.Info += Str + "\n";
|
|
}
|
|
};
|
|
global.SocketStatistic = SocketStatistic;
|
|
global.GetSocketStatus = GetSocketStatus;
|
|
global.SetSocketStatus = SetSocketStatus;
|
|
global.NodeInfo = NodeInfo;
|
|
global.NodeName = NodeName;
|
|
global.SocketInfo = SocketInfo;
|
|
global.FindNodeByAddr = FindNodeByAddr;
|
|
global.AddNodeInfo = AddNodeInfo;
|