topbit 1.0.0 → 3.0.0

package/src/extends/cors.js

@@ -0,0 +1,334 @@
+'use strict';
+
+/**
+ * 跨域请求中，在以下情况下，origin不会出现：
+ *        https页面请求http接口。
+ *        但是在目前的策略中，在https页面中，引入http资源会引入不安全因素。
+ *        浏览器会报错：已阻止载入混合活动内容。
+ * 
+ * 跨域请求中，origin字段是必须的。
+ * 
+ * 在https跨域测试中，若要使用自签名的证书，必须先通过浏览器访问后端API，并把证书添加信任。
+ * 
+ * 这之后，fetch才会成功请求。
+ * 
+ * 这里讨论的跨域和referer问题只有在浏览器环境才会有效，通过命令请求完全不会理会这些处理过程。
+ * 
+ * 严格的权限控制要通过token以及其他数据检测手段。
+ * 
+ * 所以为了保证服务既可以适用于跨域也可以同源，必须要针对referer进行检测。
+ *
+ * 你可以设置在允许的referer内也返回消息头，因为有些应用根本不给你发送这个origin消息头，比如小程序。
+ *
+ * Access-Control-Allow-Credentials需要单独考虑，这个消息头需要用在浏览器环境下的fetch、Request使用了credentials选项为true的情况下。
+ * 这个时候，access-control-allow-origin不能是*而是具体的host。
+ * 这个通信过程是前后端需要协商好的，否则会出现cors报错。
+ * 
+ */
+
+class Cors {
+
+  constructor(options = {}) {
+    
+    //某些情况下，因为状态码是204导致连接提前关闭。
+    this.statusCode = 200;
+
+    this.allow = '*';
+    
+    this.allowHeaders = 'authorization,content-type';
+
+    this.allowHeaderTable = {};
+
+    this.requestHeaders = '*';
+
+    this.credentials = false;
+
+    //Access-Control-Expose-Headers 指定哪些消息头可以暴露给请求端。
+    this.exposeHeaders = '';
+
+    this.allowEmptyReferer = true;
+
+    this.emptyRefererGroup = null;
+
+    this.referer = '';
+
+    this.methods = [
+      'GET', 'POST', 'DELETE', 'PUT', 'OPTIONS', 'PATCH', 'HEAD'
+    ];
+
+    if (typeof options !== 'object') {
+      options = {};
+    }
+
+    this.optionsCache = null;
+
+    for (let k in options) {
+      switch (k) {
+        case 'allow':
+          if (options[k] === '*' || Array.isArray(options[k])) {
+            this.allow = options[k];
+          }
+          break;
+
+        case 'credentials':
+          this.credentials = !!options[k];
+          break;
+
+        case 'allowEmptyReferer':
+          this.allowEmptyReferer = !!options[k];
+          break;
+        
+        //允许提交空referer的路由分组
+        case 'emptyRefererGroup':
+          if (typeof options[k] === 'string') options[k] = [ options[k] ];
+          if (Array.isArray(options[k])) this.emptyRefererGroup = options[k];
+          break;
+
+        case 'referer':
+          if (options[k] === '*') {
+            this[k] = '*';
+          } else {
+            if (typeof options[k] === 'string') options[k] = [ options[k] ];
+            if (Array.isArray(options[k])) this[k] = options[k];
+          }
+          break;
+
+        case 'requestHeaders':
+          this.requestHeaders = options[k];
+          break;
+
+        case 'methods':
+          if ((options[k] instanceof Array) || typeof options[k] === 'string') {
+            this.methods = options[k];
+          }
+
+          break;
+
+        case 'optionsCache':
+        case 'maxAge':
+          if (!isNaN(options[k]))
+            this.optionsCache = options[k];
+          break;
+
+        case 'allowHeaders':
+          if (Array.isArray(options[k])) {
+            if (options[k].length > 0)
+              this.allowHeaders = options[k].join(',');
+          } else if (typeof options[k] === 'string') {
+            this.allowHeaders = options[k].trim() || '*';
+          }
+
+          /* if (this.allowHeaders !== '*') {
+            this.allowHeaders.split(',')
+                .filter(p => p.length > 0)
+                .map(x => x.trim())
+                .forEach(x => {
+                  this.allowHeaderTable[x] = x;
+                });
+          } */
+          break;
+
+        case 'exposeHeaders':
+          this.exposeHeaders = options[k];
+          break;
+
+      }
+    }
+
+    if (this.methods instanceof Array) {
+      this.methodString = this.methods.join(',');
+    } else {
+      this.methodString = this.methods;
+    }
+
+    this.allowTable = {};
+    //记录是否用于referer检测。
+    this.refererTable = {};
+    this.refererList = [];
+
+    if (Array.isArray(this.allow)) {
+        let lastSlash = 0;
+        let midIndex, midChar, host, useForReferer;
+
+        for (let aw of this.allow) {
+            useForReferer = true;
+
+            if (!aw) continue;
+
+            if (typeof aw === 'string') host = aw.trim();
+            else if (typeof aw === 'object') {
+              host = aw.url || '';
+              useForReferer = !!aw.referer;
+            }
+
+            if (!host) continue;
+
+            lastSlash = host.length - 1;
+            while (host[lastSlash] === '/' && lastSlash > 0) lastSlash--;
+
+            //不允许 / 结尾。
+            if (lastSlash < host.length - 1) host = host.substring(0, lastSlash+1);
+            if (!host.trim()) continue;
+
+            midIndex = parseInt(host.length / 2);
+            midChar = host[midIndex];
+
+            this.allowTable[host] = {
+              url: host,
+              length: host.length,
+              lastIndex: host.length - 1,
+              last: host[host.length - 1],
+              midIndex: midIndex,
+              midChar: midChar,
+              slashIndex: host.indexOf('/', 8),
+              referer: useForReferer
+            };
+
+            if (useForReferer) {
+              this.refererTable[host] = this.allowTable[host];
+              this.refererList.push(this.allowTable[host]);
+            }
+        }
+
+        this.allow = Object.keys(this.allowTable);
+    }
+
+  }
+
+  checkOrigin(url) {
+    return this.allowTable[url] ? true : false;
+  }
+
+  checkReferer(url) {
+    if (this.allow === '*') return true;
+
+    let aobj;
+    let ulen = url.length;
+
+    let refererTotal = this.refererList.length;
+    
+    for (let i = 0; i < refererTotal; i++) {
+      aobj = this.refererList[i];
+
+      if (aobj.length > ulen || url[aobj.lastIndex] !== aobj.last) continue;
+
+      if (url[aobj.midIndex] !== aobj.midChar) continue;
+      
+      if (aobj.slashIndex > 0 && url[aobj.slashIndex] !== '/') continue;
+
+      if (url.indexOf(aobj.url) === 0) return true;
+    }
+
+    /* for (let u in this.refererTable) {
+      aobj = this.refererTable[u];
+      //允许的referer长度比真实的值要短，所以超过的必然不是，如果最后一个字符不匹配可以直接跳过。
+      if (aobj.length > ulen || url[aobj.length - 1] !== aobj.last) continue;
+
+      if (url[aobj.midIndex] !== aobj.midChar) continue;
+      
+      if (aobj.slashIndex > 0 && url[aobj.slashIndex] !== '/') continue;
+
+      //substring 之后 判等 比 indexOf 要慢。
+      if (url.indexOf(u) === 0) return true;
+    } */
+
+    return false;
+  }
+
+  /**
+   * 要区分两种状态：跨域请求和同源请求。
+   *    在同源请求：ctx.headers.referer必然是包含页面路径。
+   *    若直接请求此资源则不会返回数据。
+   * 
+   */
+
+  mid() {
+    let self = this;
+
+    return async (ctx, next) => {
+       //使用ctx.box.corsAllow控制，给中间件处理留出扩展空间。
+      //跨域请求，必须存在origin。
+      if (ctx.headers.origin) {
+          if (!(self.allow === '*'
+            || self.allowTable[ctx.headers.origin]
+            || ctx.box.corsAllow) )
+          {
+            return
+          }
+      } else {
+        /**
+         * 在浏览器里，如果是跨域，则必然会遵循跨域原则，所以origin和referer的规则都会有效。
+         * 若不是浏览器，仅凭CORS规范是无法约束非法请求的。
+         */
+        //有一种情况，直接返回的页面并不具备referer，所以前端页面的请求不能有跨域扩展。
+        //直接通过file方式进行，也不会有referer。
+        //如果referer前缀就是host说明是本网站访问
+
+        //非跨域请求，或仅仅是没有携带origin
+        let referer = ctx.headers.referer || ''
+        
+        //处理同源请求。允许提交空的referer或者允许某些路由分组可以提交空referer(针对前端页面)
+        //或者是检测到ctx.box.corsAllow，host和referer都是客户端的控制，检测必须要依赖服务端对host的配置。
+
+        if (!(
+              (!referer 
+                && (self.allowEmptyReferer || (self.emptyRefererGroup && self.emptyRefererGroup.indexOf(ctx.group) >= 0) ) 
+              )
+              || ctx.box.corsAllow || (referer && self.checkReferer(referer))
+            )
+        ) {
+          return
+        }
+       
+      }
+
+      let req_headers = ctx.headers['access-control-request-headers']
+
+      if (req_headers && req_headers.indexOf('x-credentials') >= 0) {
+        //如果前端使用了credentials为include选项，同时使用x-credentials消息头通知后台，此时要做特殊处理。
+        ctx.headers['x-credentials'] = 'include'
+        //ctx.setHeader('access-control-request-headers', req_headers);
+      }
+      //服务端也要包含此消息头。
+      ctx.setHeader('access-control-request-headers', self.requestHeaders)
+
+      if (self.credentials || ctx.headers['x-credentials'] === 'include') {
+        let host = '*'
+
+        if (ctx.headers.origin) {
+          host = ctx.headers.origin
+        } else if (ctx.headers.referer) {
+          // https:// 不必搜索。
+          let ind = ctx.headers.referer.indexOf('/', 8)
+          if (ind < 0) {
+            host = ctx.headers.referer
+          } else {
+            host = ctx.headers.referer.substring(0, ind)
+          }
+        }
+
+        ctx.setHeader('access-control-allow-credentials', 'true')
+        ctx.setHeader('access-control-allow-origin', host)
+      } else {
+        ctx.setHeader('access-control-allow-origin', '*')
+      }
+
+      ctx.setHeader('access-control-allow-methods', self.methodString)
+      ctx.setHeader('access-control-allow-headers', self.allowHeaders)
+
+      if (self.exposeHeaders)
+        ctx.setHeader('access-control-expose-headers', self.exposeHeaders)
+      if (ctx.method === 'OPTIONS') {
+        self.optionsCache && ctx.setHeader('access-control-max-age', self.optionsCache)
+        ctx.status(self.statusCode)
+      } else {
+        return await next(ctx)
+      }
+      
+    }
+
+  }
+
+}
+
+module.exports = Cors

