307 lines
9.2 KiB
JavaScript
307 lines
9.2 KiB
JavaScript
/*
|
|
* @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://web.telegram.org/#/im?p=@terafoundation
|
|
*/
|
|
|
|
global.PROCESS_NAME = "STATIC";
|
|
const crypto = require('crypto');
|
|
const fs = require('fs');
|
|
require("../core/constant");
|
|
require('../core/block-loader-const');
|
|
require('../core/rest_tables.js');
|
|
require('../dapp/accounts.js');
|
|
require('../dapp/smart.js');
|
|
global.DATA_PATH = GetNormalPathString(global.DATA_PATH);
|
|
global.CODE_PATH = GetNormalPathString(global.CODE_PATH);
|
|
require("../core/library");
|
|
global.READ_ONLY_DB = 1;
|
|
var LastAlive = Date.now();
|
|
setTimeout(function ()
|
|
{
|
|
setInterval(CheckAlive, 1000);
|
|
}, 20000);
|
|
setInterval(function ()
|
|
{
|
|
process.send({cmd:"Alive"});
|
|
}, 1000);
|
|
process.send({cmd:"online", message:"OK"});
|
|
process.on('message', function (msg)
|
|
{
|
|
LastAlive = Date.now();
|
|
switch(msg.cmd)
|
|
{
|
|
case "ALive":
|
|
break;
|
|
case "Exit":
|
|
process.exit(0);
|
|
break;
|
|
case "call":
|
|
var Err = 0;
|
|
var Ret;
|
|
try
|
|
{
|
|
Ret = global[msg.Name](msg.Params);
|
|
}
|
|
catch(e)
|
|
{
|
|
Err = 1;
|
|
Ret = "" + e;
|
|
}
|
|
if(msg.id)
|
|
process.send({cmd:"retcall", id:msg.id, Err:Err, Params:Ret});
|
|
break;
|
|
case "GETBLOCKHEADER":
|
|
GETBLOCKHEADER(msg);
|
|
break;
|
|
case "GETBLOCK":
|
|
GETBLOCK(msg);
|
|
break;
|
|
case "GETCODE":
|
|
GETCODE(msg);
|
|
break;
|
|
case "GETREST":
|
|
GETREST(msg);
|
|
break;
|
|
case "GETSMART":
|
|
GETSMART(msg);
|
|
break;
|
|
}
|
|
});
|
|
|
|
function CheckAlive()
|
|
{
|
|
if(global.NOALIVE)
|
|
return ;
|
|
var Delta = Date.now() - LastAlive;
|
|
if(Delta > CHECK_STOP_CHILD_PROCESS)
|
|
{
|
|
ToLog("STATIC-DB: ALIVE TIMEOUT Stop and exit: " + Delta + "/" + global.CHECK_STOP_CHILD_PROCESS);
|
|
process.exit(0);
|
|
return ;
|
|
}
|
|
};
|
|
process.on('uncaughtException', function (err)
|
|
{
|
|
ToError(err.stack);
|
|
ToLog(err.stack);
|
|
TO_ERROR_LOG("STATIC-DB", 777, err);
|
|
ToLog("-----------------STATIC-DB EXIT------------------");
|
|
process.exit();
|
|
});
|
|
process.on('error', function (err)
|
|
{
|
|
ToError("STATIC-DB:\n" + err.stack);
|
|
ToLog(err.stack);
|
|
});
|
|
var CServerDB = require("../core/db/block-db");
|
|
var KeyPair = crypto.createECDH('secp256k1');
|
|
KeyPair.setPrivateKey(Buffer.from([77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77,
|
|
77, 77, 77, 77, 77, 77, 77, 77, 77, 77]));
|
|
global.SERVER = new CServerDB(KeyPair, undefined, undefined, false, true);
|
|
global.HTTP_PORT_NUMBER = 0;
|
|
setInterval(function ()
|
|
{
|
|
if(SERVER)
|
|
SERVER.ClearBufMap();
|
|
DApps.Accounts.Close();
|
|
DApps.Smart.DBSmart.Close();
|
|
global.BlockDB.CloseDBFile("block-header");
|
|
global.BlockDB.CloseDBFile("block-body");
|
|
}, 1000);
|
|
|
|
function GETBLOCKHEADER(msg)
|
|
{
|
|
var Data = msg.Data;
|
|
var StartNum = undefined;
|
|
var BlockNum;
|
|
var LoadHash = Data.Hash;
|
|
var Foward = Data.Foward;
|
|
if(Foward)
|
|
{
|
|
var BlockDB = SERVER.ReadBlockHeaderDB(Data.BlockNum);
|
|
if(BlockDB && BlockDB.SumHash && (CompareArr(BlockDB.SumHash, LoadHash) === 0 || IsZeroArr(LoadHash)))
|
|
{
|
|
StartNum = Data.BlockNum - BLOCK_PROCESSING_LENGTH2;
|
|
if(StartNum < 0)
|
|
StartNum = 0;
|
|
BlockNum = StartNum + COUNT_BLOCKS_FOR_LOAD + BLOCK_PROCESSING_LENGTH2;
|
|
if(BlockNum > SERVER.GetMaxNumBlockDB())
|
|
BlockNum = SERVER.GetMaxNumBlockDB();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BlockNum = Data.BlockNum;
|
|
var IsSum = Data.IsSum;
|
|
var Count = Data.Count;
|
|
if(!Count || Count < 0 || BlockNum < 0)
|
|
return ;
|
|
if(Count > COUNT_BLOCKS_FOR_LOAD)
|
|
Count = COUNT_BLOCKS_FOR_LOAD;
|
|
Count += BLOCK_PROCESSING_LENGTH2;
|
|
var BlockDB = SERVER.ReadBlockHeaderDB(BlockNum);
|
|
if(BlockDB && (BlockDB.Prepared && (!IsSum) && BlockDB.Hash && CompareArr(BlockDB.Hash, LoadHash) === 0 || BlockDB.bSave && IsSum && BlockDB.SumHash && CompareArr(BlockDB.SumHash,
|
|
LoadHash) === 0))
|
|
{
|
|
StartNum = BlockNum - Count + 1;
|
|
if(StartNum < 0)
|
|
StartNum = 0;
|
|
}
|
|
}
|
|
var BufWrite = SERVER.BlockChainToBuf(StartNum, StartNum, BlockNum);
|
|
process.send({cmd:"Send", addrStr:msg.addrStr, Method:"RETBLOCKHEADER", Context:msg.Context, Data:BufWrite});
|
|
};
|
|
|
|
function GETBLOCK(msg)
|
|
{
|
|
var Data = msg.Data;
|
|
var BlockNum = Data.BlockNum;
|
|
var TreeHash = Data.TreeHash;
|
|
if(msg.Context.SendCount)
|
|
{
|
|
return ;
|
|
}
|
|
var BufWrite;
|
|
var BlockDB = SERVER.ReadBlockDB(BlockNum);
|
|
var StrSend;
|
|
if(BlockDB && (CompareArr(BlockDB.TreeHash, TreeHash) === 0 || IsZeroArr(TreeHash)))
|
|
{
|
|
var BufWrite = BufLib.GetBufferFromObject(BlockDB, FORMAT_BLOCK_TRANSFER, MAX_PACKET_LENGTH, WRK_BLOCK_TRANSFER);
|
|
StrSend = "OK";
|
|
var TreeHashTest = CalcTreeHashFromArrBody(BlockDB.BlockNum, BlockDB.arrContent);
|
|
if(CompareArr(BlockDB.TreeHash, TreeHashTest) !== 0)
|
|
{
|
|
ToLog("1. BAD CMP TreeHash block=" + BlockNum + " TO: " + msg.addrStr.substr(0, 8) + " TreeHashTest=" + GetHexFromArr(TreeHashTest) + " DB TreeHash=" + GetHexFromArr(BlockDB.TreeHash));
|
|
StrSend = "NO";
|
|
}
|
|
}
|
|
if(StrSend === "OK")
|
|
{
|
|
ADD_TO_STAT("BLOCK_SEND");
|
|
}
|
|
else
|
|
{
|
|
BufWrite = BufLib.GetNewBuffer(100);
|
|
StrSend = "NO";
|
|
}
|
|
process.send({cmd:"Send", addrStr:msg.addrStr, Method:"RETGETBLOCK", Context:msg.Context, Data:BufWrite});
|
|
};
|
|
|
|
function GETCODE(msg)
|
|
{
|
|
var VersionNum = msg.Data;
|
|
var fname = GetDataPath("Update/wallet-" + VersionNum + ".zip");
|
|
if(fs.existsSync(fname))
|
|
{
|
|
var data = fs.readFileSync(fname);
|
|
process.send({cmd:"Send", addrStr:msg.addrStr, Method:"RETCODE", Context:msg.Context, Data:data});
|
|
}
|
|
};
|
|
|
|
function GETREST(msg)
|
|
{
|
|
var Data = msg.Data;
|
|
if(!Data.BlockNum)
|
|
return ;
|
|
var BlockNumRest = Data.BlockNum;
|
|
var arr = GetCurrentRestArr();
|
|
var BufLength;
|
|
var nResult = 0;
|
|
for(var i = 0; i < arr.length; i++)
|
|
{
|
|
if(arr[i] === BlockNumRest)
|
|
{
|
|
nResult = 1;
|
|
break;
|
|
}
|
|
}
|
|
var ArrRest = [];
|
|
if(nResult)
|
|
{
|
|
var WorkStruct = {};
|
|
var WorkFormat = DApps.Accounts.FORMAT_ACCOUNT_ROW;
|
|
var WorkFormatLength = DApps.Accounts.SIZE_ACCOUNT_ROW;
|
|
var Max = DApps.Accounts.DBState.GetMaxNum();
|
|
var LengthAccount = Data.Count;
|
|
if(LengthAccount > MAX_ACCOUNTS_TRANSFER)
|
|
LengthAccount = MAX_ACCOUNTS_TRANSFER;
|
|
var EndAccount = Data.AccNum + LengthAccount - 1;
|
|
if(EndAccount > Max)
|
|
EndAccount = Max;
|
|
var FindItem;
|
|
for(var Num = Data.AccNum; Num <= EndAccount; Num++)
|
|
{
|
|
FindItem = undefined;
|
|
var RestData = DApps.Accounts.ReadRest(Num);
|
|
var Data = DApps.Accounts.DBState.Read(Num);
|
|
if(!Data)
|
|
break;
|
|
var CountZero = 0;
|
|
for(var i = RestData.Arr.length - 1; i >= 0; i--)
|
|
{
|
|
var Item = RestData.Arr[i];
|
|
if(!Item.BlockNum)
|
|
{
|
|
CountZero++;
|
|
continue;
|
|
}
|
|
if(Item.BlockNum <= BlockNumRest)
|
|
{
|
|
if(!FindItem || Item.BlockNum > FindItem.BlockNum)
|
|
{
|
|
FindItem = Item;
|
|
}
|
|
}
|
|
}
|
|
if(FindItem)
|
|
{
|
|
Data.Value = FindItem.Value;
|
|
}
|
|
else
|
|
{
|
|
if(CountZero !== RestData.Arr.length)
|
|
continue;
|
|
}
|
|
var Buf = BufLib.GetBufferFromObject(Data, WorkFormat, WorkFormatLength, WorkStruct);
|
|
ArrRest.push(Buf);
|
|
}
|
|
BufLength = 1000 + ArrRest.length * WorkFormatLength;
|
|
}
|
|
else
|
|
{
|
|
BufLength = 1000;
|
|
}
|
|
var Data2 = {Result:nResult, BlockNum:BlockNumRest, Arr:ArrRest};
|
|
var BufWrite = BufLib.GetBufferFromObject(Data2, FORMAT_REST_TRANSFER, BufLength, {});
|
|
process.send({cmd:"Send", addrStr:msg.addrStr, Method:"RETREST", Context:msg.Context, Data:BufWrite});
|
|
};
|
|
|
|
function GETSMART(msg)
|
|
{
|
|
var Data = msg.Data;
|
|
if(!Data.Count)
|
|
return ;
|
|
var BufLength = 1000;
|
|
var SizeForSend = 200 * 1024;
|
|
var Arr = [];
|
|
for(var Num = Data.SmartNum; Num < Data.SmartNum + Data.Count; Num++)
|
|
{
|
|
var BufSmart = DApps.Smart.DBSmart.Read(Num, 1);
|
|
if(!BufSmart)
|
|
break;
|
|
SizeForSend = SizeForSend - BufSmart.length;
|
|
if(SizeForSend < 0)
|
|
break;
|
|
BufLength += BufSmart.length;
|
|
Arr.push(BufSmart);
|
|
}
|
|
var Data2 = {Result:Arr.length ? 1 : 0, Arr:Arr};
|
|
var BufWrite = BufLib.GetBufferFromObject(Data2, FORMAT_SMART_TRANSFER, BufLength, {});
|
|
process.send({cmd:"Send", addrStr:msg.addrStr, Method:"RETSMART", Context:msg.Context, Data:BufWrite});
|
|
};
|