426 lines
14 KiB
TypeScript
426 lines
14 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 "./crypto-library"
|
|
import "./terahashmining"
|
|
import { RBTree } from './library'
|
|
import * as crypto from 'crypto';
|
|
import * as os from 'os'
|
|
|
|
global.glStopNode = false;
|
|
const MAX_TIME_NETWORK_TRANSPORT = 1 * 1000;
|
|
var GlSumUser;
|
|
var GlSumSys;
|
|
var GlSumIdle;
|
|
global.CountAllNode = 0;
|
|
export default class CCommon {
|
|
VirtualMode
|
|
KeyPair
|
|
PubKeyType
|
|
addrArr
|
|
addrStr
|
|
HashDBArr
|
|
ServerSign
|
|
MetaMap1
|
|
MetaMap2
|
|
CheckName
|
|
NodesArr
|
|
CurrentBlockNum
|
|
BlockNumDB
|
|
constructor(SetKeyPair, RunIP, RunPort, UseRNDHeader, bVirtual) {
|
|
global.SERVER = this
|
|
this.VirtualMode = bVirtual
|
|
this.KeyPair = SetKeyPair
|
|
var PubKey = SetKeyPair.getPublicKey('', 'compressed');
|
|
this.PubKeyType = PubKey[0]
|
|
this.addrArr = PubKey.slice(1)
|
|
this.addrStr = global.GetHexFromArr(this.addrArr)
|
|
this.HashDBArr = global.shaarr2(this.KeyPair.getPrivateKey(), [0, 0, 0, 0, 0, 0, 0, 1])
|
|
this.ServerSign = []
|
|
}
|
|
SendF(Node, Info, Length?) {
|
|
throw new Error('Unsupport Action...')
|
|
// defiend in server.ts
|
|
}
|
|
AddCheckErrCount(Node, Count, StrErr) {
|
|
throw new Error('Unsupport Action...')
|
|
// defiend in server.ts
|
|
}
|
|
GetActualNodes(): any {
|
|
throw new Error('Unsupport Action...')
|
|
// defiend in server.ts
|
|
}
|
|
ReadBlockHeaderDB(BlockNum): any {
|
|
throw new Error('Unsupport Action...')
|
|
// defiend in block-db.ts(CDB)
|
|
}
|
|
AddStatOnTimer() {
|
|
var CountAll = 0;
|
|
var CurTime = global.GetCurrentTime() - 0;
|
|
for (var i = 0; i < this.NodesArr.length; i++) {
|
|
var Item = this.NodesArr[i];
|
|
if (Item.LastTime && (CurTime - Item.LastTime) < global.NODES_DELTA_CALC_HOUR * 3600 * 1000)
|
|
CountAll++
|
|
else
|
|
if (Item.LastTimeGetNode && (CurTime - Item.LastTimeGetNode) < global.NODES_DELTA_CALC_HOUR * 3600 * 1000)
|
|
CountAll++
|
|
}
|
|
global.CountAllNode = CountAll
|
|
if (!global.STAT_MODE)
|
|
return;
|
|
var StateTX = global.DApps.Accounts.DBStateTX.Read(0);
|
|
if (StateTX) {
|
|
var Delta = this.CurrentBlockNum - StateTX.BlockNum;
|
|
global.ADD_TO_STAT("MAX:DELTA_TX", Delta)
|
|
}
|
|
var bHasCP = 0;
|
|
if (global.CHECK_POINT.BlockNum) {
|
|
var Block = this.ReadBlockHeaderDB(global.CHECK_POINT.BlockNum);
|
|
if (Block && global.CompareArr(global.CHECK_POINT.Hash, Block.Hash) === 0)
|
|
bHasCP = 1
|
|
}
|
|
var MinVer = global.MIN_VER_STAT;
|
|
if (MinVer === 0)
|
|
MinVer = global.UPDATE_CODE_VERSION_NUM
|
|
var BufMap = {}, BufMap2 = {};
|
|
var arr = this.GetActualNodes();
|
|
var Count = 0, CountHot = 0, CountHotOK = 0, CountActualOK = 0, SumDeltaHot = 0, SumDeltaActual = 0, CountCP = 0, CountLH = 0,
|
|
CountHash = 0, CountVer = 0, CountStop = 0;
|
|
var CountAutoCorrectTime = 0;
|
|
var SumAvgDeltaTime = 0;
|
|
for (var i = 0; i < arr.length; i++) {
|
|
var Node = arr[i];
|
|
if (!Node || Node.IsAddrList)
|
|
continue;
|
|
var INFO = Node.INFO;
|
|
if (!INFO)
|
|
INFO = {}
|
|
if (bHasCP && global.CHECK_POINT.BlockNum && INFO.CheckPointHashDB && global.CompareArr(global.CHECK_POINT.Hash, INFO.CheckPointHashDB) === 0) {
|
|
CountCP++
|
|
}
|
|
if (INFO.LoadHistoryMode)
|
|
CountLH++
|
|
if (Node.StopGetBlock)
|
|
CountStop++
|
|
Count++
|
|
SumAvgDeltaTime += Node.DeltaGlobTime
|
|
if (Node.VersionNum >= MinVer)
|
|
CountVer++
|
|
if (INFO && INFO.BlockNumDB && INFO.BlockNumDB <= this.BlockNumDB) {
|
|
var HashDB = ReadHashFromBufDB(BufMap2, INFO.BlockNumDB);
|
|
if (HashDB && global.CompareArr(HashDB, INFO.HashDB) === 0)
|
|
CountHash++
|
|
}
|
|
var StrChk = GetCheckAccHash(BufMap, INFO.AccountBlockNum, INFO.AccountsHash);
|
|
var Chck = 0;
|
|
if (StrChk.indexOf("=OK=") >= 0) {
|
|
Chck = 1
|
|
}
|
|
var DeltaTime = Node.DeltaTime;
|
|
if (!DeltaTime)
|
|
DeltaTime = 0
|
|
CountActualOK += Chck
|
|
SumDeltaActual += DeltaTime
|
|
if (Node.Hot) {
|
|
CountHot++
|
|
CountHotOK += Chck
|
|
SumDeltaHot += DeltaTime
|
|
}
|
|
if (INFO.AutoCorrectTime)
|
|
CountAutoCorrectTime++
|
|
}
|
|
global.ADD_TO_STAT("MAX:ALL_NODES", CountAll)
|
|
global.ADD_TO_STAT("MAX:CONNECTED_NODES", Count)
|
|
global.ADD_TO_STAT("MAX:HOT_NODES", CountHot)
|
|
global.ADD_TO_STAT("MAX:HOT_OK", CountHotOK)
|
|
global.ADD_TO_STAT("MAX:ACTUAL_OK", CountActualOK)
|
|
global.ADD_TO_STAT("MAX:CHECK_POINT_OK", CountCP)
|
|
global.ADD_TO_STAT("MAX:COUNTLH", CountLH)
|
|
global.ADD_TO_STAT("MAX:HASH_OK", CountHash)
|
|
global.ADD_TO_STAT("MAX:MIN_VERSION", CountVer)
|
|
global.ADD_TO_STAT("MAX:STOP_GET", CountStop)
|
|
global.ADD_TO_STAT("MAX:AUTOCORRECT", CountAutoCorrectTime)
|
|
global.ADD_TO_STAT("MAX:TIME_DELTA", global.DELTA_CURRENT_TIME)
|
|
if (!Count)
|
|
Count = 1
|
|
if (!CountHot)
|
|
CountHot = 1
|
|
if (Count >= 20) {
|
|
var SumDeltaAvg = 0;
|
|
var AvgGlobTime = SumAvgDeltaTime / Count;
|
|
for (var i = 0; i < arr.length; i++) {
|
|
var Node = arr[i];
|
|
if (!Node || Node.IsAddrList)
|
|
continue;
|
|
var Delta = AvgGlobTime - Node.DeltaGlobTime;
|
|
SumDeltaAvg += Delta * Delta
|
|
}
|
|
SumDeltaAvg = Math.sqrt(SumDeltaAvg / Count)
|
|
global.ADD_TO_STAT("MAX:DELTA_GLOB_TIME", 100 + AvgGlobTime)
|
|
global.ADD_TO_STAT("MAX:DISP_DELTA_GLOB_TIME", SumDeltaAvg)
|
|
arr.sort(function(a, b) {
|
|
return a.DeltaGlobTime - b.DeltaGlobTime;
|
|
})
|
|
var SumDeltaAvgM = 0;
|
|
var AvgGlobTimeM = arr[Math.trunc(arr.length / 2)].DeltaGlobTime;
|
|
var Length = arr.length;
|
|
var Start = Math.trunc(Length * 0.05);
|
|
var End = Math.trunc(Length * 0.95);
|
|
var NodesCount = 0;
|
|
for (var i = Start; i < End; i++) {
|
|
var Node = arr[i];
|
|
if (!Node || Node.IsAddrList)
|
|
continue;
|
|
NodesCount++
|
|
var Delta = AvgGlobTimeM - Node.DeltaGlobTime;
|
|
SumDeltaAvgM += Delta * Delta
|
|
}
|
|
if (!NodesCount)
|
|
NodesCount = 1
|
|
SumDeltaAvgM = Math.sqrt(SumDeltaAvgM / NodesCount)
|
|
global.ADD_TO_STAT("MAX:MEDIAN_GLOB_TIME", 100 + AvgGlobTimeM)
|
|
global.ADD_TO_STAT("MAX:DISP_MEDIAN_GLOB_TIME", SumDeltaAvgM)
|
|
}
|
|
global.ADD_TO_STAT("MAX:DELTA_TIME_HOT", SumDeltaHot / CountHot)
|
|
global.ADD_TO_STAT("MAX:DELTA_TIME_ACTUAL", SumDeltaActual / Count)
|
|
global.ADD_TO_STAT("MAX:MEMORY_USAGE", process.memoryUsage().heapTotal / 1024 / 1024)
|
|
global.ADD_TO_STAT("MAX:MEMORY_FREE", os.freemem() / 1024 / 1024)
|
|
var SumUser = 0;
|
|
var SumSys = 0;
|
|
var SumIdle = 0;
|
|
var cpus = os.cpus();
|
|
for (var i = 0; i < cpus.length; i++) {
|
|
var cpu = cpus[i];
|
|
SumUser += cpu.times.user
|
|
SumSys += cpu.times.sys + cpu.times.irq
|
|
SumIdle += cpu.times.idle
|
|
}
|
|
if (GlSumUser !== undefined) {
|
|
var maxsum = cpus.length * 1000;
|
|
global.ADD_TO_STAT("MAX:CPU_USER_MODE", Math.min(maxsum, SumUser - GlSumUser))
|
|
global.ADD_TO_STAT("MAX:CPU_SYS_MODE", Math.min(maxsum, SumSys - GlSumSys))
|
|
global.ADD_TO_STAT("MAX:CPU_IDLE_MODE", Math.min(maxsum, SumIdle - GlSumIdle))
|
|
global.ADD_TO_STAT("MAX:CPU", Math.min(maxsum, SumUser + SumSys - GlSumUser - GlSumSys))
|
|
}
|
|
GlSumUser = SumUser
|
|
GlSumSys = SumSys
|
|
GlSumIdle = SumIdle
|
|
}
|
|
GetNewMeta() {
|
|
return crypto.randomBytes(32);
|
|
}
|
|
};
|
|
class SMemBuffer {
|
|
MetaMap1
|
|
MetaMap2
|
|
CheckName
|
|
constructor(MaxTime, CheckName) {
|
|
this.MetaMap1 = {}
|
|
this.MetaMap2 = {}
|
|
this.CheckName = CheckName
|
|
setInterval(this.ShiftMapDirect.bind(this), MaxTime)
|
|
}
|
|
GetStrKey(Arr) {
|
|
if (typeof Arr === "number" || typeof Arr === "string") {
|
|
return Arr;
|
|
} else {
|
|
return global.GetHexFromAddres(Arr);
|
|
}
|
|
throw "NOT RET!";
|
|
}
|
|
LoadValue(Arr, bStay) {
|
|
if (!Arr)
|
|
return undefined;
|
|
var Key = this.GetStrKey(Arr);
|
|
var Value = this.MetaMap1[Key];
|
|
if (Value !== undefined) {
|
|
if (!bStay)
|
|
delete this.MetaMap1[Key]
|
|
return Value;
|
|
}
|
|
Value = this.MetaMap2[Key]
|
|
if (Value !== undefined) {
|
|
if (!bStay)
|
|
delete this.MetaMap2[Key]
|
|
}
|
|
return Value;
|
|
}
|
|
SaveValue(Arr, Value) {
|
|
var Key = this.GetStrKey(Arr);
|
|
if (Value !== undefined)
|
|
this.MetaMap1[Key] = Value
|
|
}
|
|
ShiftMapDirect() {
|
|
if (global.glStopNode)
|
|
return;
|
|
if (this.CheckName) {
|
|
var Count = 0;
|
|
for (var _ in this.MetaMap2) {
|
|
Count++
|
|
}
|
|
if (Count) {
|
|
global.ADD_TO_STAT(this.CheckName, 1, 1)
|
|
}
|
|
}
|
|
this.MetaMap2 = this.MetaMap1
|
|
this.MetaMap1 = {}
|
|
}
|
|
Clear() {
|
|
this.MetaMap2 = {}
|
|
this.MetaMap1 = {}
|
|
}
|
|
};
|
|
export class STreeBuffer {
|
|
KeyType
|
|
MetaTree1
|
|
MetaTree2
|
|
CheckName
|
|
constructor(MaxTime, CompareFunction?, KeyType?, CheckName?) {
|
|
this.KeyType = KeyType
|
|
this.MetaTree1 = new RBTree(CompareFunction)
|
|
this.MetaTree2 = new RBTree(CompareFunction)
|
|
this.CheckName = CheckName
|
|
setInterval(this.ShiftMapDirect.bind(this), MaxTime)
|
|
}
|
|
LoadValue(Hash, bStay) {
|
|
if (!Hash)
|
|
return undefined;
|
|
if (typeof Hash !== this.KeyType)
|
|
throw "MUST ONLY HASH ARRAY: " + Hash;
|
|
var element = this.MetaTree1.find({ hash: Hash });
|
|
if (element) {
|
|
if (!bStay)
|
|
this.MetaTree1.remove(element)
|
|
return element.value;
|
|
}
|
|
element = this.MetaTree2.find({ hash: Hash })
|
|
if (element) {
|
|
if (!bStay)
|
|
this.MetaTree2.remove(element)
|
|
return element.value;
|
|
}
|
|
return undefined;
|
|
}
|
|
SaveValue(Hash, Value) {
|
|
if (typeof Hash !== this.KeyType)
|
|
throw "MUST ONLY TYPE=" + this.KeyType + " in " + Hash;
|
|
if (Value !== undefined) {
|
|
var element = this.MetaTree1.find({ hash: Hash });
|
|
if (element)
|
|
element.value = Value
|
|
else
|
|
this.MetaTree1.insert({ hash: Hash, value: Value })
|
|
}
|
|
}
|
|
ShiftMapDirect() {
|
|
if (this.CheckName && this.MetaTree2.size) {
|
|
global.ADD_TO_STAT(this.CheckName, this.MetaTree2.size, 1)
|
|
var it = this.MetaTree2.iterator(), Item;
|
|
while ((Item = it.next()) !== null) {
|
|
var Name = Item.value.Name;
|
|
global.ADD_TO_STAT(this.CheckName + ":" + Name, 1, 1)
|
|
}
|
|
}
|
|
this.MetaTree2.clear()
|
|
var empty_tree = this.MetaTree2;
|
|
this.MetaTree2 = this.MetaTree1
|
|
this.MetaTree1 = empty_tree
|
|
}
|
|
Clear() {
|
|
this.MetaTree1.clear()
|
|
this.MetaTree2.clear()
|
|
}
|
|
};
|
|
|
|
function ReadHashFromBufDB(Map, BlockNum) {
|
|
var MyHash = Map[BlockNum];
|
|
if (!MyHash) {
|
|
var Block = global.SERVER.ReadBlockHeaderDB(BlockNum);
|
|
if (Block)
|
|
MyHash = Block.Hash;
|
|
else
|
|
MyHash = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
|
|
Map[BlockNum] = MyHash;
|
|
}
|
|
return MyHash;
|
|
};
|
|
|
|
function GetCheckAccHash(Map, BlockNum, Hash) {
|
|
var MyHash = Map[BlockNum];
|
|
if (!MyHash) {
|
|
MyHash = global.DApps.Accounts.GetHashOrUndefined(BlockNum);
|
|
Map[BlockNum] = MyHash;
|
|
}
|
|
if (MyHash) {
|
|
if (!Hash)
|
|
return "=ERR:NO=";
|
|
if (global.CompareArr(Hash, MyHash) !== 0)
|
|
return "=ERR:BAD=";
|
|
else
|
|
return "=OK=";
|
|
}
|
|
else {
|
|
if (!Hash)
|
|
return "=OK=:NO";
|
|
else
|
|
return "=MY:NO=";
|
|
}
|
|
};
|
|
global.GetCheckAccHash = GetCheckAccHash;
|
|
global.ReadHashFromBufDB = ReadHashFromBufDB;
|
|
global.STreeBuffer = STreeBuffer;
|
|
global.TestCreateTr = TestCreateTr;
|
|
|
|
function TestCreateTr() {
|
|
const FORMAT_CREATE = "{\
|
|
Type:byte,\
|
|
Currency:uint,\
|
|
PubKey:arr33,\
|
|
Description:str40,\
|
|
Adviser:uint,\
|
|
Reserve:arr7,\
|
|
POWCreate:arr12,\
|
|
}";
|
|
var TR = {
|
|
Type: 100, Currency: 0, PubKey: [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0], Description: "Description", Adviser: 10,
|
|
};
|
|
var Body = global.BufLib.GetBufferFromObject(TR, global.FORMAT_CREATE, 1000, {});
|
|
var startTime = process.hrtime();
|
|
var StartData = Date.now();
|
|
var nonce = CreateHashBodyPOWInnerMinPower(Body, 1000, 17);
|
|
var Time = process.hrtime(startTime);
|
|
var power = global.GetPowPower(global.shaarr(Body));
|
|
var deltaTime = (Time[0] * 1000 + Time[1] / 1e6) / 1000;
|
|
var DeltaData = ((new Date() as any) - StartData) / 1000;
|
|
global.ToLog("power=" + power + " nonce=" + nonce + " TIME=" + deltaTime + " sec" + " DeltaData=" + DeltaData + " sec");
|
|
return { time1: deltaTime, time2: DeltaData };
|
|
};
|
|
|
|
function CreateHashBody(body, Num, Nonce) {
|
|
body.writeUIntLE(Num, body.length - 12, 6);
|
|
body.writeUIntLE(Nonce, body.length - 6, 6);
|
|
return global.shaarr(body);
|
|
};
|
|
|
|
function CreateHashBodyPOWInnerMinPower(arr, BlockNum, MinPow) {
|
|
var nonce = 0;
|
|
while (1) {
|
|
var arrhash = CreateHashBody(arr, BlockNum, nonce);
|
|
var power = global.GetPowPower(arrhash);
|
|
if (power >= MinPow) {
|
|
return nonce;
|
|
}
|
|
nonce++;
|
|
}
|
|
};
|