package/src/extends/errorlog.js

@@ -0,0 +1,252 @@
+'use strict'
+
+const cluster = require('node:cluster')
+const fs = require('node:fs')
+const fsp = fs.promises
+
+const fmtTime = (m = 'long') => {
+  let t = new Date()
+  let year = t.getFullYear()
+  let month = t.getMonth() + 1
+  let day = t.getDate()
+  let hour = t.getHours()
+  let min = t.getMinutes()
+  let sec = t.getSeconds()
+
+  let mt = `${year}_${month > 9 ? '' : '0'}${month}_${day > 9 ? '' : '0'}${day}`
+
+  if (m === 'short') {
+    return mt
+  }
+
+  let md = `${mt}_${hour > 9 ? '' : '0'}${hour}`
+  if (m === 'middle') {
+    return md
+  }
+
+  return `${md}_${min > 9 ? '' : '0'}${min}_${sec > 9 ? '' : '0'}${sec}`
+}
+
+/**
+ * 错误收集程序，它运行在两种模式：单独的记录和发送给master进程。
+ * 
+ * 格式： 
+  ! --ERR-TAG-- | code | constructor name | message | time | extra info(ip, usera-gent...)
+  stack info
+
+  文件存储的命名格式：{prefix_name}_year_month_day_hour_minute_second.log
+ * 
+ */
+class ErrorLog {
+  constructor(options) {
+    if (!options || typeof options !== 'object') options = {}
+
+    this.flog = null
+    this.dir = './tmp'
+    this.prefix = 'errorlog_'
+    this.maxHistory = 100
+    this.maxLines = 10000
+    this.historyList = []
+    this.debug = false
+    this.selfLog = false
+    this.stdioOutput = false
+
+    for (let k in options) {
+      switch (k) {
+        case 'dir':
+        case 'prefix':
+          if (typeof options[k] === 'string' && options[k]) {
+            this[k] = options[k]
+          }
+          break
+
+        case 'debug':
+        case 'selfLog':
+        case 'stdioOutput':
+          this[k] = !!options[k]
+          break
+
+        case 'maxHistory':
+        case 'maxLines':
+          if (typeof options[k] === 'number' && options[k] > 0) {
+            this[k] = options[k]
+          }
+          break
+      }
+    }
+
+    this.logname = this.prefix + 'now.log'
+    this.logfile = this.dir + '/' + this.logname
+
+    this.initDirAndHistory()
+
+    this.count = 0
+    this.checkLock = false
+
+    this.initLogStream()
+  }
+
+  initDirAndHistory() {
+    if (!(cluster.isPrimary || this.selfLog)) return false;
+
+    try {
+      fs.accessSync(this.dir)
+    } catch (err) {
+      try {
+        fs.mkdirSync(this.dir, {mode: 0o755})
+      } catch (err) {
+        this.debug && console.error(err)
+      }
+    }
+
+    try {
+      let flist = fs.readdirSync(this.dir, {withFileTypes: true})
+      for (let f of flist) {
+        if (!f.isFile()) continue
+
+        if (f.name.substring(f.name.length - 4) !== '.log') continue
+
+        if (f.name === this.logfile) continue
+
+        if (f.name.indexOf(this.prefix) !== 0) continue
+
+        this.historyList.push(`${this.dir}/${f.name}`)
+      }
+    } catch (err) {
+      this.debug && console.error(err)
+    }
+  }
+
+  /**
+   * 
+   * @param {object} app - Titbit实例
+   */
+  init(app) {
+    if (app.strong && typeof app.strong === 'object') {
+      app.strong.errorHandle = this.sendErrorLog.bind(this)
+    }
+
+    if (app.isWorker) {
+      app.addService('sendErrorLog', this.sendErrorLog.bind(this))
+    } else {
+      app.setMsgEvent('errorlog', this.mlog.bind(this))
+    }
+  }
+
+  async initLogStream() {
+    if (this.flog) return;
+    if (!(cluster.isPrimary || this.selfLog)) return;
+
+    try {
+      this.flog = fs.createWriteStream(this.logfile, {flags: 'a+', mode: 0o644})
+
+      this.flog.on('close', () => {
+        this.flog = null
+      })
+
+      this.flog.on('error', () => {
+        this.flog = null
+      })
+    } catch (err) {
+      this.debug && console.error(err)
+    }
+  }
+
+  clearHistory() {
+    if (this.historyList.length < this.maxHistory) return;
+
+    let i = 0
+    let total = 5
+    let hfile
+
+    while (i < total) {
+      hfile = this.historyList.shift()
+      if (!hfile) return;
+      fs.unlink(hfile, err => {})
+      i += 1
+    }
+  }
+
+  async _checkLines() {
+    if (!this.flog) return;
+    if (this.count < this.maxLines) return;
+
+    try {
+      let old_log = `${this.dir}/${this.prefix}${fmtTime()}.log`
+
+      await fsp.rename(this.logfile, old_log)
+
+      this.historyList.push(old_log)
+    } catch (err) {
+      this.debug && console.error(err)
+    } finally {
+      this.flog && !this.flog.destroyed && this.flog.destroy()
+      this.flog = null
+      this.count = 0
+      this.initLogStream()
+    }
+  }
+
+  async checkLog() {
+    if (this.checkLock) return;
+
+    this.checkLock = true
+    
+    await this._checkLines()
+    this.clearHistory()
+
+    this.checkLock = false
+  }
+
+  fmtLog(msg) {
+    let {error={}, errname='-'} = msg
+
+    return `! ${errname} | ${error.code || '-'} | ${error.name} | `
+          + `${error.message} | ${fmtTime()} | ${error.extrainfo || '-'}\n`
+          + `${error.stack || ''}\n`
+  }
+  
+  //mlog is master log
+  async mlog(worker, msg, handle=null) {
+    try {
+      let logtext = this.fmtLog(msg)
+
+      if (!this.flog) this.initLogStream()
+
+      this.flog && this.flog.write(logtext) && (this.count += 1);
+
+      this.checkLog()
+    } catch (err) {
+      this.debug && console.error(err)
+    }
+  }
+
+  sendErrorLog(e, errname='--ERR-ERROR--') {
+    if (e.code === 'EPIPE') {
+      return false
+    }
+
+    this.stdioOutput && console.error(errname, e)
+
+    let errmsg = {
+      type: 'errorlog',
+      error: {
+        code: e.code || '',
+        name: e.constructor.name,
+        message: e.message,
+        stack: e.stack || '',
+        extrainfo: e.extrainfo || ''
+      },
+      errname
+    }
+
+    if (!process.send || this.selfLog) {
+      return this.mlog(null, errmsg)
+    }
+  
+    process.send(errmsg)
+  }
+
+}
+
+module.exports = ErrorLog

