topbit 3.1.0 → 3.1.2

package/README.cn.md

@@ -1921,7 +1921,7 @@ let hxy = new Http2Proxy({
         weight: 10,
         path : '/',
         reconnDelay: 200, // 重连延迟
-        max: 2,
+        maxConnect: 2,
         headers: {
           'x-test-key': `${Date.now()}`
         },

package/README.md

@@ -1882,7 +1882,7 @@ let hxy = new Http2Proxy({
         weight: 10,
         path : '/',
         reconnDelay: 200, // Reconnection delay
-        max: 2,
+        maxConnect: 2,
         headers: {
           'x-test-key': `${Date.now()}`
         },

package/demo/group-api.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const titbit = require('../lib/titbit.js')
+const titbit = require('../src/topbit.js')
 
 const app = new titbit({
   debug: true,

package/demo/group-api2.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const Titbit = require('../lib/titbit.js')
+const Titbit = require('../src/topbit.js')
 
 let app = new Titbit({
   debug: true,

package/demo/monitor.js

@@ -12,11 +12,14 @@ let {args} = npargv({
   '--loadstdio': {
     name: 'loadstdio',
     default: false
+  },
+
+  '--http2': {
+    name: 'http2',
+    default: false
   }
 })
 
-console.log(args)
-
 const app = new Topbit({
     debug : true,
     allow : new Set(['127.0.0.1']),
@@ -24,7 +27,7 @@ const app = new Topbit({
     unitTime: 10,
     useLimit: true,
     maxConn: 2000,
-    //http2: true,
+    http2: args.http2,
     loadMonitor: true,
     loadInfoType : args.loadtype,
     globalLog : false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "topbit",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "A Server-side web framework support http/1.1 and http/2",
   "main": "src/topbit.js",
   "directories": {

package/src/extends/Http2Pool.js

@@ -6,360 +6,194 @@ const crypto = require('node:crypto')
 class Http2Pool {
   
   constructor(options = {}) {
-    // 存储session的Map
     if (!options || typeof options !== 'object') options = {}
-    if (!options.connectOptions) options.connectOptions = {}
-
-    this.pool = new Map()
     
-    this.innerConnectDelay = 0
-    this.failedCount = 0
-    this.reconnecting = false
-    // 配置项
-    this.maxStreamId = !isNaN(options.maxStreamId) && options.maxStreamId > 1
-                        ? options.maxStreamId
-                        : 90000
-
-    this.timeout = options.timeout || 30000
-    this.connectTimeout = options.connectTimeout || 15000
-
-    this.max = (options.max && !isNaN(options.max) && options.max > 0) ? options.max : 50
-    this.poolMax = Math.floor(this.max * 1.5 + 0.5)
-    this.maxConnect = (options.maxConnect && !isNaN(options.maxConnect) && options.maxConnect > 0)
-                      ? options.maxConnect
-                      : this.poolMax + 500
-
-    this.url = options.url || ''
-    this.debug = options.debug || false
-    // 连接选项
+    // 配置初始化
+    this.maxConnect = options.maxConnect || 100 // 最大物理连接数
+    this.maxAliveStreams = options.maxAliveStreams || 100 // 单连接最大并发流
+    this.url = options.url
+    this.debug = !!options.debug
+    this.reconnDelay = options.reconnDelay || 500
+    
+    // 核心数据结构
+    this.sessions = [] // 使用数组代替Map，利用索引做 Round-Robin
+    this.cursor = 0    // 轮询指针
+    
     this.connectOptions = {
       rejectUnauthorized: false,
-      requestCert: false,
-      peerMaxConcurrentStreams: 100,
-      timeout: this.timeout,
+      timeout: options.timeout || 30000,
       ...options.connectOptions
     }
+    
+    this.waitQueue = [] // 等待可用连接的队列
+  }
 
-    this.reconnDelay = 100
-    if (options.reconnDelay !== undefined && !isNaN(options.reconnDelay)) {
-      this.reconnDelay = options.reconnDelay
-    }
-
-    this.parent = null
-
-    if (options.parent && typeof options.parent === 'object') {
-      this.parent = options.parent
+  /**
+   * 初始化连接池 (预热)
+   */
+  createPool(initialSize = 5) {
+    for (let i = 0; i < initialSize; i++) {
+      this._createConnection()
     }
-
-    this.maxAliveStreams = options.maxAliveStreams || 100
-
-    this.quiet = false
-    if (options.quiet)
-      this.quiet = !!options.quiet
   }
 
   /**
-   * 创建新的session连接
+   * 内部建立连接
    */
-  async connect() {
-    if (this.pool.size > this.maxConnect) {
-      return {
-        deny: true,
-        error: `超出最大连接限制：${this.maxConnect}`
-      }
-    }
+  _createConnection() {
+    if (this.sessions.length >= this.maxConnect) return null
 
     const session = http2.connect(this.url, this.connectOptions)
-
-    // 生成唯一session id
-    const sessionId = crypto.randomBytes(16).toString('hex')
     
-    // 初始化session相关计数器和状态
-    const sessionState = {
-      using: false,
-      id: sessionId,
-      session,
-      streamCount: 0,
-      url: this.url,
+    const wrapper = {
+      id: crypto.randomBytes(8).toString('hex'),
+      session: session,
       connected: false,
-      error: null,
-      aliveStreams: 0
+      aliveStreams: 0, // 当前并发数
+      weight: 1        // 预留权重字段
     }
 
-    // 处理session事件
-    this._handleSessionEvents(sessionState)
-
-    // 等待连接建立
-    try {
-      let timeout_timer = null
-      let resolved = false
-      let rejected = false
-
-      await new Promise((resolve, reject) => {
-          session.once('connect', () => {
-            if (timeout_timer) {
-              clearTimeout(timeout_timer)
-              timeout_timer = null
-            }
-
-            if (this.failedCount > 0) {
-              this.failedCount--
-            }
-
-            this.innerConnectDelay = 0
-
-            sessionState.connected = true
-            this.parent && !this.parent.alive && (this.parent.alive = true)
-
-            resolve()
-          })
-
-          session.once('error', err => {
-            if (timeout_timer) {
-              clearTimeout(timeout_timer)
-              timeout_timer = null
-            }
-
-            if (this.pool.size < 1) {
-              this.parent && (this.parent.alive = false)
-            }
-
-            this.failedCount++
-
-            if (this.failedCount < 10) {
-              this.innerConnectDelay = this.failedCount
-            } if (this.failedCount < 60000) {
-              this.innerConnectDelay = Math.floor(this.failedCount / 10)
-            } else { this.innerConnectDelay = 6000 }
-
-            !rejected && (rejected = true) && reject(err)
-          })
-
-          session.once('goaway', err => {
-            if (timeout_timer) {
-              clearTimeout(timeout_timer)
-              timeout_timer = null
-            }
-
-            !rejected && (rejected = true) && reject(err||new Error('goaway'))
-          })
-
-          session.once('frameError', err => {
-            if (timeout_timer) {
-              clearTimeout(timeout_timer)
-              timeout_timer = null
-            }
-            !rejected && (rejected = true) && reject(err)
-          })
-          
-          if (!timeout_timer) {
-            timeout_timer = setTimeout(() => {
-              timeout_timer = null
-              !session.destroyed && session.destroy()
-              !rejected && (rejected = true) && reject(new Error('connect timeout'))
-            }, this.connectTimeout)
-          }
-      })
-    } catch (err) {
-      sessionState.error = err
-      sessionState.session = null
-      this.debug && console.error(err)
-    } finally {
-      this.reconnecting = false
-    }
-
-    if (this.pool.size < this.poolMax && sessionState.connected) {
-      this.pool.set(sessionId, sessionState)
-    }
-
-    return sessionState
-  }
-
-  createPool(max=0) {
-    if (max <= 0) max = this.max
-
-    for (let i = 0; i < max; i++) {
-      this.connect()
-    }
-  }
-
-  delayConnect() {
-    if (this.reconnecting) return false
-
-    let delay_time = this.reconnDelay + this.innerConnectDelay
-
-    if (delay_time > 0) {
-      if (!this.delayTimer) {
-        this.reconnecting = true
-        this.delayTimer = setTimeout(() => {
-          this.delayTimer = null
-          this.connect()
-        }, delay_time)
-      }
-    } else {
-      this.reconnecting = true
-      this.connect()
-    }
-  }
-
-  /**
-   * 处理session的各种事件
-   */
-  _handleSessionEvents(sessionState) {
-    const { session, id } = sessionState
-
-    session.on('close', () => {
-      // session关闭时从pool中移除
-      this.pool.delete(id)
-
-      if (this.pool.size < 1) {
-        this.delayConnect()
+    session.once('connect', () => {
+      wrapper.connected = true
+      // 触发队列中的等待者
+      while (this.waitQueue.length > 0 && wrapper.aliveStreams < this.maxAliveStreams) {
+        const resolve = this.waitQueue.shift()
+        resolve(wrapper)
       }
     })
 
-    session.on('error', err => {
-      this.debug && console.error(err)
-      !session.destroyed && session.destroy()
-      this.pool.delete(id)
-    })
+    // 错误处理与清理
+    const cleanup = () => {
+        if (wrapper._destroyed) return
+        wrapper._destroyed = true
+        
+        // 从池中移除
+        const idx = this.sessions.indexOf(wrapper)
+        if (idx !== -1) {
+            this.sessions.splice(idx, 1)
+            // 修正指针，防止跳过
+            if (this.cursor >= idx && this.cursor > 0) this.cursor-- 
+        }
 
-    session.on('frameError', err => {
-      !session.destroyed && session.destroy()
-      this.pool.delete(id)
-    })
+        if (!session.destroyed) session.destroy()
+        
+        // 自动补充连接 (维持最小连接数，可选)
+        if (this.sessions.length < 2) {
+             // 防止雪崩，延迟重连
+             setTimeout(() => this._createConnection(), this.reconnDelay)
+        }
+    }
 
-    session.on('goaway', err => {
-      this.debug && err && console.error('..........goaway........', err)
-      !session.destroyed && session.close()
-      this.pool.delete(id)
+    session.on('close', cleanup)
+    session.on('error', (err) => {
+        if(this.debug) console.error(`[H2Pool] Session Error ${this.url}:`, err.message)
+        cleanup()
     })
-
-    session.setTimeout(this.timeout, () => {
-      this.debug && console.error('session.....time.....out......')
-      if (!session.destroyed) {
-        session.destroy()
-      }
-
-      this.pool.delete(id)
+    session.on('goaway', cleanup)
+    
+    // 超时保活策略：只有完全空闲才销毁，否则发送 ping
+    session.setTimeout(this.connectOptions.timeout, () => {
+        if (wrapper.aliveStreams > 0) {
+            // 还有流量，不销毁，尝试 ping 保持活跃
+            session.ping && session.ping(() => {}) 
+        } else {
+            session.close() // 优雅关闭
+        }
     })
-  }
 
-  isSessionHealthy(session) {
-    return session
-            && !session.destroyed
-            && !session.closed
-            && session.socket
-            && !session.socket.destroyed
+    this.sessions.push(wrapper)
+    return wrapper
   }
 
   /**
-   * 获取可用的session,如果没有则创建新的
+   * 获取最佳可用 Session (Round-Robin)
    */
   async getSession() {
-    if (this.pool.size > 0) {
-        let items = this.pool.entries()
-        for (const [id, state] of items) {
-          if (state.connected
-              && state.streamCount < this.maxStreamId
-              && this.isSessionHealthy(state.session))
-          {
-            if (state.aliveStreams < this.maxAliveStreams) {
-              return state
-            }
-          } else {
-            state.connected = false
-            if (!state.session.destroyed) {
-              state.session.close()
+    let tried = 0
+    const len = this.sessions.length
 
-              if (state.aliveStreams < 1) {
-                state.session.destroy()
-              }
-              /*  else {
-                let sess = state.session
-                setTimeout(() => {
-                  !sess.destroyed && sess.destroy()
-                  sess = null
-                }, this.timeout + 5000)
-              } */
-            }
+    // 1. 尝试轮询获取可用连接
+    while (tried < len) {
+        this.cursor = (this.cursor + 1) % len
+        const wrapper = this.sessions[this.cursor]
 
-            this.pool.delete(state.id)
-          }
+        if (wrapper && wrapper.connected && !wrapper.session.destroyed && wrapper.aliveStreams < this.maxAliveStreams) {
+            return wrapper
+        }
+        tried++
+    }
+
+    // 2. 如果没有可用连接，且未达上限，创建新连接
+    if (this.sessions.length < this.maxConnect) {
+        const newWrapper = this._createConnection()
+        if (newWrapper) {
+            // 等待连接建立 (设置一个短超时)
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                     reject(new Error('Connection timeout'))
+                }, 5000)
+                
+                const onConnect = () => {
+                    clearTimeout(timer)
+                    newWrapper.session.removeListener('connect', onConnect)
+                    resolve(newWrapper)
+                }
+                newWrapper.session.once('connect', onConnect)
+                newWrapper.session.once('error', (err) => {
+                    clearTimeout(timer)
+                    reject(err)
+                })
+            })
         }
     }
 
-    return this.connect()
-  }
-
-  /**
-   * 创建新的请求stream
-   */
-  async request(headers, sessionState=null) {
-    !sessionState && (sessionState = await this.getSession())
-
-    sessionState.streamCount++
-
-    if (!sessionState.connected) {
-      if (this.quiet) return null
-      throw new Error('There is no connected')
-    }
-
-    //创建请求stream
-    return sessionState.session.request(headers)
+    // 3. 还是没有，进入队列等待 (削峰填谷)
+    return new Promise((resolve, reject) => {
+        // 3秒后还没拿到连接就报错
+        const timer = setTimeout(() => {
+            const idx = this.waitQueue.indexOf(resolve)
+            if (idx !== -1) this.waitQueue.splice(idx, 1)
+            reject(new Error('No available h2 session (Queued timeout)'))
+        }, 3000)
+
+        // 包装 resolve 以清理 timer
+        this.waitQueue.push((wrapper) => {
+            clearTimeout(timer)
+            resolve(wrapper)
+        })
+    })
   }
 
   /**
-   * 关闭所有session
+   * 发起请求 (核心入口)
    */
-  closeAll() {
-    for (const [id, state] of this.pool.entries()) {
-      if (!state.session.destroyed) {
-        state.session.close()
-      }
-    }
-
-    this.pool.clear()
-  }
+  async request(headers) {
+    const wrapper = await this.getSession()
+    wrapper.aliveStreams++
 
-  async aok() {
-    if (this.pool.size <= 0) {
-      await this.connect()
+    try {
+        const stream = wrapper.session.request(headers)
+        
+        // 监听流关闭，减少计数
+        stream.once('close', () => {
+            wrapper.aliveStreams--
+            // 如果有等待队列，唤醒一个
+            if (this.waitQueue.length > 0) {
+                const resolve = this.waitQueue.shift()
+                resolve(wrapper)
+            }
+        })
+        
+        return stream
+    } catch (e) {
+        wrapper.aliveStreams--
+        throw e
     }
-
-    return this.ok()
   }
 
   ok() {
-    let items = this.pool.entries()
-
-    for (const [id, state] of items) {
-      if (state.connected) return true
-    }
-
-    return false
-  }
-
-  /**
-   * 获取当前pool状态
-   */
-  status() {
-    const status = {
-      total: this.pool.size,
-      sessions: []
-    }
-
-    let items = this.pool.entries()
-
-    for (const [id, state] of items) {
-      status.sessions.push({
-        id: state.id,
-        streamCount: state.streamCount,
-        connected: state.connected
-      })
-    }
-
-    return status
+      return this.sessions.some(s => s.connected && !s.session.destroyed)
   }
 }
 
-module.exports = Http2Pool
+module.exports = Http2Pool