@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/undici/lib/dispatcher/pool-base.js

@@ -1,9 +1,9 @@
 'use strict'
 
-const { PoolStats } = require('../util/stats.js')
 const DispatcherBase = require('./dispatcher-base')
 const FixedQueue = require('./fixed-queue')
 const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = require('../core/symbols')
+const PoolStats = require('./pool-stats')
 
 const kClients = Symbol('clients')
 const kNeedDrain = Symbol('needDrain')
@@ -13,121 +13,62 @@ const kOnDrain = Symbol('onDrain')
 const kOnConnect = Symbol('onConnect')
 const kOnDisconnect = Symbol('onDisconnect')
 const kOnConnectionError = Symbol('onConnectionError')
-const kOnClientBusy = Symbol('on client busy')
-const kOnClientDrain = Symbol('on client drain')
-const kDrainQueue = Symbol('drain queue')
 const kGetDispatcher = Symbol('get dispatcher')
-const kHasDispatcher = Symbol('has dispatcher')
 const kAddClient = Symbol('add client')
 const kRemoveClient = Symbol('remove client')
+const kStats = Symbol('stats')
 
 class PoolBase extends DispatcherBase {
-  [kQueue] = new FixedQueue();
+  constructor (opts) {
+    super(opts)
 
-  [kQueued] = 0;
+    this[kQueue] = new FixedQueue()
+    this[kClients] = []
+    this[kQueued] = 0
 
-  [kClients] = [];
+    const pool = this
 
-  [kNeedDrain] = false;
+    this[kOnDrain] = function onDrain (origin, targets) {
+      const queue = pool[kQueue]
 
-  [kOnDrain] (client, origin, targets) {
-    if (client.closed || client.destroyed) {
-      return
-    }
-
-    const queue = this[kQueue]
-    let needDrain = false
-
-    this[kOnClientDrain](client)
-
-    while (!needDrain) {
-      const item = queue.shift()
-      if (!item) {
-        break
-      }
-      this[kQueued]--
-      needDrain = !client.dispatch(item.opts, item.handler)
-    }
-
-    client[kNeedDrain] = needDrain
-    if (needDrain) {
-      this[kOnClientBusy](client)
-    }
-
-    if (!needDrain && this[kNeedDrain]) {
-      this[kNeedDrain] = false
-      this.emit('drain', origin, [this, ...targets])
-    }
+      let needDrain = false
 
-    if (this[kClosedResolve] && queue.isEmpty()) {
-      const closeAll = []
-      for (let i = 0; i < this[kClients].length; i++) {
-        const client = this[kClients][i]
-        if (!client.destroyed) {
-          closeAll.push(client.close())
+      while (!needDrain) {
+        const item = queue.shift()
+        if (!item) {
+          break
         }
+        pool[kQueued]--
+        needDrain = !this.dispatch(item.opts, item.handler)
       }
-      return Promise.all(closeAll)
-        .then(this[kClosedResolve])
-    }
-  }
-
-  [kOnClientBusy] () {}
-
-  [kOnClientDrain] () {}
 
-  [kDrainQueue] (origin, targets) {
-    const queue = this[kQueue]
-    let hasDispatcher = true
+      this[kNeedDrain] = needDrain
 
-    while (!queue.isEmpty()) {
-      const dispatcher = this[kGetDispatcher]()
-      if (!dispatcher) {
-        hasDispatcher = false
-        break
+      if (!this[kNeedDrain] && pool[kNeedDrain]) {
+        pool[kNeedDrain] = false
+        pool.emit('drain', origin, [pool, ...targets])
       }
 
-      const item = queue.shift()
-      this[kQueued]--
-
-      if (!dispatcher.dispatch(item.opts, item.handler)) {
-        dispatcher[kNeedDrain] = true
-        this[kOnClientBusy](dispatcher)
-        hasDispatcher = this[kHasDispatcher]()
-        if (!hasDispatcher) {
-          break
-        }
+      if (pool[kClosedResolve] && queue.isEmpty()) {
+        Promise
+          .all(pool[kClients].map(c => c.close()))
+          .then(pool[kClosedResolve])
       }
     }
 
-    if (hasDispatcher && this[kNeedDrain]) {
-      this[kNeedDrain] = false
-      this.emit('drain', origin, [this, ...targets])
+    this[kOnConnect] = (origin, targets) => {
+      pool.emit('connect', origin, [pool, ...targets])
     }
 
-    if (this[kClosedResolve] && queue.isEmpty()) {
-      const closeAll = []
-      for (let i = 0; i < this[kClients].length; i++) {
-        const client = this[kClients][i]
-        if (!client.destroyed) {
-          closeAll.push(client.close())
-        }
-      }
-      return Promise.all(closeAll)
-        .then(this[kClosedResolve])
+    this[kOnDisconnect] = (origin, targets, err) => {
+      pool.emit('disconnect', origin, [pool, ...targets], err)
     }
-  }
-
-  [kOnConnect] = (origin, targets) => {
-    this.emit('connect', origin, [this, ...targets])
-  };
 
-  [kOnDisconnect] = (origin, targets, err) => {
-    this.emit('disconnect', origin, [this, ...targets], err)
-  };
+    this[kOnConnectionError] = (origin, targets, err) => {
+      pool.emit('connectionError', origin, [pool, ...targets], err)
+    }
 
-  [kOnConnectionError] = (origin, targets, err) => {
-    this.emit('connectionError', origin, [this, ...targets], err)
+    this[kStats] = new PoolStats(this)
   }
 
   get [kBusy] () {
@@ -135,19 +76,11 @@ class PoolBase extends DispatcherBase {
   }
 
   get [kConnected] () {
-    let ret = 0
-    for (const { [kConnected]: connected } of this[kClients]) {
-      ret += connected
-    }
-    return ret
+    return this[kClients].filter(client => client[kConnected]).length
   }
 
   get [kFree] () {
-    let ret = 0
-    for (const { [kConnected]: connected, [kNeedDrain]: needDrain } of this[kClients]) {
-      ret += connected && !needDrain
-    }
-    return ret
+    return this[kClients].filter(client => client[kConnected] && !client[kNeedDrain]).length
   }
 
   get [kPending] () {
@@ -175,40 +108,29 @@ class PoolBase extends DispatcherBase {
   }
 
   get stats () {
-    return new PoolStats(this)
+    return this[kStats]
   }
 
-  [kClose] () {
+  async [kClose] () {
     if (this[kQueue].isEmpty()) {
-      const closeAll = []
-      for (let i = 0; i < this[kClients].length; i++) {
-        const client = this[kClients][i]
-        if (!client.destroyed) {
-          closeAll.push(client.close())
-        }
-      }
-      return Promise.all(closeAll)
+      await Promise.all(this[kClients].map(c => c.close()))
     } else {
-      return new Promise((resolve) => {
+      await new Promise((resolve) => {
         this[kClosedResolve] = resolve
       })
     }
   }
 
-  [kDestroy] (err) {
+  async [kDestroy] (err) {
     while (true) {
       const item = this[kQueue].shift()
       if (!item) {
         break
       }
-      item.handler.onResponseError(null, err)
+      item.handler.onError(err)
     }
 
-    const destroyAll = new Array(this[kClients].length)
-    for (let i = 0; i < this[kClients].length; i++) {
-      destroyAll[i] = this[kClients][i].destroy(err)
-    }
-    return Promise.all(destroyAll)
+    await Promise.all(this[kClients].map(c => c.destroy(err)))
   }
 
   [kDispatch] (opts, handler) {
@@ -220,32 +142,15 @@ class PoolBase extends DispatcherBase {
       this[kQueued]++
     } else if (!dispatcher.dispatch(opts, handler)) {
       dispatcher[kNeedDrain] = true
-      this[kOnClientBusy](dispatcher)
-      this[kNeedDrain] = !this[kHasDispatcher]()
+      this[kNeedDrain] = !this[kGetDispatcher]()
     }
 
     return !this[kNeedDrain]
   }
 
-  [kHasDispatcher] () {
-    for (let i = 0; i < this[kClients].length; i++) {
-      const dispatcher = this[kClients][i]
-
-      if (
-        !dispatcher[kNeedDrain] &&
-        dispatcher.closed !== true &&
-        dispatcher.destroyed !== true
-      ) {
-        return true
-      }
-    }
-
-    return false
-  }
-
   [kAddClient] (client) {
     client
-      .on('drain', this[kOnDrain].bind(this, client))
+      .on('drain', this[kOnDrain])
       .on('connect', this[kOnConnect])
       .on('disconnect', this[kOnDisconnect])
       .on('connectionError', this[kOnConnectionError])
@@ -254,8 +159,8 @@ class PoolBase extends DispatcherBase {
 
     if (this[kNeedDrain]) {
       queueMicrotask(() => {
-        if (this[kNeedDrain] && !client[kNeedDrain]) {
-          this[kOnDrain](client, client[kUrl], [client, this])
+        if (this[kNeedDrain]) {
+          this[kOnDrain](client[kUrl], [this, client])
         }
       })
     }
@@ -264,14 +169,14 @@ class PoolBase extends DispatcherBase {
   }
 
   [kRemoveClient] (client) {
-    const idx = this[kClients].indexOf(client)
-    if (idx !== -1) {
-      this[kClients].splice(idx, 1)
-    }
-
-    client.close(() => {})
+    client.close(() => {
+      const idx = this[kClients].indexOf(client)
+      if (idx !== -1) {
+        this[kClients].splice(idx, 1)
+      }
+    })
 
-    this[kNeedDrain] = !this[kClients].some(dispatcher => (
+    this[kNeedDrain] = this[kClients].some(dispatcher => (
       !dispatcher[kNeedDrain] &&
       dispatcher.closed !== true &&
       dispatcher.destroyed !== true
@@ -285,9 +190,5 @@ module.exports = {
   kNeedDrain,
   kAddClient,
   kRemoveClient,
-  kDrainQueue,
-  kOnClientBusy,
-  kOnClientDrain,
-  kGetDispatcher,
-  kHasDispatcher
+  kGetDispatcher
 }

package/node_modules/undici/lib/dispatcher/pool-stats.js

@@ -0,0 +1,34 @@
+const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = require('../core/symbols')
+const kPool = Symbol('pool')
+
+class PoolStats {
+  constructor (pool) {
+    this[kPool] = pool
+  }
+
+  get connected () {
+    return this[kPool][kConnected]
+  }
+
+  get free () {
+    return this[kPool][kFree]
+  }
+
+  get pending () {
+    return this[kPool][kPending]
+  }
+
+  get queued () {
+    return this[kPool][kQueued]
+  }
+
+  get running () {
+    return this[kPool][kRunning]
+  }
+
+  get size () {
+    return this[kPool][kSize]
+  }
+}
+
+module.exports = PoolStats

package/node_modules/undici/lib/dispatcher/pool.js

@@ -5,53 +5,24 @@ const {
   kClients,
   kNeedDrain,
   kAddClient,
-  kDrainQueue,
-  kOnClientBusy,
-  kOnClientDrain,
-  kGetDispatcher,
-  kHasDispatcher,
-  kRemoveClient
+  kGetDispatcher
 } = require('./pool-base')
 const Client = require('./client')
 const {
   InvalidArgumentError
 } = require('../core/errors')
 const util = require('../core/util')
-const { kConnecting, kHTTPContext, kUrl } = require('../core/symbols')
+const { kUrl, kInterceptors } = require('../core/symbols')
 const buildConnector = require('../core/connect')
 
 const kOptions = Symbol('options')
 const kConnections = Symbol('connections')
 const kFactory = Symbol('factory')
-const kProtocol = Symbol('protocol')
-const kProtocolProbe = Symbol('protocol probe')
 
 function defaultFactory (origin, opts) {
   return new Client(origin, opts)
 }
 
-function shouldCreateProtocolProbe (pool, dispatcher) {
-  return dispatcher instanceof Client &&
-    pool[kProtocol] !== 'h1' &&
-    (pool[kOptions].useH2c === true || (pool[kUrl].protocol === 'https:' && pool[kOptions].allowH2 !== false))
-}
-
-function createClient (pool) {
-  const dispatcher = pool[kFactory](pool[kUrl], pool[kOptions])
-
-  // HTTPS does not reveal whether the peer selected h1 or h2 until ALPN
-  // completes. While h2 is still possible, let one Client probe the protocol
-  // and keep later requests in the Pool queue instead of opening one TLS
-  // connection per request. A confirmed h1 connection disables this gate and
-  // restores the usual Pool fan-out.
-  if (shouldCreateProtocolProbe(pool, dispatcher)) {
-    pool[kProtocolProbe] = dispatcher
-  }
-
-  pool[kAddClient](dispatcher)
-  return dispatcher
-}
-
 class Pool extends PoolBase {
   constructor (origin, {
     connections,
@@ -64,8 +35,6 @@ class Pool extends PoolBase {
     autoSelectFamily,
     autoSelectFamilyAttemptTimeout,
     allowH2,
-    useH2c,
-    clientTtl,
     ...options
   } = {}) {
     if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
@@ -85,65 +54,31 @@ class Pool extends PoolBase {
         ...tls,
         maxCachedSessions,
         allowH2,
-        useH2c,
         socketPath,
         timeout: connectTimeout,
-        ...(typeof autoSelectFamily === 'boolean' ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
         ...connect
       })
     }
 
     super(options)
 
+    this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool)
+      ? options.interceptors.Pool
+      : []
     this[kConnections] = connections || null
     this[kUrl] = util.parseOrigin(origin)
-    this[kOptions] = { ...util.deepClone(options), connect, allowH2, useH2c, clientTtl, socketPath }
+    this[kOptions] = { ...util.deepClone(options), connect, allowH2 }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
     this[kFactory] = factory
-    this[kProtocol] = null
-    this[kProtocolProbe] = null
-
-    this.on('connect', (origin, targets) => {
-      if (clientTtl != null && clientTtl > 0) {
-        for (const target of targets) {
-          Object.assign(target, { ttl: Date.now() })
-        }
-      }
-
-      const client = targets[targets.length - 1]
-      if (client instanceof Client) {
-        this[kProtocol] = client[kHTTPContext]?.version
-      }
-
-      if (client === this[kProtocolProbe]) {
-        // An h2 Client's drain event releases the requests accumulated during
-        // negotiation onto that Client. If ALPN selected h1, release the probe
-        // immediately and restore normal Pool fan-out instead.
-        if (this[kProtocol] !== 'h2') {
-          this[kProtocolProbe] = null
-          this[kDrainQueue](origin, targets.slice(1))
-        }
-      }
-    })
-
-    this.on('disconnect', (origin, targets) => {
-      if (targets.includes(this[kProtocolProbe])) {
-        this[kProtocolProbe] = null
-        this[kDrainQueue](origin, targets.slice(1))
-      }
-    })
-
-    this.on('connectionError', (origin, targets) => {
-      let resumeQueued = false
 
+    this.on('connectionError', (origin, targets, error) => {
       // If a connection error occurs, we remove the client from the pool,
       // and emit a connectionError event. They will not be re-used.
       // Fixes https://github.com/nodejs/undici/issues/3895
       for (const target of targets) {
-        if (target === this[kProtocolProbe]) {
-          this[kProtocolProbe] = null
-          resumeQueued = true
-        }
-
         // Do not use kRemoveClient here, as it will close the client,
         // but the client cannot be closed in this state.
         const idx = this[kClients].indexOf(target)
@@ -151,75 +86,21 @@ class Pool extends PoolBase {
           this[kClients].splice(idx, 1)
         }
       }
-
-      if (resumeQueued) {
-        this[kDrainQueue](origin, targets.slice(1))
-      }
     })
   }
 
-  [kOnClientBusy] (client) {
-    if (
-      this[kProtocolProbe] === null &&
-      client[kConnecting] &&
-      shouldCreateProtocolProbe(this, client)
-    ) {
-      this[kProtocolProbe] = client
-    }
-  }
-
-  [kOnClientDrain] (client) {
-    if (client === this[kProtocolProbe]) {
-      this[kProtocolProbe] = null
-    }
-  }
-
   [kGetDispatcher] () {
-    const clientTtlOption = this[kOptions].clientTtl
-    for (let i = 0; i < this[kClients].length; i++) {
-      const client = this[kClients][i]
-
-      // check ttl of client and if it's stale, remove it from the pool
-      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
-        this[kRemoveClient](client)
-        i--
-      } else if (!client[kNeedDrain]) {
+    for (const client of this[kClients]) {
+      if (!client[kNeedDrain]) {
         return client
       }
     }
 
-    if (this[kProtocolProbe] !== null) {
-      return
-    }
-
-    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
-      return createClient(this)
-    }
-  }
-
-  [kHasDispatcher] () {
-    const clientTtlOption = this[kOptions].clientTtl
-    for (let i = 0; i < this[kClients].length; i++) {
-      const client = this[kClients][i]
-
-      if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {
-        this[kRemoveClient](client)
-        i--
-      } else if (!client[kNeedDrain]) {
-        return true
-      }
-    }
-
-    if (this[kProtocolProbe] !== null) {
-      return false
-    }
-
     if (!this[kConnections] || this[kClients].length < this[kConnections]) {
-      createClient(this)
-      return true
+      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
+      this[kAddClient](dispatcher)
+      return dispatcher
     }
-
-    return false
   }
 }