package/src/extends/http2limit.js

@@ -0,0 +1,126 @@
+'use strict'
+
+/**
+ *
+ * 基于IP的限制，titbit已经能够处理。
+ *
+ * 此限流针对的是因为http/2协议设计上特点导致单个连接请求密集。
+ *
+ * 当请求密集时，关闭连接即可，若频繁发起连接请求，此时titbit层面的IP连接限制自会处理。
+ *
+ * 连接但不请求，空闲自然会有超时处理。
+ *
+ * 所以需要限制的场景：
+ *    - 时间段内的密集请求。
+ *    - 在空闲超时限制内，不频繁的请求，一直持有连接。
+ *
+ * 设定一个session生命期，超过则关闭连接。
+ *
+ **/
+
+class StreamLimit {
+
+  constructor(options = {}) {
+    this.cache = new Map()
+  
+    if (typeof options !== 'object') {
+      options = {}
+    }
+
+    this.timeSlice = 1000
+
+    //单位时间内的最大请求次数。
+    this.maxRequest = 50
+
+    this.socketLife = 3600000
+
+    for (let k in options) {
+        switch (k) {
+          case 'timeSlice':
+          case 'maxRequest':
+          case 'socketLife':
+            if (typeof options[k] === 'number') {
+              this[k] = options[k]
+            }
+            break
+        }
+    }
+
+  }
+
+  _sid(sess) {
+    return `${sess.socket.remoteAddress} ${sess.socket.remotePort}`
+  }
+
+  set(id) {
+    let s = this.cache.get(id);
+
+    if (!s) {
+      let d = {
+        time: Date.now(),
+        count: 1
+      }
+
+      d.startTime = d.time
+
+      this.cache.set(id, d)
+      return d
+    }
+
+    s.count += 1
+    
+    return s
+  }
+
+  remove(id) {
+    return this.cache.delete(id)
+  }
+
+  checkAndSet(id) {
+    let s = this.set(id)
+ 
+    if (s.count <= 1) return true
+    
+    let tm = Date.now()
+    
+    if (this.socketLife > 0 && (s.startTime + this.socketLife) < tm) {
+      return null
+    }
+
+    if ( (s.time + this.timeSlice) > tm ) {
+      if (this.maxRequest > 0 && s.count > this.maxRequest) {
+        return false
+      }
+    } else {
+      s.count = 1
+      s.time = tm
+    }
+
+    return true
+  }
+
+  init(app) {
+    app.on('session', session => {
+
+        let id = this._sid(session)
+
+        session.socket && session.socket.on('close', () => {
+            this.remove(id)
+        })
+
+        session.on('stream', stm => {
+          let st = this.checkAndSet(id)
+          if (st === null) {
+            session.close(() => {
+              !session.destroyed && session.destroy()
+            })
+          } else if (!st) {
+            session.destroy()
+          }
+        })
+    })
+  }
+
+}
+
+module.exports = StreamLimit