topbit 1.0.0 → 2.0.0

package/src/logger.js

@@ -0,0 +1,32 @@
+'use strict'
+const process = require('node:process');
+
+module.exports = function (msg) {
+  let tm = new Date();
+  let tmstr = 
+    `${tm.getFullYear()}-${tm.getMonth()+1}-${tm.getDate()} ${tm.getHours()}:${tm.getMinutes()}:${tm.getSeconds()}`;
+
+  let log_data = {
+    type  : '_log',
+    success : true,
+    status : msg.status,
+    method: msg.method,
+    ip: msg.ip,
+    real_ip: msg.real_ip,
+    log : `@ ${msg.method} | ${msg.link} | ${msg.status} | ${tmstr} | ${msg.ip} | ${msg.agent} | ${msg.real_ip}\n`
+  };
+
+  if (msg.status >= 400) {
+    log_data.success = false;
+  }
+
+  if (process.send && typeof process.send === 'function') {
+    process.send(log_data);
+  } else {
+    if (log_data.success) {
+      console.log(log_data.log);
+    } else {
+      console.error(log_data.log);
+    }
+  }
+};

package/src/loggermsg.js

@@ -0,0 +1,349 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const fsp = fs.promises;
+
+let fmtTime = () => {
+  let t = new Date();
+  let m = t.getMonth() + 1;
+  let d = t.getDate();
+  let h = t.getHours();
+  let mt = t.getMinutes();
+  let sec = t.getSeconds();
+
+  return `${t.getFullYear()}_${m < 10 ? '0' : ''}${m}_${d < 10 ? '0' : ''}${d}`
+      + `_${h < 10 ? '0' : ''}${h}_${mt < 10 ? '0' : ''}${mt}`
+      + `_${sec < 10 ? '0' : ''}${sec}`;
+};
+
+class loggermsg {
+
+  constructor (options) {
+    this.config = options;
+
+    this.out = null;
+
+    this.fout = null;
+    this.ferr = null;
+
+    this.watchReset = false;
+
+    this.count = 0;
+
+    this.errCount = 0;
+
+    this.maxLines = this.config.logMaxLines;
+
+    this.maxSize = 200 * this.maxLines;
+
+    this.checkLock = false;
+
+    this.historyList = [];
+    this.errHistoryList = [];
+
+    this.logfile = '';
+    this.logDir = '';
+    this.errfile = '';
+    this.errLogDir = '';
+
+    this.prefix = '';
+    this.eprefix = '';
+
+    this.premap = {
+      logfile: 'prefix',
+      errfile: 'eprefix'
+    };
+
+    this.parseLogPath();
+    this.parsePrefix();
+  }
+
+  parsePrefix() {
+    let keys = ['logfile', 'errfile'];
+ 
+    keys.forEach(a => {
+      let leng = this[a].length
+      let extname = this[a].substring(leng-4).toLowerCase()
+      let k = this.premap[a]
+
+      if (extname === '.log') {
+        this[k] = this[a].substring(0, leng-4) + '_'
+      } else {
+        this[k] = this[a] + '_'
+      }
+
+    })
+  }
+
+  parseLogPath () {
+    if (this.config.logType !== 'file') return;
+
+    this.logfile = path.basename(this.config.logFile);
+    this.errfile = path.basename(this.config.errorLogFile);
+    this.logDir = path.resolve( path.dirname(this.config.logFile) );
+    this.errLogDir = path.resolve( path.dirname(this.config.errorLogFile) );
+  }
+
+  //在init之后运行
+  watch () {
+    if (this.config.logType !== 'file') {
+      return;
+    }
+
+    let wtf = (evt, fname) => {
+      if (this.watchReset) {
+        return;
+      }
+
+      if (evt === 'rename') {
+        if (fname !== this.logfile && fname !== this.errfile ) {
+          return;
+        }
+        this.watchReset = true;
+        this.destroy();
+        this.init();
+        this.watchReset = false;
+      }
+    };
+
+    try {
+      fs.watch(this.logDir, wtf);
+    } catch (err) {}
+
+    if (this.logDir !== this.errLogDir) {
+      try {
+        fs.watch(this.errLogDir, wtf);
+      } catch (err) {}
+    }
+
+  }
+
+  destroy () {
+    try {
+      if (this.fout && !this.fout.destroyed) {
+        this.fout.destroy();
+      }
+      if (this.ferr && !this.ferr.destroyed) {
+        this.ferr.destroy();
+      }
+    } catch (err) {}
+
+    this.fout = this.ferr = this.out = null;
+  }
+
+  /**
+   * 用于init之前的检测工作，主要检测日志文件是否已经超过了最大限制，
+   * 如果服务进程反复运行，会导致日志文件不断增大。
+   * 解决方案就是如果初始检测发现日志文件已经存在并且已经超过最大限制，
+   * 则直接设置计数为maxLines，让日志处理程序自动把它保存为备份日志文件。
+   * */
+  async _checkBeforeInit () {
+    if (this.config.logType !== 'file') return;
+
+    try {
+      await fsp.access(this.config.logFile);
+      let fa = await fsp.stat(this.config.logFile);
+
+      if (fa.size >= this.maxSize) {
+        this.count = this.maxLines;
+      }
+    } catch (err) {
+
+    }
+
+    try {
+      await fsp.access(this.config.errorLogFile);
+      let fb = await fsp.stat(this.config.errorLogFile);
+      if (fb.size >= this.maxSize) {
+        this.errCount = this.maxLines;
+      }
+    } catch (err) {
+
+    }
+
+  }
+
+  init () {
+    if (this.config.logType === 'file') {
+      this.out = null;
+
+      if (this.fout === null) {
+          try {
+            this.fout = fs.createWriteStream(this.config.logFile, { flags: 'a+', mode: 0o644 });
+            
+            this.fout.on('close', () => {
+              this.fout = null;
+            });
+
+            this.fout.on('error', err => {
+              this.fout = null;
+            });
+          } catch (err) {
+            this.config.errorHandle(err, '--ERR-LOGGER-INIT--');
+          }
+      }
+
+      if (this.ferr === null) {
+          try {
+              this.ferr = fs.createWriteStream(this.config.errorLogFile, { flags: 'a+', mode: 0o644 });
+
+              this.ferr.on('close', () => {
+                this.ferr = null;
+              });
+
+              this.ferr.on('error', err => {
+                this.ferr = null;
+              });
+
+          } catch (err) {
+            this.config.errorHandle(err, '--ERR-LOGGER-INIT--');
+          }
+      }
+
+    } else if (this.config.logType === 'stdio') {
+      if (!this.out) {
+        let opts = {
+              stdout: process.stdout,
+              stderr: process.stderr
+            };
+
+        this.out = new console.Console(opts);
+      }
+    }
+  }
+
+  async _checkAndInit (k, ct, fname, curname, dirname, hlist) {
+    if (!this[k]) return;
+    if (this[ct] < this.maxLines) return;
+
+    let prename = this.premap[curname];
+
+    let history_logfile = `${this[dirname]}/${this[prename]}${fmtTime()}.log`;
+
+    let st = true;
+
+    await fsp.rename(fname, history_logfile).catch(err => {
+        st = false;
+        //检测是否还存在日志文件，若没有则初始化。
+        fs.access(fname, err => {
+          if (!err) return;
+          this[k] && !this[k].destroyed && this[k].destroy();
+          this[ct] = 0;
+          this.init();
+        });
+    });
+
+    if (!st) return;
+
+    this[hlist].push(history_logfile);
+    this[k] && !this[k].destroyed && this[k].destroy();
+    this[k] = null;
+    this[ct] = 0;
+
+    this.init();
+  }
+
+  async checkLog () {
+    if (this.checkLock) return;
+
+    this.checkLock = true;
+    try {
+      this.clearHistoryList('historyList');
+      this.clearHistoryList('errHistoryList');
+
+      await this._checkAndInit('fout', 'count',
+                this.config.logFile,
+                'logfile',
+                'logDir',
+                'historyList');
+      
+      await this._checkAndInit('ferr', 'errCount',
+                this.config.errorLogFile,
+                'errfile',
+                'errLogDir',
+                'errHistoryList');
+
+    } catch (err) {
+      this.config.errorHandle(err, '--ERR-CHECK-LOG--');
+    } finally {
+      this.checkLock = false;
+    }
+
+  }
+
+  clearHistoryList(k) {
+    let hlist = this[k];
+    
+    if (!hlist || !Array.isArray(hlist)) return;
+
+    if (hlist.length > (this.config.logHistory + 2)) {
+        let hfile;
+        let i=0;
+        let total = 3;
+        while (i < total) {
+          hfile = hlist.shift();
+          
+          if (!hfile) return;
+
+          fs.unlink(hfile, err => {
+            err && (!err.code || err.code !== 'ENOENT') && this.config.errorHandle(err, '--ERR-UNLINK-LOG--')
+          });
+
+          i += 1;
+        }
+    }
+  }
+
+  msgEvent () {
+    if (typeof this.config.logHandle === 'function') {
+      return this.config.logHandle
+    }
+    
+    let handle_none = (w, msg, handle) => {}
+
+    if (this.config.logType === '') {
+      return handle_none
+    }
+
+    let handle_file = (w, msg, handle) => {
+        if (msg.success) {
+          this.fout && this.fout.write(msg.log) && (this.count += 1);
+        } else {
+          this.ferr && this.ferr.write(msg.log) && (this.errCount += 1);
+        }
+
+        if (!this.fout || !this.ferr) {
+          this.init();
+        }
+
+        this.checkLog();
+    }
+
+    let handle_stdio = (w, msg, handle) => {
+        if (this.out) {
+          msg.success ? this.out.log(msg.log) : this.out.error(msg.log);
+        } else {
+          this.init();
+        }
+    }
+
+    if (this.config.logType === 'file') {
+      return handle_file
+    }
+
+    /*
+    if (this.config.logType === 'mix') {
+      return (w, msg, handle) => {
+        handle_file(w, msg, handle)
+        handle_stdio(w, msg, handle)
+      }
+    }*/
+
+    return handle_stdio
+  }
+
+}
+
+module.exports = loggermsg;

