424 lines
13 KiB
TypeScript
424 lines
13 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
|
|
*/
|
|
|
|
require("./constant.js");
|
|
var fs = require('fs');
|
|
require("./log-strict.js");
|
|
var file_name_info = global.GetDataPath("info.log");
|
|
var file_name_infoPrev = global.GetDataPath("info-prev.log");
|
|
global.CheckSizeLogFile(file_name_info, file_name_infoPrev);
|
|
var file_name_log = global.GetDataPath("log.log");
|
|
var file_name_logPrev = global.GetDataPath("log-prev.log");
|
|
global.CheckSizeLogFile(file_name_log, file_name_logPrev);
|
|
var file_name_log_web = global.GetDataPath("web.log");
|
|
var file_name_log_webPrev = global.GetDataPath("web-prev.log");
|
|
global.CheckSizeLogFile(file_name_log_web, file_name_log_webPrev);
|
|
var file_name_error = global.GetDataPath("err.log");
|
|
var file_name_errorPrev = global.GetDataPath("err-prev.log");
|
|
global.CheckSizeLogFile(file_name_error, file_name_errorPrev);
|
|
var file_name_error_tx = global.GetDataPath("err-tx.log");
|
|
var file_name_error_txPrev = global.GetDataPath("err-tx-prev.log");
|
|
global.CheckSizeLogFile(file_name_error_tx, file_name_error_txPrev);
|
|
global.ToLog = function(Str, Level) {
|
|
if (Level === undefined)
|
|
Level = 1;
|
|
if (Level && Level > global.LOG_LEVEL)
|
|
return;
|
|
if (global.ALL_LOG_TO_CLIENT)
|
|
ToLogClient(Str, undefined, undefined);
|
|
else
|
|
ToLogFile(file_name_log, Str);
|
|
};
|
|
global.WEB_LOG = 0;
|
|
global.ToLogWeb = function(Str) {
|
|
if (global.WEB_LOG) {
|
|
SaveToLogFileSync(file_name_log_web, Str);
|
|
}
|
|
};
|
|
global.SmallAddr = function(Str) {
|
|
return Str.substr(0, 5);
|
|
};
|
|
global.ToErrorTrace = function(Str) {
|
|
global.ToError("" + Str + ":" + new Error().stack);
|
|
};
|
|
global.ToLogTrace = function(Str) {
|
|
global.ToErrorTrace(Str);
|
|
};
|
|
global.ToInfo = function(Str) {
|
|
ToLogFile(file_name_info, Str, 1);
|
|
};
|
|
global.ToError = function(Str) {
|
|
ToLogFile(file_name_error, Str);
|
|
};
|
|
global.ToErrorTx = function(Str) {
|
|
SaveToLogFileSync(file_name_error_tx, Str);
|
|
global.ToLog(Str);
|
|
};
|
|
|
|
function ToLogFile(file_name, Str, bNoFile?) {
|
|
if (Str instanceof Error) {
|
|
Str = Str.message + "\n" + Str.stack;
|
|
}
|
|
if (!global.START_SERVER)
|
|
Str = global.PROCESS_NAME + ": " + Str;
|
|
if (global.PROCESS_NAME !== "MAIN" && process.send) {
|
|
process.send({ cmd: "log", message: Str });
|
|
return;
|
|
} else {
|
|
console.log("" + global.START_PORT_NUMBER + ": " + global.GetStrOnlyTime() + ": " + Str);
|
|
}
|
|
if (bNoFile)
|
|
return;
|
|
SaveToLogFileSync(file_name, Str);
|
|
};
|
|
global.ArrLogClient = [];
|
|
|
|
function ToLogClient(Str, StrKey, bFinal) {
|
|
if (!Str)
|
|
return;
|
|
ToLogFile(file_name_log, Str);
|
|
if (!StrKey)
|
|
StrKey = "";
|
|
global.ArrLogClient.push({ text: global.GetStrOnlyTime() + " " + Str, key: StrKey, final: bFinal, });
|
|
if (global.ArrLogClient.length > 13)
|
|
global.ArrLogClient.shift();
|
|
};
|
|
global.ToLogClient = ToLogClient;
|
|
global.ToLogClient0 = ToLogClient;
|
|
var StartStatTime;
|
|
var CONTEXT_STATS = { Total: {}, Interval: [] };
|
|
var CONTEXT_ERRORS = { Total: {}, Interval: [] };
|
|
var CurStatIndex = 0;
|
|
global.PrepareStatEverySecond = function() {
|
|
CurStatIndex++;
|
|
var index = GetCurrentStatIndex();
|
|
CopyStatInterval(CONTEXT_STATS, index);
|
|
CopyStatInterval(CONTEXT_ERRORS, index);
|
|
};
|
|
global.TO_ERROR_LOG = function(Module, ErrNum, Str, type, data1, data2) {
|
|
if (Str instanceof Error) {
|
|
Str = Str.message + "\n";
|
|
}
|
|
if (type === "rinfo")
|
|
Str += " from: " + data1.address + ':' + data1.port;
|
|
else
|
|
if (type === "node")
|
|
Str += " from: " + data1.ip + ':' + data1.port;
|
|
var Key = Module + ":" + ErrNum;
|
|
global.ToError(" ==ERROR== " + Key + " " + Str);
|
|
AddToStatContext(CONTEXT_ERRORS, Key);
|
|
global.ADD_TO_STAT("ERRORS");
|
|
};
|
|
|
|
function GetCurrentStatIndex() {
|
|
var DefMaxStatPeriod = global.MAX_STAT_PERIOD * 2 + 2;
|
|
return CurStatIndex % DefMaxStatPeriod;
|
|
};
|
|
global.HASH_RATE = 0;
|
|
global.ADD_HASH_RATE = function(Count) {
|
|
Count = Count / 1000000;
|
|
global.HASH_RATE += Count;
|
|
global.ADD_TO_STAT("HASHRATE", Count);
|
|
};
|
|
global.GET_STAT = function(Key) {
|
|
var Val = CONTEXT_STATS.Total[Key];
|
|
if (!Val)
|
|
Val = 0;
|
|
return Val;
|
|
};
|
|
global.ADD_TO_STAT_TIME = function(Name, startTime, bDetail) {
|
|
if (global.STAT_MODE) {
|
|
if (bDetail && global.STAT_MODE !== 2)
|
|
return;
|
|
var Time = process.hrtime(startTime);
|
|
var deltaTime = Time[0] * 1000 + Time[1] / 1e6;
|
|
global.ADD_TO_STAT(Name, deltaTime);
|
|
}
|
|
};
|
|
global.ADD_TO_STAT = function(Key, Count, bDetail) {
|
|
if (global.STAT_MODE) {
|
|
if (bDetail && global.STAT_MODE !== 2)
|
|
return;
|
|
AddToStatContext(CONTEXT_STATS, Key, Count);
|
|
}
|
|
};
|
|
global.GET_STATDIAGRAMS = function(Keys) {
|
|
var now = global.GetCurrentTime();
|
|
var index = GetCurrentStatIndex();
|
|
if (!Keys || !Keys.length)
|
|
return [];
|
|
var Data = [];
|
|
for (var i = 0; i < Keys.length; i++) {
|
|
var name = Keys[i];
|
|
var Value = GetDiagramData(CONTEXT_STATS, name);
|
|
Data.push({ name: name, maxindex: index, arr: Value, starttime: (StartStatTime - 0), steptime: 1 });
|
|
}
|
|
var MinLength = undefined;
|
|
for (var i = 0; i < Data.length; i++) {
|
|
var arr = Data[i].arr;
|
|
if (arr.length > 0 && (MinLength === undefined || arr.length < MinLength))
|
|
MinLength = arr.length;
|
|
}
|
|
var MaxSizeArr = 500;
|
|
for (var i = 0; i < Data.length; i++) {
|
|
var ItemServer = Data[i];
|
|
var arr = ItemServer.arr;
|
|
if (MinLength && arr.length > MinLength) {
|
|
arr = arr.slice(arr.length - MinLength);
|
|
}
|
|
if (MinLength)
|
|
if (",POWER_MY_WIN,POWER_BLOCKCHAIN,".indexOf("," + ItemServer.name + ",") >= 0) {
|
|
arr = global.SERVER.GetStatBlockchain(ItemServer.name, MinLength);
|
|
}
|
|
var AvgValue = 0;
|
|
for (var j = 0; j < arr.length; j++) {
|
|
if (arr[j])
|
|
AvgValue += arr[j];
|
|
}
|
|
if (arr.length > 0)
|
|
AvgValue = AvgValue / arr.length;
|
|
var StepTime = 1;
|
|
if (ItemServer.name.substr(0, 4) === "MAX:") {
|
|
while (arr.length >= MaxSizeArr) {
|
|
arr = ResizeArrMax(arr);
|
|
StepTime = StepTime * 2;
|
|
}
|
|
} else {
|
|
while (arr.length >= MaxSizeArr) {
|
|
arr = ResizeArrAvg(arr);
|
|
StepTime = StepTime * 2;
|
|
}
|
|
}
|
|
ItemServer.AvgValue = AvgValue;
|
|
ItemServer.steptime = StepTime;
|
|
ItemServer.arr = arr.slice(1);
|
|
}
|
|
return Data;
|
|
};
|
|
global.GET_STATS = function(Key) {
|
|
var now = global.GetCurrentTime();
|
|
var index = GetCurrentStatIndex();
|
|
var stats = {
|
|
Counter: CONTEXT_STATS.Total, Counter10S: CalcInterval(CONTEXT_STATS, index, 10), Counter10M: CalcInterval(CONTEXT_STATS,
|
|
index, 10 * 60),
|
|
};
|
|
var errors = {
|
|
Counter: CONTEXT_ERRORS.Total, Counter10S: CalcInterval(CONTEXT_ERRORS, index, 10), Counter10M: CalcInterval(CONTEXT_ERRORS,
|
|
index, 10 * 60),
|
|
};
|
|
var Period = (now - StartStatTime) / 1000;
|
|
return { stats: stats, errors: errors, period: Period, Confirmation: [] };
|
|
};
|
|
global.StartCommonStat = function() {
|
|
for (var key in CONTEXT_STATS.Total)
|
|
return;
|
|
global.ClearCommonStat();
|
|
};
|
|
global.ClearCommonStat = function() {
|
|
CurStatIndex = 0;
|
|
StartStatTime = undefined;
|
|
CONTEXT_STATS = { Total: {}, Interval: [] };
|
|
CONTEXT_ERRORS = { Total: {}, Interval: [] };
|
|
global.HASH_RATE = 0;
|
|
global.SERVER.ClearStat();
|
|
};
|
|
|
|
function ResizeArrMax(arr) {
|
|
var arr2 = [];
|
|
var Count2 = Math.trunc(arr.length / 2);
|
|
for (var i = 0; i < Count2; i++) {
|
|
arr2[i] = Math.max(arr[i * 2], arr[i * 2 + 1]);
|
|
}
|
|
return arr2;
|
|
};
|
|
|
|
function ResizeArrAvg(arr) {
|
|
var arr2 = [];
|
|
var Count2 = Math.trunc(arr.length / 2);
|
|
for (var i = 0; i < Count2; i++) {
|
|
arr2[i] = (arr[i * 2] + arr[i * 2 + 1]) / 2;
|
|
}
|
|
return arr2;
|
|
};
|
|
|
|
function ResizeArr(arr) {
|
|
var arr2 = [];
|
|
var Count2 = Math.trunc(arr.length / 2);
|
|
for (var i = 0; i < Count2; i++) {
|
|
arr2[i] = arr[i * 2];
|
|
}
|
|
return arr2;
|
|
};
|
|
global.ResizeArrAvg = ResizeArrAvg;
|
|
global.ResizeArrMax = ResizeArrMax;
|
|
|
|
function GetDiagramData(Context, Key) {
|
|
var DefMaxStatPeriod = global.MAX_STAT_PERIOD * 2 + 2;
|
|
var IsMax;
|
|
if (Key.substr(0, 4) === "MAX:")
|
|
IsMax = true;
|
|
else
|
|
IsMax = false;
|
|
var delta = global.MAX_STAT_PERIOD;
|
|
var index2 = GetCurrentStatIndex();
|
|
var index1 = (index2 - delta + DefMaxStatPeriod) % DefMaxStatPeriod;
|
|
var Total = Context.Total;
|
|
var Counter1;
|
|
var arr = [];
|
|
var PrevValue = undefined;
|
|
for (var i = index1; i < index1 + delta; i++) {
|
|
var index3 = i % DefMaxStatPeriod;
|
|
Counter1 = Context.Interval[index3];
|
|
if (Counter1) {
|
|
var Value = Counter1[Key];
|
|
if (Value !== undefined) {
|
|
if (!IsMax) {
|
|
if (PrevValue !== undefined) {
|
|
arr.push(Value - PrevValue);
|
|
} else {
|
|
arr.push(Value);
|
|
}
|
|
PrevValue = Value;
|
|
} else {
|
|
arr.push(Value);
|
|
}
|
|
} else {
|
|
arr.push(0);
|
|
}
|
|
}
|
|
}
|
|
return arr;
|
|
};
|
|
|
|
function CalcInterval(Context, index2, delta) {
|
|
var DefMaxStatPeriod = global.MAX_STAT_PERIOD * 2 + 2;
|
|
var Res = {};
|
|
var index1 = (index2 - delta + DefMaxStatPeriod) % DefMaxStatPeriod;
|
|
var Total = Context.Total;
|
|
var Counter1;
|
|
for (var i = index1; i < index1 + delta; i++) {
|
|
var index3 = i % DefMaxStatPeriod;
|
|
Counter1 = Context.Interval[index3];
|
|
if (Counter1)
|
|
break;
|
|
}
|
|
if (Counter1)
|
|
for (var Key in Total) {
|
|
if (Key.substr(0, 4) === "MAX:")
|
|
Res[Key] = 0;
|
|
else {
|
|
if (Counter1[Key] === undefined)
|
|
Res[Key] = Total[Key];
|
|
else
|
|
Res[Key] = Total[Key] - Counter1[Key];
|
|
}
|
|
}
|
|
return Res;
|
|
};
|
|
|
|
function AddToStatContext(Context, Key, AddValue?) {
|
|
if (AddValue === undefined)
|
|
AddValue = 1;
|
|
var Val = Context.Total[Key];
|
|
if (!Val)
|
|
Val = 0;
|
|
if (Key.substr(0, 4) === "MAX:")
|
|
Val = Math.max(Val, AddValue);
|
|
else
|
|
Val = Val + AddValue;
|
|
Context.Total[Key] = Val;
|
|
if (!StartStatTime)
|
|
StartStatTime = global.GetCurrentTime(0);
|
|
};
|
|
|
|
function CopyStatInterval(Context, index) {
|
|
var Counter = Context.Interval[index];
|
|
if (!Counter) {
|
|
Counter = {};
|
|
Context.Interval[index] = Counter;
|
|
}
|
|
var Total = Context.Total;
|
|
for (var Key in Total) {
|
|
Counter[Key] = Total[Key];
|
|
if (Key.substr(0, 4) === "MAX:")
|
|
Total[Key] = 0;
|
|
}
|
|
};
|
|
if (global.DEBUG_MODE)
|
|
global.TO_DEBUG_LOG = function(Str, type, data1, data2) {
|
|
if (!global.DEBUG_MODE)
|
|
return;
|
|
if (type === "rinfo")
|
|
Str += " from: " + data1.address + ':' + data1.port + ' - ' + data2.length;
|
|
global.ToLog(Str);
|
|
};
|
|
else
|
|
global.TO_DEBUG_LOG = function(Str, type, data1, data2) {
|
|
};
|
|
|
|
function SaveToLogFileAsync(fname, Str) {
|
|
fs.open(fname, "a", undefined, function(err, file_handle) {
|
|
if (!err) {
|
|
var StrLog = global.GetStrTime() + " : " + Str + "\r\n";
|
|
fs.write(file_handle, StrLog, null, 'utf8', function(err, written) {
|
|
if (!err) {
|
|
fs.close(file_handle, function(err) {
|
|
if (err)
|
|
console.log(err);
|
|
});
|
|
}
|
|
else {
|
|
console.log("Ошибка записи в лог-файл ошибок!");
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
console.log("Ошибка открытия лог-файла ошибок");
|
|
}
|
|
});
|
|
};
|
|
|
|
function SaveToLogFileSync(fname, Str) {
|
|
try {
|
|
var StrLog = global.GetStrTime() + " : " + Str + "\r\n";
|
|
var file_handle = fs.openSync(fname, "a");
|
|
fs.writeSync(file_handle, StrLog, null, 'utf8');
|
|
fs.closeSync(file_handle);
|
|
}
|
|
catch (err) {
|
|
console.log(err.message);
|
|
}
|
|
};
|
|
global.GetStrOnlyTime = function(now) {
|
|
if (!global.GetCurrentTime)
|
|
return ":::";
|
|
if (!now)
|
|
now = global.GetCurrentTime();
|
|
var Str = "" + now.getHours().toStringZ(2);
|
|
Str = Str + ":" + now.getMinutes().toStringZ(2);
|
|
Str = Str + ":" + now.getSeconds().toStringZ(2);
|
|
Str = Str + "." + now.getMilliseconds().toStringZ(3);
|
|
return Str;
|
|
};
|
|
global.GetStrTime = function(now) {
|
|
if (!global.GetCurrentTime)
|
|
return ":::";
|
|
if (!now)
|
|
now = global.GetCurrentTime();
|
|
var Str = "" + now.getDate().toStringZ(2);
|
|
Str = Str + "." + (1 + now.getMonth()).toStringZ(2);
|
|
Str = Str + "." + now.getFullYear();
|
|
Str = Str + " " + now.getHours().toStringZ(2);
|
|
Str = Str + ":" + now.getMinutes().toStringZ(2);
|
|
Str = Str + ":" + now.getSeconds().toStringZ(2);
|
|
Str = Str + "." + now.getMilliseconds().toStringZ(3);
|
|
return Str;
|
|
};
|