1079 lines
42 KiB
TypeScript
1079 lines
42 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 * as net from 'net'
|
|
// import dgram = require("dgram");
|
|
import * as crypto from 'crypto';
|
|
import { secp256k1, RBTree } from "./library"
|
|
import "./crypto-library"
|
|
import CConnect from './connect'
|
|
import { STreeBuffer } from './base';
|
|
import CNode, { TeraSocket } from './node';
|
|
const HARD_PACKET_PERIOD = 20;
|
|
global.BUF_TYPE = 1;
|
|
global.STR_TYPE = 2;
|
|
global.MAX_STR_BUF_DATA = 200;
|
|
global.MAX_CONNECTION_ACTIVE = 40;
|
|
var MAX_CONNECTION_ANOTHER = 40;
|
|
const TRAFIC_LIMIT_NODE_1S = global.MAX_BLOCK_SIZE * 1.25;
|
|
const TRAFIC_LIMIT_1S = 8 * TRAFIC_LIMIT_NODE_1S;
|
|
global.STAT_PERIOD = global.CONSENSUS_PERIOD_TIME / 5;
|
|
const TRAFIC_LIMIT_SEND = TRAFIC_LIMIT_1S * global.STAT_PERIOD / 1000;
|
|
const TRAFIC_LIMIT_NODE = TRAFIC_LIMIT_NODE_1S * global.STAT_PERIOD / 1000;
|
|
const BUF_PACKET_SIZE = 32 * 1024;
|
|
global.FORMAT_POW_TO_CLIENT = "{addrArr:hash,HashRND:hash,MIN_POWER_POW_HANDSHAKE:uint,PubKeyType:byte,Sign:arr64,Reserve:arr33}";
|
|
global.FORMAT_POW_TO_SERVER = "{\
|
|
DEF_NETWORK:str15,\
|
|
DEF_VERSION:str9,\
|
|
DEF_CLIENT:str16, \
|
|
addrArr:addres, \
|
|
ToIP:str26,\
|
|
ToPort:uint16, \
|
|
FromIP:str26,\
|
|
FromPort:uint16, \
|
|
nonce:uint,\
|
|
Reconnect:byte,\
|
|
SendBytes:uint,\
|
|
PubKeyType:byte,\
|
|
Sign:arr64,\
|
|
SecretForReconnect:arr20,\
|
|
GrayConnect:byte,\
|
|
Reserve:arr14\
|
|
}";
|
|
const WorkStructPacketSend = {};
|
|
const FORMAT_PACKET_SEND_TCP = "{\
|
|
PacketSize:uint,\
|
|
NumXORRND:uint,\
|
|
Method:str25,\
|
|
NodeTime:time,\
|
|
Length:uint,\
|
|
ContextID:hash,\
|
|
TypeData:byte,\
|
|
Hash:hash,\
|
|
Data:data,\
|
|
}";
|
|
export default class CTransport extends CConnect {
|
|
UseRNDHeader
|
|
BAN_IP
|
|
CanSend
|
|
SendFormatMap
|
|
ActualNodes
|
|
SendTrafficFree
|
|
LoadedPacketNum
|
|
LoadedSocketNum
|
|
LoadBufSocketList
|
|
BusyLevel
|
|
LastTimeHard
|
|
LastTimeHardOK
|
|
HardPacketForSend
|
|
MethodTiming
|
|
CurrentTimeStart
|
|
CurrentTimeValues
|
|
SendStatNum
|
|
Server
|
|
ServerSign
|
|
constructor(SetKeyPair, RunIP, RunPort, UseRNDHeader, bVirtual) {
|
|
super(SetKeyPair, RunIP, RunPort, UseRNDHeader, bVirtual)
|
|
this.UseRNDHeader = UseRNDHeader
|
|
this.BAN_IP = {}
|
|
this.ip = RunIP.trim()
|
|
this.port = RunPort
|
|
this.CanSend = 0
|
|
this.SendFormatMap = {}
|
|
this.ActualNodes = new RBTree(function(a: any, b: any): number {
|
|
if (b.Prioritet !== a.Prioritet)
|
|
return b.Prioritet - a.Prioritet;
|
|
return global.CompareArr(a.addrArr, b.addrArr);
|
|
})
|
|
this.SendTrafficFree = 0
|
|
this.LoadedPacketNum = 0
|
|
this.LoadedSocketNum = 0
|
|
setInterval(this.DoLoadBuf.bind(this), 1)
|
|
this.LoadBufSocketList = new RBTree(function(a: any, b: any): number {
|
|
if (b.SocketPrioritet !== a.SocketPrioritet)
|
|
return b.SocketPrioritet - a.SocketPrioritet;
|
|
return a.SocketNum - b.SocketNum;
|
|
})
|
|
this.BusyLevel = 0
|
|
this.LastTimeHard = 0
|
|
this.LastTimeHardOK = 0
|
|
setInterval(this.DoHardPacketForSend.bind(this), HARD_PACKET_PERIOD)
|
|
this.HardPacketForSend = new RBTree(function(a: any, b: any): number {
|
|
if (b.BlockProcessCount === a.BlockProcessCount)
|
|
return a.PacketNum - b.PacketNum;
|
|
else
|
|
return b.BlockProcessCount - a.BlockProcessCount;
|
|
})
|
|
setInterval(this.DoSendPacket.bind(this), 2)
|
|
setInterval(this.DoSendBuf.bind(this), 1)
|
|
var Map = {};
|
|
this.MethodTiming = Map
|
|
MethodTiming:
|
|
{
|
|
Map["TRANSFER"] = { Period: 700, Hot: 1 }
|
|
Map["TRANSFERTX"] = { Period: 700, Hot: 1 }
|
|
Map["TIME"] = { Period: 2000, LowVersion: 1, Hard: 1, Immediately: 1 }
|
|
Map["PING"] = { Period: 4000, LowVersion: 1, Hard: 1, Immediately: 1 }
|
|
Map["PONG"] = { Period: 0, LowVersion: 1, Immediately: 1 }
|
|
Map["ADDLEVELCONNECT"] = { Period: 1000, Hard: 1 }
|
|
Map["RETADDLEVELCONNECT"] = { Period: 0 }
|
|
Map["DISCONNECTHOT"] = { Period: 1000, Hard: 1 }
|
|
Map["GETMESSAGE"] = { Period: 1000, Hard: 1 }
|
|
Map["MESSAGE"] = { Period: 1000, Hard: 1 }
|
|
Map["TRANSACTION"] = { Period: global.PERIOD_GET_BLOCK, Hard: 1 }
|
|
Map["GETBLOCKHEADER"] = { Period: global.PERIOD_GET_BLOCK, Hard: 2, Process: global.STATIC_PROCESS }
|
|
Map["GETBLOCKHEADER100"] = { Period: global.PERIOD_GET_BLOCK, Hard: 2, Process: global.STATIC_PROCESS }
|
|
Map["GETBLOCK"] = { Period: global.PERIOD_GET_BLOCK, Hard: 2, Process: global.STATIC_PROCESS }
|
|
Map["GETNODES"] = { Period: 1000, Hard: 1, LowVersion: 1, IsAddrList: 1 }
|
|
Map["RETGETNODES"] = { Period: 0, IsAddrList: 1 }
|
|
Map["RETGETNODES2"] = { Period: 0, IsAddrList: 1 }
|
|
Map["GETCODE"] = { Period: 10000, Hard: 1, LowVersion: 1, Process: global.STATIC_PROCESS }
|
|
Map["RETBLOCKHEADER"] = { Period: 0 }
|
|
Map["RETBLOCKHEADER100"] = { Period: 0 }
|
|
Map["RETGETBLOCK"] = { Period: 0 }
|
|
Map["RETCODE"] = { Period: 0 }
|
|
Map["GETREST"] = { Period: 1000, Hard: 2, Process: global.STATIC_PROCESS }
|
|
Map["RETREST"] = { Period: 0 }
|
|
Map["GETSMART"] = { Period: 1000, Hard: 2, Process: global.STATIC_PROCESS }
|
|
Map["RETSMART"] = { Period: 0 }
|
|
}
|
|
if (!this.VirtualMode)
|
|
this.StartServer()
|
|
this.CurrentTimeStart = 0
|
|
this.CurrentTimeValues = {}
|
|
this.LoadNodesFromFile()
|
|
}
|
|
GetF(Method, bSend) {
|
|
var name = Method + "-" + bSend;
|
|
var format = this.SendFormatMap[name];
|
|
if (!format) {
|
|
var F = this.constructor[Method + "_F"];
|
|
if (typeof F === "function") {
|
|
format = { struct: F(bSend), length: 8096, wrk: {} }
|
|
}
|
|
else {
|
|
format = "{}"
|
|
}
|
|
this.SendFormatMap[name] = format
|
|
}
|
|
return format;
|
|
}
|
|
SendF(Node, Info, Length) {
|
|
var format = this.GetF(Info.Method, true);
|
|
if (!Length)
|
|
Length = format.length
|
|
Info.Data = global.BufLib.GetBufferFromObject(Info.Data, format.struct, Length, format.wrk)
|
|
this.Send(Node, Info, 1)
|
|
}
|
|
DataFromF(Info, bSendFormat?) {
|
|
var format = this.GetF(Info.Method, bSendFormat);
|
|
try {
|
|
var Data = global.BufLib.GetObjectFromBuffer(Info.Data, format.struct, format.wrk);
|
|
return Data;
|
|
}
|
|
catch (e) {
|
|
global.ToLog(e)
|
|
return {};
|
|
}
|
|
}
|
|
ADD_CURRENT_STAT_TIME(Key, Value) {
|
|
var TimeNum = Math.floor(Date.now() / global.STAT_PERIOD);
|
|
if (this.CurrentTimeStart !== TimeNum)
|
|
this.CurrentTimeValues = {}
|
|
this.CurrentTimeStart = TimeNum
|
|
if (!this.CurrentTimeValues[Key])
|
|
this.CurrentTimeValues[Key] = 0
|
|
this.CurrentTimeValues[Key] += Value
|
|
}
|
|
GET_CURRENT_STAT_TIME(Key) {
|
|
var TimeNum = Math.floor(Date.now() / global.STAT_PERIOD);
|
|
if (this.CurrentTimeStart === TimeNum) {
|
|
var Value = this.CurrentTimeValues[Key];
|
|
if (Value === undefined)
|
|
return 0;
|
|
else
|
|
return Value;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
RecalcSendStatictic() {
|
|
var TimeNum = Math.floor(Date.now() / global.STAT_PERIOD);
|
|
if (this.SendStatNum === TimeNum)
|
|
return;
|
|
this.SendStatNum = TimeNum
|
|
var Period = global.CONSENSUS_PERIOD_TIME / global.STAT_PERIOD;
|
|
this.SendTrafficFree = TRAFIC_LIMIT_SEND
|
|
var it = this.ActualNodes.iterator(), Node;
|
|
while ((Node = it.next()) !== null) {
|
|
{
|
|
var arr = Node.TrafficArr;
|
|
arr.push(Node.BufWriteLength)
|
|
Node.BufWriteLength = 0
|
|
if (arr.length > 5 * Period) {
|
|
arr.shift()
|
|
}
|
|
else {
|
|
if (arr.length < 3 * Period)
|
|
continue;
|
|
}
|
|
var arrAvg = [], arrK = [];
|
|
var valNext = CalcStatArr(arr, arrAvg, arrK, Period);
|
|
valNext = Math.min(valNext, TRAFIC_LIMIT_NODE)
|
|
Node.SendTrafficLimit = Math.min(this.SendTrafficFree, valNext * 1.1)
|
|
this.SendTrafficFree -= Node.SendTrafficLimit
|
|
}
|
|
Node.SendTrafficCurrent = 0
|
|
global.ADD_TO_STAT("MAX:NODE_TRAFFIC_LIMIT:" + global.NodeName(Node), 1000 / global.STAT_PERIOD * Node.SendTrafficLimit / 1024, 1)
|
|
}
|
|
this.SendTrafficFree += TRAFIC_LIMIT_NODE
|
|
global.ADD_TO_STAT("SEND_TRAFFIC_FREE", this.SendTrafficFree / 1024)
|
|
}
|
|
OnGetMethod(Info, CurTime) {
|
|
if (global.DEBUG_MODE) {
|
|
var Str = "";
|
|
if (Info.Data && Info.Data.Length)
|
|
Str = " LENGTH=" + Info.Data.Length
|
|
global.TO_DEBUG_LOG("GET:" + Info.Method + Str + " from: Node=" + global.NodeInfo(Info.Node))
|
|
}
|
|
if (global.ADDRLIST_MODE) {
|
|
var StrOK = ",HAND,GETNODES,";
|
|
if (StrOK.indexOf("," + Info.Method + ",") === - 1)
|
|
return;
|
|
}
|
|
Info.Node.LastTime = CurTime - 0
|
|
if (Info.Context && typeof Info.Context.F === "function") {
|
|
Info.Context.F(Info, CurTime)
|
|
}
|
|
else {
|
|
var F = this[Info.Method.toUpperCase()];
|
|
if (typeof F === "function") {
|
|
F.bind(this)(Info, CurTime)
|
|
}
|
|
else {
|
|
global.TO_ERROR_LOG("TRANSPORT", 20, "Method '" + Info.Method + "' not found Socket=*" + Info.Socket.ConnectID, "node", Info.Node)
|
|
this.AddCheckErrCount(Info.Node, 1, "Method not found")
|
|
}
|
|
}
|
|
}
|
|
GetActualNodes() {
|
|
var Arr = [];
|
|
var it = this.ActualNodes.iterator(), Item;
|
|
while ((Item = it.next()) !== null) {
|
|
if (global.GetSocketStatus(Item.Socket) >= 100)
|
|
Arr.push(Item)
|
|
else {
|
|
this.DeleteNodeFromActive(Item)
|
|
}
|
|
}
|
|
return Arr;
|
|
}
|
|
NodeIp(Node) {
|
|
if (Node.ip_arrival) {
|
|
return { ip: Node.ip_arrival, port: Node.port_arrival };
|
|
}
|
|
else {
|
|
return { ip: Node.ip, port: Node.port };
|
|
}
|
|
}
|
|
SetXORHeader(buf, bForce) {
|
|
if (this.UseRNDHeader || bForce) {
|
|
var HashHashSign = global.shaarr(buf.slice(buf.length - 32, buf.length));
|
|
for (var i = 0; i < 32; i++)
|
|
buf[i] = HashHashSign[i] ^ buf[i]
|
|
}
|
|
}
|
|
WasBanIP(rinfo) {
|
|
if (!rinfo || !rinfo.address)
|
|
return false;
|
|
var Key = "" + rinfo.address.trim();
|
|
var Stat = this.BAN_IP[Key];
|
|
if (Stat) {
|
|
if (Stat.TimeTo > (global.GetCurrentTime(0) - 0))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
NodeInBan(Node) {
|
|
return this.WasBanIP({ address: Node.ip });
|
|
}
|
|
DeleteNodeFromActiveByIP(ip) {
|
|
var Arr = this.GetActualNodes();
|
|
for (var i = 0; i < Arr.length; i++) {
|
|
var Node = Arr[i];
|
|
if (Node.ip === ip) {
|
|
this.DeleteNodeFromActive(Node)
|
|
}
|
|
}
|
|
}
|
|
AddToBan(Node, Str) {
|
|
if (global.NeedRestart)
|
|
return;
|
|
this.DeleteNodeFromActive(Node)
|
|
if (!Node.ip)
|
|
return;
|
|
var Key = "" + Node.ip.trim();
|
|
if (!Node.DeltaBan)
|
|
Node.DeltaBan = 300
|
|
if (Node.DeltaBan > 1000000)
|
|
Node.DeltaBan = 1000000
|
|
Node.DeltaBan = Node.DeltaBan * 2
|
|
var TimeTo = (global.GetCurrentTime(0) - 0) + Node.DeltaBan * 1000;
|
|
this.BAN_IP[Key] = { TimeTo: TimeTo }
|
|
Node.BlockProcessCount = 0
|
|
this.DeleteNodeFromActiveByIP(Node.ip)
|
|
global.ADD_TO_STAT("AddToBan")
|
|
}
|
|
AddToBanIP(ip, Str, Period?) {
|
|
if (!Period)
|
|
Period = 600 * 1000
|
|
var Key = "" + ip.trim();
|
|
this.BAN_IP[Key] = { TimeTo: (global.GetCurrentTime(0) - 0) + Period }
|
|
this.DeleteNodeFromActiveByIP(ip)
|
|
global.ToLog("ADD TO BAN:: " + Key + " " + Str)
|
|
global.ADD_TO_STAT("AddToBanIP")
|
|
}
|
|
OnPacketTCP(Meta) {
|
|
var startTime = process.hrtime();
|
|
global.ADD_TO_STAT("USEPACKET")
|
|
var CurTime = global.GetCurrentTime();
|
|
Meta.Node.LastTime = CurTime - 0
|
|
if (Meta.MethodTiming.Process && Meta.MethodTiming.Process.Worker) {
|
|
var Data = this.DataFromF(Meta);
|
|
Meta.MethodTiming.Process.Worker.send({ cmd: Meta.Method, Data: Data, addrStr: Meta.Node.addrStr, Context: Meta.Context })
|
|
}
|
|
else {
|
|
this.OnGetMethod(Meta, CurTime)
|
|
}
|
|
global.ADD_TO_STAT_TIME("MAX:TIME_USE_PACKET", startTime)
|
|
global.ADD_TO_STAT_TIME("TIME_USE_PACKET", startTime)
|
|
global.ADD_TO_STAT_TIME("MAX:TIME_USE_PACKET:" + Meta.Method, startTime)
|
|
}
|
|
GetBufFromData(Method, Data, TypeData, ContextID?) {
|
|
var BufData;
|
|
if (TypeData === global.BUF_TYPE) {
|
|
BufData = Data
|
|
}
|
|
else
|
|
if (TypeData === global.STR_TYPE) {
|
|
BufData = Buffer.from(Data.substr(0, global.MAX_STR_BUF_DATA))
|
|
} else {
|
|
if (Data === undefined) {
|
|
TypeData = global.BUF_TYPE
|
|
BufData = Buffer.alloc(0)
|
|
} else {
|
|
throw "ERROR TYPE DATA";
|
|
}
|
|
}
|
|
var BUF: any = {};
|
|
BUF.PacketSize = 0
|
|
BUF.NumXORRND = 0
|
|
BUF.Method = Method
|
|
BUF.NodeTime = global.GetCurrentTime()
|
|
BUF.TypeData = TypeData
|
|
BUF.Length = BufData.length
|
|
BUF.Data = BufData
|
|
BUF.ContextID = ContextID
|
|
BUF.Hash = this.GetHashFromData(BUF)
|
|
var BufWrite = global.BufLib.GetBufferFromObject(BUF, FORMAT_PACKET_SEND_TCP, BufData.length + 300, WorkStructPacketSend);
|
|
BufWrite.len = 0
|
|
global.BufLib.Write(BufWrite, BufWrite.length, "uint")
|
|
return BufWrite;
|
|
}
|
|
GetDataFromBuf(buf) {
|
|
try {
|
|
var Meta = global.BufLib.GetObjectFromBuffer(buf, FORMAT_PACKET_SEND_TCP, WorkStructPacketSend);
|
|
} catch (e) {
|
|
global.TO_ERROR_LOG("TRANSPORT", 640, "Error parsing Buffer")
|
|
return undefined;
|
|
}
|
|
var Hash = this.GetHashFromData(Meta);
|
|
if (global.CompareArr(Hash, Meta.Hash) !== 0) {
|
|
if (global.WATCHDOG_DEV)
|
|
global.ToLog("TRANSPORT", 645, "Error hash Buffer", 2)
|
|
return undefined;
|
|
}
|
|
if (Meta.TypeData === global.STR_TYPE) {
|
|
Meta.Data = Meta.Data.slice(0, global.MAX_STR_BUF_DATA).toString()
|
|
}
|
|
return Meta;
|
|
}
|
|
GetHashFromData(Info) {
|
|
return global.shaarr(Info.Method + Info.Length + "-" + (Info.NodeTime - 0));
|
|
}
|
|
OnGetFromTCP(Node: CNode, Socket: TeraSocket, Buf) {
|
|
if (!Node)
|
|
return;
|
|
if (!Node.Socket)
|
|
Node.Socket = Socket
|
|
if (!Socket.Buf || Socket.Buf.length === 0) {
|
|
Socket.Buf = Buf
|
|
} else {
|
|
Socket.Buf = Buffer.concat([Socket.Buf, Buf])
|
|
}
|
|
if (!Socket.SocketNum) {
|
|
this.LoadedSocketNum++
|
|
Socket.SocketNum = this.LoadedSocketNum
|
|
Socket.SocketPrioritet = Node.BlockProcessCount
|
|
}
|
|
this.LoadBufSocketList.insert(Socket)
|
|
}
|
|
DoLoadBuf() {
|
|
var Socket = this.LoadBufSocketList.min();
|
|
if (!Socket)
|
|
return;
|
|
this.LoadBufSocketList.remove(Socket)
|
|
if (Socket.WasClose)
|
|
return;
|
|
while (true) {
|
|
if (Socket.Buf && Socket.Buf.length > 6) {
|
|
global.ADD_TO_STAT("MAX:BUFFE_LOAD_SIZE", Socket.Buf.length / 1024)
|
|
Socket.Buf.len = 0
|
|
var PacketSize = global.BufLib.Read(Socket.Buf, "uint");
|
|
if (PacketSize > global.MAX_PACKET_LENGTH) {
|
|
this.SendCloseSocket(Socket, "MAX_PACKET_LENGTH")
|
|
break;
|
|
}
|
|
else
|
|
if (Socket.Buf.length >= PacketSize) {
|
|
var data = Socket.Buf.slice(0, PacketSize);
|
|
Socket.Buf = Socket.Buf.slice(PacketSize, Socket.Buf.length)
|
|
var Res = this.DoDataFromTCP(Socket, data);
|
|
if (Res) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
DoDataFromTCP(Socket, buf) {
|
|
this.LoadedPacketNum++
|
|
var Node = Socket.Node;
|
|
if (!Node)
|
|
return 0;
|
|
var startTime = process.hrtime();
|
|
global.ADD_TO_STAT("GETDATA(KB)", buf.length / 1024)
|
|
global.ADD_TO_STAT("GETDATA(KB):" + global.NodeName(Node), buf.length / 1024, 1)
|
|
if (!Node.TransferSize)
|
|
Node.TransferSize = 0
|
|
Node.TransferSize += buf.length / 1024
|
|
Node.TransferBlockNumFix = this.CurrentBlockNum
|
|
var Buf = this.GetDataFromBuf(buf);
|
|
if (!Buf) {
|
|
this.AddCheckErrCount(Node, 1, "Err GetDataFromBuf")
|
|
this.SendCloseSocket(Socket, "FORMAT_PACKET_SEND_TCP")
|
|
return 0;
|
|
}
|
|
global.ADD_TO_STAT("GET:" + Buf.Method)
|
|
global.ADD_TO_STAT("GET:(KB)" + Buf.Method, buf.length / 1024)
|
|
global.ADD_TO_STAT("GET:" + Buf.Method + ":" + global.NodeName(Node), 1, 1)
|
|
var Param = this.MethodTiming[Buf.Method];
|
|
if (this.StopDoSendPacket(Param, Node, Buf.Method)) {
|
|
return 1;
|
|
}
|
|
if (!global.IsZeroArr(Buf.ContextID)) {
|
|
Buf.Context = global.ContextPackets.LoadValue(Buf.ContextID)
|
|
}
|
|
if (!Buf.Context) {
|
|
if (Param && Param.Period === 0 && Buf.Method !== "RETBLOCKHEADER") {
|
|
this.AddCheckErrCount(Node, 1)
|
|
return;
|
|
}
|
|
Buf.Context = {}
|
|
}
|
|
Buf.Context.ContextID = Buf.ContextID
|
|
Buf.Node = Node
|
|
Buf.Socket = Socket
|
|
Buf.MethodTiming = Param
|
|
if (!global.ADDRLIST_MODE || Param.IsAddrList) {
|
|
if (Param.Hard) {
|
|
if (Param.Immediately && this.HardPacketForSend.size <= 3) {
|
|
this.OnPacketTCP(Buf)
|
|
}
|
|
else {
|
|
Buf.PacketNum = this.LoadedPacketNum
|
|
Buf.BlockProcessCount = Node.BlockProcessCount
|
|
Buf.TimeLoad = Date.now()
|
|
this.HardPacketForSend.insert(Buf)
|
|
}
|
|
}
|
|
else {
|
|
this.OnPacketTCP(Buf)
|
|
}
|
|
}
|
|
global.ADD_TO_STAT_TIME("MAX:TIMEDOGETDATA", startTime)
|
|
return 1;
|
|
}
|
|
StopDoSendPacket(Param, Node, Name) {
|
|
var CurTime = global.GetCurrentTime(0) - 0;
|
|
if (!Param) {
|
|
global.ADD_TO_STAT("STOP_METHOD")
|
|
global.ADD_TO_STAT("STOP_METHOD:NO")
|
|
this.AddCheckErrCount(Node, 1)
|
|
return 1;
|
|
}
|
|
if (Param.Hot && !Node.Hot) {
|
|
this.AddCheckErrCount(Node, 1)
|
|
return 0;
|
|
}
|
|
if (Param.Period && !Node.VersionOK && !Param.LowVersion) {
|
|
global.ADD_TO_STAT("STOP_METHOD")
|
|
global.ADD_TO_STAT("STOP_METHOD:LOWVERSION:" + Name)
|
|
return 1;
|
|
}
|
|
if (global.STOPGETBLOCK && Param.Hard === 2 && Node.BlockProcessCount < 1000000) {
|
|
Node.NextPing = 1 * 1000
|
|
global.ADD_TO_STAT("STOP_METHOD")
|
|
global.ADD_TO_STAT("STOP_METHOD:STOPGETBLOCK:" + Name)
|
|
this.AddCheckErrCount(Node, 0.5)
|
|
return 1;
|
|
}
|
|
var ArrTime = Node.TimeMap[Name];
|
|
if (!ArrTime) {
|
|
ArrTime = [0, 0, 0]
|
|
Node.TimeMap[Name] = ArrTime
|
|
}
|
|
ArrTime.sort(function(a, b) {
|
|
return a - b;
|
|
})
|
|
var Delta = CurTime - ArrTime[0];
|
|
if (Delta < Param.Period) {
|
|
global.ADD_TO_STAT("STOP_METHOD")
|
|
global.ADD_TO_STAT("STOP_METHOD:" + Name)
|
|
this.AddCheckErrCount(Node, 1)
|
|
return 1;
|
|
}
|
|
ArrTime[0] = CurTime
|
|
return 0;
|
|
}
|
|
DoHardPacketForSend() {
|
|
global.ADD_TO_STAT("MAX:BUSY_LEVEL", this.BusyLevel)
|
|
global.ADD_TO_STAT("MAX:HARD_PACKET_SIZE", this.HardPacketForSend.size)
|
|
var Delta = Date.now() - this.LastTimeHard;
|
|
this.LastTimeHard = Date.now()
|
|
if (Delta > global.HARD_PACKET_PERIOD120 * HARD_PACKET_PERIOD / 100) {
|
|
global.ADD_TO_STAT("HARD_PACKET_PERIOD120")
|
|
var Delta2 = Date.now() - this.LastTimeHardOK;
|
|
if (Delta2 > 100) {
|
|
var Info = this.HardPacketForSend.min();
|
|
this.RiseBusyLevelByInfo(Info)
|
|
}
|
|
return;
|
|
}
|
|
if (this.BusyLevel)
|
|
this.BusyLevel = this.BusyLevel / 1.1
|
|
this.LastTimeHardOK = Date.now()
|
|
global.ADD_TO_STAT("HARD_PACKET_PERIOD")
|
|
this.DoHardPacketForSendNext()
|
|
}
|
|
RiseBusyLevelByInfo(Info) {
|
|
if (!Info)
|
|
return;
|
|
if (!this.BusyLevel)
|
|
this.BusyLevel = 1
|
|
if (Info.BlockProcessCount > this.BusyLevel)
|
|
this.BusyLevel = Info.BlockProcessCount + 1
|
|
if (this.BusyLevel <= 0)
|
|
this.BusyLevel = 1
|
|
}
|
|
DropBusyLevelByInfo(Info) {
|
|
if (!Info)
|
|
return;
|
|
if (this.BusyLevel > Info.BlockProcessCount)
|
|
this.BusyLevel = Info.BlockProcessCount - 1
|
|
if (this.BusyLevel < 0)
|
|
this.BusyLevel = 0
|
|
}
|
|
DoHardPacketForSendNext() {
|
|
var Info = this.HardPacketForSend.min();
|
|
if (!Info) {
|
|
this.BusyLevel = 0
|
|
return;
|
|
}
|
|
this.DropBusyLevelByInfo(Info)
|
|
this.HardPacketForSend.remove(Info)
|
|
this.OnPacketTCP(Info)
|
|
global.ADD_TO_STAT("DO_HARD_PACKET")
|
|
global.ADD_TO_STAT("DO_HARD_PACKET:" + Info.Method)
|
|
var DeltaTime = Date.now() - Info.TimeLoad;
|
|
if (this.HardPacketForSend.size && DeltaTime > global.PACKET_ALIVE_PERIOD / 2) {
|
|
global.ADD_TO_STAT("DELETE_HARD_PACKET_OLD", this.HardPacketForSend.size)
|
|
this.HardPacketForSend.clear()
|
|
return;
|
|
}
|
|
var MaxCount = 20;
|
|
while (Info = this.HardPacketForSend.max()) {
|
|
var DeltaTime = Date.now() - Info.TimeLoad;
|
|
if (DeltaTime > global.PACKET_ALIVE_PERIOD / 2 || !Info.Node.Socket || Info.Node.Socket.WasClose) {
|
|
this.HardPacketForSend.remove(Info)
|
|
if (DeltaTime > global.PACKET_ALIVE_PERIOD / 2) {
|
|
this.RiseBusyLevelByInfo(Info)
|
|
Info.Node.NextPing = 1 * 1000
|
|
this.AddCheckErrCount(Info.Node, 0.2)
|
|
global.ADD_TO_STAT("DELETE_HARD_PACKET_OLD")
|
|
global.ADD_TO_STAT("DELETE_HARD_PACKET_OLD:" + Info.Method)
|
|
}
|
|
else {
|
|
global.ADD_TO_STAT("DELETE_HARD_PACKET_NO_ALIVE")
|
|
}
|
|
}
|
|
MaxCount--
|
|
if (MaxCount <= 0)
|
|
break;
|
|
}
|
|
}
|
|
Send(Node, Info, TypeData) {
|
|
if (!Node.Socket) {
|
|
this.DeleteNodeFromActive(Node)
|
|
return;
|
|
}
|
|
if (Info.Context) {
|
|
Info.ContextID = Info.Context.ContextID
|
|
if (!Info.ContextID) {
|
|
Info.ContextID = crypto.randomBytes(32)
|
|
Info.Context.ContextID = Info.ContextID
|
|
}
|
|
global.ContextPackets.SaveValue(Info.ContextID, Info.Context)
|
|
}
|
|
else {
|
|
Info.ContextID = []
|
|
}
|
|
Node.SendPacketNum++
|
|
Info.Node = Node
|
|
Info.TypeData = TypeData
|
|
Info.Prioritet = Node.Prioritet
|
|
Info.PacketNum = Node.SendPacketNum
|
|
Info.TimeNum = Date.now()
|
|
Node.SendPacket.insert(Info)
|
|
}
|
|
DoSendPacketNodeAll(Node) {
|
|
while (this.DoSendPacketNode(Node) === 1);
|
|
}
|
|
DoSendPacketNode(Node) {
|
|
var TimeNum = Date.now();
|
|
var Info = Node.SendPacket.max();
|
|
if (Info && TimeNum - Info.TimeNum > global.PACKET_ALIVE_PERIOD)
|
|
while (Info = Node.SendPacket.max()) {
|
|
var DeltaTime = TimeNum - Info.TimeNum;
|
|
if (DeltaTime > global.PACKET_ALIVE_PERIOD / 2) {
|
|
Node.SendPacket.remove(Info)
|
|
global.ADD_TO_STAT("DELETE_OLD_PACKET")
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
Info = Node.SendPacket.min()
|
|
if (!Info)
|
|
return 0;
|
|
global.ADD_TO_STAT("MAX:NODE_BUF_WRITE:" + global.NodeName(Node), Node.BufWrite.length / 1024, 1)
|
|
global.ADD_TO_STAT("MAX:NODE_SEND_BUF_PACKET_COUNT:" + global.NodeName(Node), Node.SendPacket.size, 1)
|
|
if (Node.BufWrite.length > 2 * TRAFIC_LIMIT_1S) {
|
|
return 2;
|
|
}
|
|
Node.SendPacket.remove(Info)
|
|
if (Info.Context) {
|
|
if (!Info.Context.SendCount)
|
|
Info.Context.SendCount = 0
|
|
Info.Context.SendCount++
|
|
}
|
|
var BufWrite = this.GetBufFromData(Info.Method, Info.Data, Info.TypeData, Info.ContextID);
|
|
Node.BufWriteLength += BufWrite.length
|
|
if (Node.BufWrite.length === 0)
|
|
Node.BufWrite = BufWrite
|
|
else
|
|
Node.BufWrite = Buffer.concat([Node.BufWrite, BufWrite])
|
|
global.ADD_TO_STAT("SEND:" + Info.Method)
|
|
global.ADD_TO_STAT("SEND:(KB)" + Info.Method, BufWrite.length / 1024)
|
|
global.ADD_TO_STAT("SEND:" + Info.Method + ":" + global.NodeName(Node), 1, 1)
|
|
global.TO_DEBUG_LOG("SEND " + Info.Method + " to " + global.NodeInfo(Node) + " LENGTH=" + BufWrite.length)
|
|
return 1;
|
|
}
|
|
DoSendPacket() {
|
|
var it = this.ActualNodes.iterator(), Node;
|
|
while ((Node = it.next()) !== null)
|
|
if (Node.ConnectStatus() === 100) {
|
|
this.DoSendPacketNode(Node)
|
|
}
|
|
else {
|
|
global.ADD_TO_STAT("SEND_ERROR")
|
|
this.AddCheckErrCount(Node, 0.005, "NODE STATUS=" + Node.ConnectStatus())
|
|
}
|
|
}
|
|
DoSendBuf() {
|
|
this.RecalcSendStatictic()
|
|
var CountNodeSend = 0;
|
|
var it = this.ActualNodes.iterator(), Node;
|
|
NEXT_NODE:
|
|
while ((Node = it.next()) !== null)
|
|
if (Node.Socket && Node.ConnectStatus() === 100)
|
|
if (Node.BufWrite.length > 0) {
|
|
CountNodeSend++
|
|
var CountSend = Math.min(BUF_PACKET_SIZE, Node.BufWrite.length);
|
|
var Value = CountSend / 1024;
|
|
if (global.LIMIT_SEND_TRAFIC) {
|
|
var CanCountSend = Node.SendTrafficLimit - Node.SendTrafficCurrent;
|
|
if (CanCountSend < CountSend) {
|
|
if (this.SendTrafficFree < CountSend) {
|
|
global.ADD_TO_STAT("LIMIT_SENDDATA:" + global.NodeName(Node), Value, 1)
|
|
continue NEXT_NODE;
|
|
}
|
|
this.SendTrafficFree -= CountSend
|
|
}
|
|
}
|
|
Node.write(Node.BufWrite.slice(0, CountSend))
|
|
Node.SendTrafficCurrent += CountSend
|
|
Node.BufWrite = Node.BufWrite.slice(CountSend)
|
|
this.ADD_CURRENT_STAT_TIME("SEND_DATA", Value)
|
|
global.ADD_TO_STAT("SENDDATA(KB)", Value)
|
|
global.ADD_TO_STAT("SENDDATA(KB):" + global.NodeName(Node), Value, 1)
|
|
}
|
|
}
|
|
CheckPOWTicketConnect(Socket, data) {
|
|
try {
|
|
var Info = global.BufLib.GetObjectFromBuffer(data, global.FORMAT_POW_TO_SERVER, {});
|
|
}
|
|
catch (e) {
|
|
this.SendCloseSocket(Socket, "FORMAT_POW_TO_SERVER")
|
|
return;
|
|
}
|
|
if (Info.DEF_NETWORK !== global.GetNetworkName()) {
|
|
this.SendCloseSocket(Socket, "DEF_NETWORK=" + Info.DEF_NETWORK + " MUST:" + global.GetNetworkName())
|
|
return;
|
|
}
|
|
var Node = this.FindRunNodeContext(Info.addrArr, Info.FromIP, Info.FromPort, true);
|
|
if (global.CompareArr(Info.addrArr, this.addrArr) === 0) {
|
|
global.AddNodeInfo(Node, "SERV: GET SELF")
|
|
this.SendCloseSocket(Socket, "SELF")
|
|
return;
|
|
}
|
|
var Hash = global.shaarr2(this.addrArr, Socket.HashRND);
|
|
var hashInfo = global.GetHashWithValues(Hash, Info.nonce, 0);
|
|
var power = global.GetPowPower(hashInfo);
|
|
if (Info.Reconnect) {
|
|
if ((Node.SecretForReconnect && Node.WaitConnectFromServer && global.CompareArr(Node.SecretForReconnect, Info.SecretForReconnect) === 0) || Info.Reconnect === 255) {
|
|
let Result = 1;
|
|
if (Info.Reconnect === 255) {
|
|
Result = global.CheckDevelopSign(Hash, Info.Sign)
|
|
}
|
|
if (Result) {
|
|
Node.NextConnectDelta = 1000
|
|
Node.WaitConnectFromServer = 0
|
|
Node.GrayConnect = 0
|
|
global.AddNodeInfo(Node, "3. SERVER OK CONNECT for client node " + global.SocketInfo(Socket))
|
|
this.AddNodeToActive(Node)
|
|
Node.Socket = Socket
|
|
global.SetSocketStatus(Socket, 3)
|
|
global.SetSocketStatus(Socket, 100)
|
|
Socket.Node = Node
|
|
Socket.write(this.GetBufFromData("POW_CONNECT0", "OK", 2))
|
|
return;
|
|
}
|
|
else {
|
|
Node.NextConnectDelta = 60 * 1000
|
|
global.ToLog("Error Sign Node from " + global.NodeInfo(Node))
|
|
this.AddCheckErrCount(Node, 10, "Error Sign Node")
|
|
}
|
|
}
|
|
global.AddNodeInfo(Node, "SERV: ERROR_RECONNECT")
|
|
Socket.end(this.GetBufFromData("POW_CONNEC11", "ERROR_RECONNECT", 2))
|
|
global.CloseSocket(Socket, "ERROR_RECONNECT")
|
|
return;
|
|
}
|
|
else {
|
|
if (power < global.MIN_POWER_POW_HANDSHAKE) {
|
|
global.ToLog("END: MIN_POWER_POW_HANDSHAKE")
|
|
global.AddNodeInfo(Node, "SERV: ERR MIN_POWER_POW_HANDSHAKE")
|
|
Socket.end(this.GetBufFromData("POW_CONNECT2", "MIN_POWER_POW_HANDSHAKE", 2))
|
|
global.CloseSocket(Socket, "MIN_POWER_POW_HANDSHAKE")
|
|
return;
|
|
}
|
|
else {
|
|
if (!Node.BlockProcessCount)
|
|
Node.BlockProcessCount = 0
|
|
if (this.ActualNodes.size >= global.MAX_CONNECTIONS_COUNT && Node.BlockProcessCount < global.TRUST_PROCESS_COUNT) {
|
|
global.AddNodeInfo(Node, "SERV: ERROR_MAX_CLIENTS")
|
|
Socket.end(this.GetBufFromData("POW_CONNECT8", "ERROR_MAX_CLIENTS", 2))
|
|
global.CloseSocket(Socket, "ERROR_MAX_CLIENTS")
|
|
return;
|
|
}
|
|
let Result = false;
|
|
if (Info.PubKeyType === 2 || Info.PubKeyType === 3)
|
|
Result = secp256k1.verify(Buffer.from(Hash), Buffer.from(Info.Sign), Buffer.from([Info.PubKeyType].concat(Info.addrArr)))
|
|
if (!Result) {
|
|
global.AddNodeInfo(Node, "SERV: ERROR_SIGN_CLIENT")
|
|
Socket.end(this.GetBufFromData("POW_CONNECT8", "ERROR_SIGN_CLIENT", 2))
|
|
global.CloseSocket(Socket, "ERROR_SIGN_CLIENT")
|
|
this.AddToBanIP(Socket.remoteAddress, "ERROR_SIGN_CLIENT")
|
|
return;
|
|
}
|
|
global.AddNodeInfo(Node, "1. SERVER OK POW for client node " + global.SocketInfo(Socket))
|
|
Node.FromIP = Info.FromIP
|
|
Node.FromPort = Info.FromPort
|
|
Node.SecretForReconnect = crypto.randomBytes(20)
|
|
Node.PubKey = Buffer.from([Info.PubKeyType].concat(Info.addrArr))
|
|
if (Info.GrayConnect) {
|
|
Node.NextConnectDelta = 1000
|
|
Node.WaitConnectFromServer = 0
|
|
Node.GrayConnect = 1
|
|
global.AddNodeInfo(Node, "5. CLIENT OK GRAY CONNECT " + global.SocketInfo(Socket))
|
|
this.AddNodeToActive(Node)
|
|
Node.Socket = Socket
|
|
global.SetSocketStatus(Socket, 3)
|
|
global.SetSocketStatus(Socket, 100)
|
|
Socket.Node = Node
|
|
Socket.write(this.GetBufFromData("POW_CONNECT0", "OK", 2))
|
|
return;
|
|
}
|
|
if (!Node.WasAddToReconnect) {
|
|
Node.WasAddToReconnect = 1
|
|
Node.ReconnectFromServer = 1
|
|
global.ArrReconnect.push(Node)
|
|
}
|
|
Socket.write(this.GetBufFromData("POW_CONNECT4", "WAIT_CONNECT_FROM_SERVER:" + global.GetHexFromArr(Node.SecretForReconnect), 2))
|
|
}
|
|
}
|
|
}
|
|
StopServer() {
|
|
if (this.Server)
|
|
this.Server.close()
|
|
}
|
|
StartServer() {
|
|
if (global.GrayConnect()) {
|
|
this.CanSend++
|
|
return;
|
|
}
|
|
let SELF = this;
|
|
this.Server = net.createServer(function(sock: any) {
|
|
if (SELF.WasBanIP({ address: sock.remoteAddress })) {
|
|
sock.ConnectID = "new"
|
|
global.CloseSocket(sock, "WAS BAN", true)
|
|
return;
|
|
}
|
|
let SOCKET = sock;
|
|
global.socketInit(SOCKET, "c")
|
|
global.SetSocketStatus(SOCKET, 0)
|
|
global.AddNodeInfo(SOCKET, "Client *" + SOCKET.ConnectID + " connected from " + SOCKET.remoteAddress + ":" + SOCKET.remotePort, 1)
|
|
global.ADD_TO_STAT("ClientConnected")
|
|
SOCKET.HashRND = crypto.randomBytes(32)
|
|
var Data = {
|
|
addrArr: SELF.addrArr, HashRND: SOCKET.HashRND, MIN_POWER_POW_HANDSHAKE: global.MIN_POWER_POW_HANDSHAKE, PubKeyType: SELF.PubKeyType,
|
|
Sign: SELF.ServerSign, Reserve: []
|
|
};
|
|
var BufData = global.BufLib.GetBufferFromObject(Data, global.FORMAT_POW_TO_CLIENT, 300, {});
|
|
var BufWrite = SELF.GetBufFromData("POW_CONNECT5", BufData, 1);
|
|
try {
|
|
SOCKET.write(BufWrite)
|
|
}
|
|
catch (e) {
|
|
global.ToError(e)
|
|
SOCKET = undefined
|
|
return;
|
|
}
|
|
SOCKET.on('data', function(data) {
|
|
if (SOCKET.WasClose) {
|
|
return;
|
|
}
|
|
if (!SOCKET.Node) {
|
|
var Buf = SELF.GetDataFromBuf(data);
|
|
if (Buf) {
|
|
SELF.CheckPOWTicketConnect(SOCKET, Buf.Data)
|
|
SOCKET.ConnectToServer = 0
|
|
return;
|
|
}
|
|
global.CloseSocket(SOCKET, "=SERVER ON DATA=")
|
|
}
|
|
else {
|
|
global.socketRead(SOCKET, data)
|
|
SELF.OnGetFromTCP(SOCKET.Node, SOCKET, data)
|
|
}
|
|
})
|
|
SOCKET.on('end', function() {
|
|
global.ADD_TO_STAT("ClientEnd")
|
|
var Node = SOCKET.Node;
|
|
var Status = global.GetSocketStatus(SOCKET);
|
|
if (Status)
|
|
global.AddNodeInfo(Node, "Get socket end *" + SOCKET.ConnectID + " from client Stat: " + global.SocketStatistic(SOCKET))
|
|
if (Node && Status === 200) {
|
|
Node.SwapSockets()
|
|
SOCKET.WasClose = 1
|
|
}
|
|
})
|
|
SOCKET.on('close', function(err) {
|
|
global.ADD_TO_STAT("ClientClose")
|
|
if (SOCKET.ConnectID && global.GetSocketStatus(SOCKET))
|
|
global.AddNodeInfo(SOCKET.Node, "Get socket close *" + SOCKET.ConnectID + " from client Stat: " + global.SocketStatistic(SOCKET))
|
|
if (!SOCKET.WasClose && SOCKET.Node) {
|
|
global.CloseSocket(SOCKET, "GET CLOSE")
|
|
}
|
|
global.SetSocketStatus(SOCKET, 0)
|
|
})
|
|
SOCKET.on('error', function(err) {
|
|
global.ADD_TO_STAT("ERRORS")
|
|
global.CloseSocket(SOCKET, "ERRORS")
|
|
if (SOCKET.Node)
|
|
SELF.AddCheckErrCount(SOCKET.Node, 1, "ERR##2 : socket")
|
|
})
|
|
})
|
|
this.Server.on('close', function() {
|
|
})
|
|
this.Server.on('error', function(err) {
|
|
if (err.code === 'EADDRINUSE') {
|
|
global.ToLogClient('Port ' + SELF.port + ' in use, retrying...')
|
|
if (SELF.Server)
|
|
SELF.Server.close()
|
|
setTimeout(function() {
|
|
SELF.RunListenServer()
|
|
}, 5000)
|
|
return;
|
|
}
|
|
global.ADD_TO_STAT("ERRORS")
|
|
global.ToError("ERR##3")
|
|
})
|
|
if (!SELF.ip) {
|
|
this.FindInternetIP()
|
|
}
|
|
else {
|
|
this.CanSend++
|
|
this.RunListenServer()
|
|
}
|
|
}
|
|
RunListenServer() {
|
|
if (!global.START_PORT_NUMBER || global.START_PORT_NUMBER === "undefined")
|
|
global.START_PORT_NUMBER = 30000
|
|
let SELF = this;
|
|
SELF.port = global.START_PORT_NUMBER
|
|
global.ToLogClient("Prepare to run TCP server on " + global.LISTEN_IP + ":" + SELF.port)
|
|
this.Server.listen(SELF.port, global.LISTEN_IP, function() {
|
|
if (SELF.CanSend < 2)
|
|
global.ToLogClient("Run TCP server on " + SELF.ip + ":" + SELF.port)
|
|
SELF.CanSend++
|
|
var Hash = global.sha3(SELF.addrStr)
|
|
SELF.ServerSign = secp256k1.sign(Buffer.from(Hash), SELF.KeyPair.getPrivateKey('')).signature
|
|
})
|
|
}
|
|
FindInternetIP() {
|
|
let Stun = global.Stun;
|
|
let SELF = this;
|
|
let server = Stun.createServer();
|
|
const request = Stun.createMessage(Stun.constants.STUN_BINDING_REQUEST);
|
|
server.on('error', function(err) {
|
|
SELF.CanSend++
|
|
})
|
|
server.once('bindingResponse', function(stunMsg) {
|
|
var value = stunMsg.getAttribute(Stun.constants.STUN_ATTR_XOR_MAPPED_ADDRESS).value;
|
|
global.ToLog("INTERNET IP:" + value.address)
|
|
SELF.CanSend++
|
|
global.INTERNET_IP_FROM_STUN = value.address
|
|
if (!SELF.ip)
|
|
SELF.ip = global.INTERNET_IP_FROM_STUN
|
|
if (server)
|
|
server.close()
|
|
SELF.RunListenServer()
|
|
})
|
|
var StrStunAddr = 'stun.l.google.com';
|
|
const dns = require('dns');
|
|
dns.lookup(StrStunAddr, function(err, address, family) {
|
|
if (!err)
|
|
server.send(request, 19302, StrStunAddr)
|
|
else
|
|
SELF.CanSend++
|
|
})
|
|
}
|
|
CLOSE_SOCKET(Context, CurTime) {
|
|
global.AddNodeInfo(Context.Socket.Node, "GET CLOSE_SOCKET *" + Context.Socket.ConnectID + ": " + Context.Data.toString())
|
|
global.CloseSocket(Context.Socket, "CLOSE_SOCKET")
|
|
}
|
|
SendCloseSocket(Socket, Str) {
|
|
global.AddNodeInfo(Socket.Node, "CLOSE_SOCKET " + global.SocketInfo(Socket) + " - " + Str)
|
|
if (Socket.WasClose) {
|
|
return;
|
|
}
|
|
this.AddCheckErrCount(Socket.Node, 1, "SendCloseSocket")
|
|
if (Socket.Node && Socket.Node.BufWrite && Socket.Node.BufWrite.length > 0) {
|
|
}
|
|
else {
|
|
global.AddNodeInfo(Socket.Node, "END *" + Socket.ConnectID + ": " + Str)
|
|
Socket.end(this.GetBufFromData("CLOSE_SOCKET", Str, 2))
|
|
}
|
|
global.CloseSocket(Socket, Str)
|
|
}
|
|
AddCheckErrCount(Node, Count, StrErr?) {
|
|
if (!Node)
|
|
return;
|
|
if (!Count)
|
|
Count = 1
|
|
var Delta = Date.now() - Node.LastTimeError;
|
|
if (Delta > 10 * 1000) {
|
|
Node.ErrCount = 0
|
|
}
|
|
Node.LastTimeError = Date.now()
|
|
Node.ErrCountAll += Count
|
|
Node.ErrCount += Count
|
|
if (Node.ErrCount >= 5) {
|
|
Node.ErrCount = 0
|
|
global.ADD_TO_STAT("ERRORS")
|
|
Node.BlockProcessCount--
|
|
if (Node.BlockProcessCount < - 30) {
|
|
if (!StrErr)
|
|
StrErr = ""
|
|
this.AddToBan(Node, StrErr + " BlockProcess:" + Node.BlockProcessCount)
|
|
}
|
|
else {
|
|
}
|
|
}
|
|
}
|
|
};
|
|
global.ContextPackets = new STreeBuffer(10 * 1000, global.CompareItemHash32, "object");
|
|
|
|
function CalcStatArr(arr, arrAvg, arrNext, Period) {
|
|
var arrSum = [arr[0]];
|
|
for (var i = 1; i < arr.length; i++) {
|
|
arrSum[i] = arrSum[i - 1] + arr[i];
|
|
}
|
|
for (var i = 0; i < arrSum.length; i++) {
|
|
if (i < Period)
|
|
arrAvg[i] = Math.floor(arrSum[i] / (i + 1));
|
|
else {
|
|
arrAvg[i] = Math.floor((arrSum[i] - arrSum[i - Period]) / Period);
|
|
}
|
|
}
|
|
arrNext[0] = 0;
|
|
for (var i = 1; i < arrAvg.length; i++) {
|
|
var Avg = arrSum[i] / (i + 1);
|
|
var minValue = Avg / 20;
|
|
var Value1 = arrAvg[i - 1];
|
|
var Value2 = arrAvg[i];
|
|
if (Value1 < minValue)
|
|
Value1 = minValue;
|
|
if (Value2 < minValue)
|
|
Value2 = minValue;
|
|
var KLast = Math.floor(100 * (Value2 - Value1) / Value1) / 100;
|
|
var AvgLast = arrAvg[i];
|
|
if (Avg > AvgLast)
|
|
AvgLast = Avg;
|
|
if (KLast > 2.0)
|
|
KLast = 2.0;
|
|
if (KLast < - 0.0)
|
|
KLast = - 0.0;
|
|
arrNext[i] = AvgLast * (1 + KLast);
|
|
var AvgMax = 0;
|
|
if (0)
|
|
if (i > 1 * Period) {
|
|
for (var j = i - Period / 2; j <= i; j++)
|
|
if (arrAvg[j] > AvgMax)
|
|
AvgMax = arrAvg[j];
|
|
}
|
|
}
|
|
return arrNext[arrNext.length - 1];
|
|
};
|