npm - topbit - Versions diffs - 1.0.0 → 3.0.0 - Mend

topbit 1.0.0 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (89) hide show

package/LICENSE +128 -0
package/README.cn.md +1519 -0
package/README.md +1483 -0
package/bin/app.js +17 -0
package/bin/loadinfo.sh +18 -0
package/bin/new-ctl.js +234 -0
package/bin/newapp.js +22 -0
package/demo/allow.js +98 -0
package/demo/cert/localhost-cert.pem +19 -0
package/demo/cert/localhost-privkey.pem +28 -0
package/demo/controller/api.js +15 -0
package/demo/extends.js +5 -0
package/demo/group-api.js +161 -0
package/demo/group-api2.js +109 -0
package/demo/http2.js +34 -0
package/demo/http2_proxy_backend.js +45 -0
package/demo/http2proxy.js +48 -0
package/demo/http_proxy_backend.js +44 -0
package/demo/httpproxy.js +47 -0
package/demo/loader.js +27 -0
package/demo/log.js +118 -0
package/demo/memlimit.js +31 -0
package/demo/min.js +7 -0
package/demo/serv.js +15 -0
package/images/middleware.jpg +0 -0
package/images/topbit-middleware.png +0 -0
package/images/topbit.png +0 -0
package/package.json +42 -11
package/src/_loadExtends.js +21 -0
package/src/bodyparser.js +420 -0
package/src/connfilter.js +125 -0
package/src/context1.js +166 -0
package/src/context2.js +182 -0
package/src/ctxpool.js +39 -0
package/src/ext.js +318 -0
package/src/extends/Http2Pool.js +365 -0
package/src/extends/__randstring.js +24 -0
package/src/extends/cookie.js +44 -0
package/src/extends/cors.js +334 -0
package/src/extends/errorlog.js +252 -0
package/src/extends/http2limit.js +126 -0
package/src/extends/http2proxy.js +691 -0
package/src/extends/jwt.js +217 -0
package/src/extends/mixlogger.js +63 -0
package/src/extends/paramcheck.js +266 -0
package/src/extends/proxy.js +662 -0
package/src/extends/realip.js +34 -0
package/src/extends/referer.js +68 -0
package/src/extends/resource.js +398 -0
package/src/extends/session.js +174 -0
package/src/extends/setfinal.js +50 -0
package/src/extends/sni.js +48 -0
package/src/extends/sse.js +293 -0
package/src/extends/timing.js +111 -0
package/src/extends/tofile.js +123 -0
package/src/fastParseUrl.js +426 -0
package/src/headerLimit.js +18 -0
package/src/http1.js +336 -0
package/src/http2.js +337 -0
package/src/httpc.js +251 -0
package/src/lib/npargv.js +354 -0
package/src/lib/zipdata.js +45 -0
package/src/loader/loader.js +999 -0
package/src/logger.js +32 -0
package/src/loggermsg.js +349 -0
package/src/makeId.js +200 -0
package/src/midcore.js +213 -0
package/src/middleware1.js +103 -0
package/src/middleware2.js +116 -0
package/src/monitor.js +380 -0
package/src/movefile.js +30 -0
package/src/optionsCheck.js +54 -0
package/src/randstring.js +23 -0
package/src/router.js +682 -0
package/src/sendmsg.js +27 -0
package/src/strong.js +72 -0
package/src/token/token.js +461 -0
package/src/topbit.js +1293 -0
package/src/versionCheck.js +31 -0
package/test/test-bigctx.js +29 -0
package/test/test-daemon-args.js +7 -0
package/test/test-ext.js +81 -0
package/test/test-find.js +69 -0
package/test/test-route-sort.js +71 -0
package/test/test-route.js +49 -0
package/test/test-route2.js +51 -0
package/test/test-run-args.js +7 -0
package/test/test-url.js +52 -0
package/main.js +0 -0

package/src/extends/proxy.js ADDED Viewed