package/src/makeId.js

@@ -0,0 +1,200 @@
+'use strict'
+
+const randstring = require('./randstring.js');
+
+//2017-2-25  2050
+let start_time = 1490390182066
+
+let start_year = 2024
+
+if ((new Date()).getFullYear() > 2085) {
+  start_year = 2086
+}
+
+let loopch = [
+  "0","1","2","3","4","5","6","7","8","9",
+  "a","b","c","d","e","f","g","h","i","j",
+  "k","l","m","n","o","p","q","r","s","t",
+  "u","v","w","x","y","z"
+]
+
+let msloopch = []
+for (let x of loopch) {
+  for (let y of loopch) {
+    msloopch.push(x+y)
+  }
+}
+
+let sloopch = msloopch.slice(0, 100)
+let yloopch = msloopch.slice(36, 500)
+
+msloopch = msloopch.slice(parseInt(Math.random() * 100))
+
+let loopLength = loopch.length
+let sloopLength = sloopch.length
+let yloopLength = yloopch.length
+
+class Clocks {
+  constructor() {
+    this.clocks = {
+      y: 0,
+      m: 0,
+      d: 0
+    }
+
+    this.startYear = 2024
+  }
+
+  rand() {
+    for (let k in this.clocks) {
+      this.clocks[k] = parseInt(loopLength * Math.random())
+    }
+  }
+
+  getFullTime() {
+    return this.getTime() + this.getCharTime()
+  }
+
+  getTime() {
+    let t = new Date()
+    let year = t.getFullYear()
+    let month = t.getMonth()
+    let dat = t.getDate()
+    let hour = t.getHours()
+    let minute = t.getMinutes()
+    let seconds = t.getSeconds()
+    let ms = t.getMilliseconds()
+    
+    let yind = year - this.startYear
+
+    if (yind < 0 || yind >= yloopLength) yind = 0
+
+    //bits: 2 + 1 + 1 + 1 + 2 + 2 + 2 = 11
+    return yloopch[yind] + loopch[month] + loopch[dat] + loopch[hour] + sloopch[minute] + sloopch[seconds] + msloopch[ms]
+  }
+
+  getCharTime() {
+    let str = loopch[this.clocks.y] + loopch[this.clocks.m] + loopch[this.clocks.d]
+    
+    this.clocks.d++
+    if (this.clocks.d >= loopLength) {
+      this.clocks.d = 0
+      this.clocks.m++
+      if (this.clocks.m >= loopLength) {
+        this.clocks.m = 0
+        this.clocks.y++
+        if (this.clocks.y >= loopLength) {
+          this.clocks.y = 0
+        }
+      }
+    }
+
+    return str
+  }
+
+}
+
+function longId(idLen=18, idPre = '') {
+  let pstr = (Date.now() - start_time).toString(16)
+  let leng = pstr.length
+  if (idLen < 18) idLen = 18
+  return idPre + pstr + randstring(idLen - leng)
+}
+
+function makeId(idLen = 12, idPre = '') {
+  if (idLen > 17) {
+    return longId(idLen, idPre);
+  }
+
+  let tmstr = Math.random().toString(16).substring(2);
+
+  if (tmstr.length < idLen) {
+    tmstr = `${tmstr}${randstring(idLen - tmstr.length)}`;
+  }
+
+  if (tmstr.length > idLen) {
+    tmstr = tmstr.substring(tmstr.length - idLen);
+  }
+
+  if (idPre) {
+    return `${idPre}${tmstr}`;
+  }
+
+  return tmstr;
+}
+
+let b_year = 2**47
+let b_month = 2**43
+let b_date = 2**38
+let b_hour = 2**33
+let b_min = 2**27
+let b_sec = 2**21
+let b_msec = 2**11
+
+let end_max = 4096
+
+function numId(obj) {
+  let t = new Date()
+
+  let first_num = (t.getFullYear() - start_year) * b_year + (t.getMonth()+1) * b_month
+                  + t.getDate() * b_date + t.getHours() * b_hour + t.getMinutes() * b_min
+                  + t.getSeconds() * b_sec + t.getMilliseconds() * b_msec
+
+  let fnum = first_num + obj.endnum
+
+  obj.endnum++
+
+  if (obj.endnum >= end_max) {
+    obj.endnum = 0
+  }
+
+  return fnum
+}
+
+function bigId(obj, a='', b='') {
+  let fnum = numId(obj)
+  return (BigInt(fnum) * 1000n + BigInt(parseInt(Math.random() * 1000))).toString()
+}
+
+Object.defineProperty(makeId, 'numId', {
+  enumerable: false,
+  configurable: false,
+  get: function () {
+    let oo = {
+      endnum: parseInt(Math.random() * 2000)
+    }
+
+    return numId.bind(null, oo)
+  }
+})
+
+Object.defineProperty(makeId, 'bigId', {
+  enumerable: false,
+  configurable: false,
+  get: function () {
+    let oo = {
+      endnum: parseInt(Math.random() * 2000)
+    }
+
+    return bigId.bind(null, oo)
+  }
+})
+
+makeId.longId = longId
+
+Object.defineProperty(makeId, 'serialId', {
+  enumerable: false,
+  configurable: false,
+  get: function () {
+    let _next = new Clocks()
+    _next.rand()
+
+    return function sid(idLen=16, idPre='') {
+      if (idLen < 14) return makeId(idLen, idPre)
+
+      return idPre + _next.getFullTime() + randstring(idLen - 14)
+    }
+  }
+})
+
+module.exports = makeId;