@@ -0,0 +1,662 @@
+'use strict';
+const urlparse = require('node:url');
+const http = require('node:http');
+const https = require('node:https');
+/**
+ * {
+ *    host : {}
+ * }
+ * {
+ *    host : ''
+ * }
+ *
+ * {
+ *    host : [
+ *      {}
+ *    ]
+ * }
+ *
+ */
+class Proxy {
+  constructor(options = {}) {
+    this.methods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'HEAD', 'PATCH', 'TRACE']
+    this.hostProxy = {}
+    this.proxyBalance = {}
+    this.pathTable = {}
+    this.config = {}
+    this.urlpreg = /(unix|http|https):\/\/[a-zA-Z0-9\-\_]+/
+    this.maxBody = 50000000
+    //是否启用全代理模式。
+    this.full = false
+    this.timeout = 15000
+    this.addIP = false
+    this.debug = false
+    this.autoClearListeners = false
+    //记录定时器
+    this.proxyIntervals = {}
+    this.connectOptions = {
+      family: 4
+    }
+    this.error = {
+      '502' : `<!DOCTYPE html><html>
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Error 502</title>
+          </head>
+          <body>
+            <div style="width:100%;font-size:105%;color:#737373;padding:0.8rem;">
+              <h2>502 Bad Gateway</h2><br>
+              <p>代理请求不可达。</p>
+            </div>
+          </body>
+      </html>`,
+      '503' :`<!DOCTYPE html><html>
+          <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Error 503</title>
+          </head>
+          <body>
+            <div style="width:100%;font-size:105%;color:#737373;padding:0.8rem;">
+              <h2>503 Service Unavailable</h2><br>
+              <p>此服务暂时不可用。</p>
+            </div>
+          </body>
+      </html>`
+    }
+    if (typeof options !== 'object') {
+      options = {}
+    }
+    for (let k in options) {
+      switch (k) {
+        case 'host':
+        case 'config':
+          this.config = options[k]
+          break
+        case 'methods':
+          Array.isArray(options[k]) && (this.methods = options[k]);
+          break
+        case 'maxBody':
+          if (typeof options[k] == 'number' && parseInt(options[k]) >= 0) {
+            this.maxBody = parseInt(options[k])
+          }
+          break
+        case 'full':
+        case 'debug':
+        case 'autoClearListeners':
+          this[k] = !!options[k]
+          break
+        case 'timeout':
+          if (typeof options[k] === 'number' && options[k] >= 0) {
+            this.timeout = options[k]
+          }
+          break
+        case 'addIP':
+          this.addIP = options[k]
+          break
+        case 'connectOptions':
+          if (options[k] && typeof options[k] === 'object') {
+            for (let o in options[k]) this.connectOptions[o] = options[k][o]
+          }
+          break
+        default:;
+      }
+    }
+    this.setHostProxy(this.config)
+  }
+  fmtpath(path) {
+    path = path.trim()
+    if (path.length == 0) {
+      return '/*'
+    }
+    if (path[0] !== '/') {
+      path = `/${path}`
+    }
+    if (path.length > 1 && path[path.length - 1] !== '/') {
+      path = `${path}/`
+    }
+    if (path.indexOf('/:') >= 0) {
+      return path.substring(0, path.length-1)
+    }
+    return `${path}*`
+  }
+  setHostProxy(cfg) {
+    if (typeof cfg !== 'object') {
+      return
+    }
+    let pt = ''
+    let tmp = ''
+    let backend_obj = null
+    for (let k in cfg) {
+      if (typeof cfg[k] === 'string') {
+        cfg[k] = [ { path : '/', url : cfg[k] } ]
+      } else if (!(cfg[k] instanceof Array) && typeof cfg[k] === 'object') {
+        cfg[k] = [ cfg[k] ]
+      } else if ( !(cfg[k] instanceof Array) ) {
+        continue
+      }
+      /**
+       * {
+       *    path : '',
+       *    url : '',
+       *    aliveCheckPath : '',
+       *    headers : {}
+       * }
+       */
+        for (let i = 0; i < cfg[k].length; i++) {
+          tmp = cfg[k][i]
+          if (typeof tmp !== 'object' || (tmp instanceof Array) ) {
+            console.error(`${k} ${JSON.stringify(tmp)} 错误的配置格式`)
+            continue
+          }
+          if (tmp.path === undefined) {
+            tmp.path = '/'
+          }
+          if (tmp.url === undefined) {
+            console.error(`${k} ${tmp.path}：没有指定要代理转发的url。`)
+            continue
+          }
+          if (this.urlpreg.test(tmp.url) === false) {
+            console.error(`${tmp.url} : 错误的url，请检查。`)
+            continue
+          }
+          pt = this.fmtpath(tmp.path)
+          if (tmp.url[ tmp.url.length - 1 ] == '/') {
+            tmp.url = tmp.url.substring(0, tmp.url.length - 1)
+          }
+          if (tmp.headers !== undefined) {
+            if (typeof tmp.headers !== 'object') {
+              console.error(
+                `${k} ${tmp.url} ${tmp.path}：headers属性要求是object类型，使用key-value形式提供。`
+              );
+              continue
+            }
+          }
+          if (this.hostProxy[k] === undefined) {
+            this.hostProxy[k] = {}
+            this.proxyBalance[k] = {}
+          }
+          tmp.urlobj = this.parseUrl(tmp.url)
+          tmp.urlobj.timeout = tmp.timeout || this.timeout
+          backend_obj = {
+            url : tmp.url,
+            urlobj : tmp.urlobj,
+            headers : {},
+            path : tmp.path,
+            weight: 1,
+            weightCount : 0,
+            alive : true,
+            aliveCheckInterval : 5,
+            aliveCheckPath : '/',
+            intervalCount : 0,
+            rewrite: (tmp.rewrite && typeof tmp.rewrite === 'function') ? tmp.rewrite : null,
+            connectOptions: {...this.connectOptions}
+          }
+          if (tmp.connectOptions && typeof tmp.connectOptions) {
+            for (let o in tmp.connectOptions) {
+              backend_obj.connectOptions[o] = tmp.connectOptions[o]
+            }
+          }
+          if (tmp.headers !== undefined) {
+            for (let h in tmp.headers) {
+              backend_obj.headers[h] = tmp.headers[h]
+            }
+          }
+          if (typeof tmp.aliveCheckPath === 'string' && tmp.aliveCheckPath.length > 0) {
+            if (tmp.aliveCheckPath[0] !== '/') {
+              tmp.aliveCheckPath = `/${tmp.aliveCheckPath}`
+            }
+            backend_obj.aliveCheckPath = tmp.aliveCheckPath
+          }
+          if (tmp.weight && typeof tmp.weight === 'number' && tmp.weight > 1) {
+            backend_obj.weight = parseInt(tmp.weight)
+          }
+          if (tmp.aliveCheckInterval !== undefined && typeof tmp.aliveCheckInterval === 'number') {
+            if (tmp.aliveCheckInterval >= 0 && tmp.aliveCheckInterval <= 7200) {
+              backend_obj.aliveCheckInterval = tmp.aliveCheckInterval
+            }
+          }
+          if (this.hostProxy[k][pt] === undefined) {
+            this.hostProxy[k][pt] = [ backend_obj ]
+            this.proxyBalance[k][pt] = {
+              stepIndex : 0,
+              useWeight : false
+            }
+          } else if (this.hostProxy[k][pt] instanceof Array) {
+            this.hostProxy[k][pt].push(backend_obj)
+          }
+          if (backend_obj.weight > 1) {
+            this.proxyBalance[k][pt].useWeight = true
+          }
+          this.pathTable[pt] = 1
+        } //end sub for
+    } // end for
+  }
+  parseUrl(url) {
+    let u = new urlparse.URL(url)
+    let urlobj = {
+      hash    : u.hash,
+      hostname: u.hostname,
+      protocol: u.protocol,
+      path    : u.pathname,
+      method  : 'GET',
+      headers : {},
+    }
+    if (u.search.length > 0) {
+      urlobj.path += u.search
+    }
+    if (u.protocol  === 'unix:') {
+      urlobj.protocol = 'http:'
+      let sockarr = u.pathname.split('.sock')
+      urlobj.socketPath = `${sockarr[0]}.sock`
+      urlobj.path = sockarr[1]
+    } else {
+      urlobj.host = u.host
+      urlobj.port = u.port
+    }
+    if (u.protocol === 'https:') {
+      urlobj.requestCert = false
+      urlobj.rejectUnauthorized = false
+    }
+    return urlobj
+  }
+  copyUrlobj(uobj) {
+    let u = {
+      hash: uobj.hash,
+      hostname: uobj.hostname,
+      protocol: uobj.protocol,
+      path: uobj.path,
+      method: 'GET',
+      headers: {},
+      timeout: uobj.timeout
+    }
+    if (uobj.host) {
+      u.host = uobj.host
+      u.port = uobj.port
+    } else {
+      u.socketPath = uobj.socketPath
+    }
+    if (uobj.protocol === 'https:') {
+      u.requestCert = false
+      u.rejectUnauthorized = false
+    }
+    return u
+  }
+  getBackend(c, host) {
+    let prlist = this.hostProxy[host][c.routepath]
+    let pb = this.proxyBalance[host][c.routepath]
+    let pr
+    if (prlist.length === 1) {
+      pr = prlist[0]
+    } else {
+      if (pb.stepIndex >= prlist.length) {
+        pb.stepIndex = 0
+      }
+      pr = prlist[pb.stepIndex]
+      if (pb.useWeight) {
+        if (pr.weightCount >= pr.weight) {
+          pr.weightCount = 0
+          pb.stepIndex++
+        } else {
+          pr.weightCount++
+        }
+      } else {
+        pb.stepIndex++
+      }
+    }
+    if (pr.alive === false) {
+      for (let i = 0; i < prlist.length; i++) {
+        pr = prlist[i]
+        if (pr.alive === true) {
+          return pr
+        }
+      }
+      return null
+    }
+    return pr
+  }
+  mid() {
+    let self = this
+    let timeoutError = new Error('request timeout')
+    timeoutError.code = 'ETIMEOUT'
+    return async (c, next) => {
+      let host = c.host
+      let hind = c.host.length - 1
+      if (hind > 4) {
+        let eind = hind - 5
+        while (hind >= eind) {
+          if (c.host[hind] === ':') {
+            host = c.host.substring(0, hind)
+            break
+          }
+          hind--
+        }
+      }
+      if (self.hostProxy[host]===undefined || self.hostProxy[host][c.routepath]===undefined) {
+        if (self.full) {
+          return c.status(502).to(self.error['502'])
+        }
+        return await next(c)
+      }
+      let pr = self.getBackend(c, host)
+      if (pr === null) {
+        for (let i = 0; i < 200; i++) {
+          await new Promise((rv, rj) => {setTimeout(rv, 10)})
+          pr = self.getBackend(c, host)
+          if (pr) break
+        }
+        if (!pr)
+          return c.status(503).to(self.error['503'])
+      }
+      let urlobj = self.copyUrlobj(pr.urlobj)
+      urlobj.path = c.req.url
+      urlobj.headers = c.headers
+      urlobj.method = c.method
+      if (self.addIP && urlobj.headers['x-real-ip']) {
+        urlobj.headers['x-real-ip'] += `,${c.ip}`
+      } else {
+        urlobj.headers['x-real-ip'] = c.ip
+      }
+      let hci = urlobj.protocol == 'https:' ? https : http
+      for (let k in pr.connectOptions) {
+        urlobj[k] = pr.connectOptions[k]
+      }
+      if (pr.rewrite) {
+        let rw = pr.rewrite(c, c.req.url)
+        if (rw) {
+          let path_typ = typeof rw
+          if (path_typ === 'string') {
+            urlobj.path = rw
+          } else if (path_typ === 'object' && rw.redirect) {
+            return c.setHeader('location', rw.redirect)
+          }
+        }
+      }
+      let h = hci.request(urlobj)
+      return await new Promise((rv, rj) => {
+        let resolved = false
+        let rejected = false
+        c.req.on('timeout', () => {
+          !h.destroyed && h.destroy(timeoutError)
+        })
+        c.res.on('timeout', () => {
+          !h.destroyed && h.destroy(timeoutError)
+        })
+        h.on('timeout', () => {
+          !h.destroyed && h.destroy(timeoutError)
+        })
+        h.on('close', () => {
+          if (!resolved && !rejected) {
+            resolved = true
+            rv()
+          }
+        })
+        h.on('response', res => {
+          c.status(res.statusCode)
+          for (let k in res.headers) {
+            c.setHeader(k, res.headers[k])
+          }
+          res.on('data', chunk => {
+            c.res.write(chunk)
+          })
+          res.on('end', () => {
+            c.res.end()
+            if (!resolved && !rejected) {
+              resolved = true
+              rv()
+            }
+          })
+            res.on('error', err => {
+                if (!resolved && !rejected){
+                  rejected = true
+                  rj(err)
+                }
+            })
+        })
+        h.on('error', (err) => {
+          if (!resolved && !rejected) {
+            rejected = true
+            rj(err)
+          }
+        })
+        c.req.on('data', chunk => {
+          h.write(chunk)
+        })
+        c.req.on('end', () => {
+          h.end()
+        })
+      }).catch(err => {
+        self.debug && console.error(err);
+        c.status(503).to(self.error['503']);
+      })
+      .finally(() => {
+        this.autoClearListeners && h.removeAllListeners && h.removeAllListeners();
+        !h.destroyed && h.destroy();
+      })
+    }
+  }
+  timerRequest(pxy, timeout=false) {
+    let h = http
+    let opts = {
+      timeout : this.timeout + 30_000,
+      method: 'TRACE',
+      headers: {
+        'user-agent': 'Node.js/Topbit,Topbit-Toolkit: Proxy,AliveCheck'
+      }
+    }
+    if (pxy.urlobj.protocol === 'https:') {
+      h = https
+      opts.rejectUnauthorized = false
+      opts.requestCert = false
+    }
+    for (let o in pxy.connectOptions) {
+      opts[o] = pxy.connectOptions[o]
+    }
+    let aliveUrl = `${pxy.urlobj.protocol}//${pxy.urlobj.host}${pxy.aliveCheckPath}`
+    let req = h.request(aliveUrl, opts)
+    req.on('error', err => {
+      pxy.alive = false
+      //当出现连接错误，立即发起一个请求，测试是否是某些特殊情况导致的异常，比如服务重启导致瞬间请求失败。
+      if (!timeout) {
+        setTimeout(() => {
+          this.timerRequest(pxy, true)
+        }, 500)
+      }
+    })
+    req.on('response', res => {
+      pxy.alive = true
+      res.on('error', err => {
+      })
+      res.on('data', chunk => {
+        pxy.alive = true
+      })
+      res.on('end', () => {
+        pxy.alive = true
+      })
+    })
+    req.end()
+  }
+  setTimer(pxys) {
+    let count = 0
+    for (let p of pxys) {
+      if (p.aliveCheckInterval > 0) count++
+    }
+    if (count === 0) return null
+    let self = this
+    return setInterval(() => {
+      for (let i = 0; i < pxys.length; i++) {
+        if (pxys[i].aliveCheckInterval <= 0) continue
+        pxys[i].intervalCount++
+        if (pxys[i].intervalCount >= pxys[i].aliveCheckInterval) {
+          pxys[i].intervalCount = 0
+          self.timerRequest(pxys[i])
+        }
+      }
+    }, 1000)
+  }
+  init(app) {
+    app.config.timeout = this.timeout
+    for (let p in this.pathTable) {
+      app.router.map(this.methods, p, async c => {}, '@titbit_proxy')
+    }
+    app.use(this.mid(), {pre: true, group: `titbit_proxy`})
+    for (let k in this.hostProxy) {
+      this.proxyIntervals[k] = {}
+      for (let p in this.hostProxy[k]) {
+        this.proxyIntervals[k][p] = this.setTimer(this.hostProxy[k][p])
+      }
+    }
+  }
+}
+module.exports = Proxy

package/src/extends/realip.js ADDED Viewed

@@ -0,0 +1,34 @@
+'use strict'
+class RealIP {
+  constructor() {
+  }
+  mid() {
+    return async (c, next) => {
+      let realipstr = c.headers['x-real-ip'] || c.headers['x-forwarded-for'] || ''
+      if (realipstr !== '') {
+        if (realipstr.indexOf(',') > 0) {
+          c.box.realip = realipstr.split(',').filter(p => p.length > 0)
+          if (c.box.realip.length > 0) {
+            c.ip = c.box.realip[0].trim()
+          }
+        } else {
+          c.ip = realipstr
+        }
+      }
+      await next(c)
+    }
+  }
+}
+module.exports = RealIP