@yanglaofish/fishtools 0.5.2 → 0.6.0

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

@@ -1,19 +1,20 @@
 'use strict'
 
-const { InvalidArgumentError, MaxOriginsReachedError } = require('../core/errors')
-const { kBusy, kClients, kConnected, kRunning, kPending, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
+const { InvalidArgumentError } = require('../core/errors')
+const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require('../core/symbols')
 const DispatcherBase = require('./dispatcher-base')
 const Pool = require('./pool')
 const Client = require('./client')
 const util = require('../core/util')
+const createRedirectInterceptor = require('../interceptor/redirect-interceptor')
 
 const kOnConnect = Symbol('onConnect')
 const kOnDisconnect = Symbol('onDisconnect')
 const kOnConnectionError = Symbol('onConnectionError')
+const kMaxRedirections = Symbol('maxRedirections')
 const kOnDrain = Symbol('onDrain')
 const kFactory = Symbol('factory')
 const kOptions = Symbol('options')
-const kOrigins = Symbol('origins')
 
 function defaultFactory (origin, opts) {
   return opts && opts.connections === 1
@@ -22,7 +23,7 @@ function defaultFactory (origin, opts) {
 }
 
 class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
+  constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
     if (typeof factory !== 'function') {
       throw new InvalidArgumentError('factory must be a function.')
     }
@@ -31,8 +32,8 @@ class Agent extends DispatcherBase {
       throw new InvalidArgumentError('connect must be a function or an object')
     }
 
-    if (typeof maxOrigins !== 'number' || Number.isNaN(maxOrigins) || maxOrigins <= 0) {
-      throw new InvalidArgumentError('maxOrigins must be a number greater than 0')
+    if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
     }
 
     super(options)
@@ -41,10 +42,17 @@ class Agent extends DispatcherBase {
       connect = { ...connect }
     }
 
-    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
+    this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent)
+      ? options.interceptors.Agent
+      : [createRedirectInterceptor({ maxRedirections })]
+
+    this[kOptions] = { ...util.deepClone(options), connect }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
+    this[kMaxRedirections] = maxRedirections
     this[kFactory] = factory
     this[kClients] = new Map()
-    this[kOrigins] = new Set()
 
     this[kOnDrain] = (origin, targets) => {
       this.emit('drain', origin, [this, ...targets])
@@ -65,112 +73,56 @@ class Agent extends DispatcherBase {
 
   get [kRunning] () {
     let ret = 0
-    for (const dispatcher of this[kClients].values()) {
-      ret += dispatcher[kRunning]
+    for (const client of this[kClients].values()) {
+      ret += client[kRunning]
     }
     return ret
   }
 
   [kDispatch] (opts, handler) {
-    let origin
+    let key
     if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) {
-      origin = String(opts.origin)
+      key = String(opts.origin)
     } else {
       throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')
     }
 
-    const allowH2 = opts.allowH2 ?? this[kOptions].allowH2
-    const key = allowH2 === false ? `${origin}#http1-only` : origin
-
-    if (this[kOrigins].size >= this[kOptions].maxOrigins && !this[kOrigins].has(origin)) {
-      throw new MaxOriginsReachedError()
-    }
-
     let dispatcher = this[kClients].get(key)
+
     if (!dispatcher) {
-      dispatcher = this[kFactory](opts.origin, allowH2 === false
-        ? { ...this[kOptions], allowH2: false }
-        : this[kOptions])
-
-      const closeClientIfUnused = () => {
-        if (this[kClients].get(key) !== dispatcher) {
-          return
-        }
-
-        // A GOAWAY detaches the HTTP/2 session before requeued requests are
-        // dispatched on a replacement connection. At that point the pool has
-        // no connected clients and is not busy, but it still has pending work.
-        // Closing it here lets the replacement Client finish those requests
-        // and then destroys that new connection with ClientDestroyedError.
-        if (dispatcher[kConnected] > 0 || dispatcher[kBusy] || dispatcher[kPending] > 0) {
-          return
-        }
-
-        this[kClients].delete(key)
-        if (!dispatcher.destroyed) {
-          dispatcher.close()
-        }
-
-        let hasOrigin = false
-        for (const k of this[kClients].keys()) {
-          if (k === origin || k === `${origin}#http1-only`) {
-            hasOrigin = true
-            break
-          }
-        }
-
-        if (!hasOrigin) {
-          this[kOrigins].delete(origin)
-        }
-      }
-
-      dispatcher
+      dispatcher = this[kFactory](opts.origin, this[kOptions])
         .on('drain', this[kOnDrain])
         .on('connect', this[kOnConnect])
-        .on('disconnect', (origin, targets, err) => {
-          closeClientIfUnused()
-          this[kOnDisconnect](origin, targets, err)
-        })
-        .on('connectionError', (origin, targets, err) => {
-          closeClientIfUnused()
-          this[kOnConnectionError](origin, targets, err)
-        })
+        .on('disconnect', this[kOnDisconnect])
+        .on('connectionError', this[kOnConnectionError])
 
+      // This introduces a tiny memory leak, as dispatchers are never removed from the map.
+      // TODO(mcollina): remove te timer when the client/pool do not have any more
+      // active connections.
       this[kClients].set(key, dispatcher)
-      this[kOrigins].add(origin)
     }
 
     return dispatcher.dispatch(opts, handler)
   }
 
-  [kClose] () {
+  async [kClose] () {
     const closePromises = []
-    for (const dispatcher of this[kClients].values()) {
-      closePromises.push(dispatcher.close())
+    for (const client of this[kClients].values()) {
+      closePromises.push(client.close())
     }
     this[kClients].clear()
 
-    return Promise.all(closePromises)
+    await Promise.all(closePromises)
   }
 
-  [kDestroy] (err) {
+  async [kDestroy] (err) {
     const destroyPromises = []
-    for (const dispatcher of this[kClients].values()) {
-      destroyPromises.push(dispatcher.destroy(err))
+    for (const client of this[kClients].values()) {
+      destroyPromises.push(client.destroy(err))
     }
     this[kClients].clear()
 
-    return Promise.all(destroyPromises)
-  }
-
-  get stats () {
-    const allClientStats = {}
-    for (const dispatcher of this[kClients].values()) {
-      if (dispatcher.stats) {
-        allClientStats[dispatcher[kUrl].origin] = dispatcher.stats
-      }
-    }
-    return allClientStats
+    await Promise.all(destroyPromises)
   }
 }
 

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

@@ -13,8 +13,8 @@ const {
   kGetDispatcher
 } = require('./pool-base')
 const Pool = require('./pool')
-const { kOriginless, kUrl } = require('../core/symbols')
-const util = require('../core/util')
+const { kUrl, kInterceptors } = require('../core/symbols')
+const { parseOrigin } = require('../core/util')
 const kFactory = Symbol('factory')
 
 const kOptions = Symbol('options')
@@ -49,17 +49,10 @@ function defaultFactory (origin, opts) {
 }
 
 class BalancedPool extends PoolBase {
-  constructor (upstreams = [], { factory = defaultFactory, connect, tls, ...opts } = {}) {
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
+  constructor (upstreams = [], { factory = defaultFactory, ...opts } = {}) {
+    super()
 
-    super(opts)
-
-    this[kOriginless] = true
-    if (connect && typeof connect !== 'function') connect = { ...connect }
-    if (tls && typeof tls !== 'function') tls = { ...tls }
-    this[kOptions] = { ...util.deepClone(opts), connect, tls }
+    this[kOptions] = opts
     this[kIndex] = -1
     this[kCurrentWeight] = 0
 
@@ -70,6 +63,13 @@ class BalancedPool extends PoolBase {
       upstreams = [upstreams]
     }
 
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    this[kInterceptors] = opts.interceptors?.BalancedPool && Array.isArray(opts.interceptors.BalancedPool)
+      ? opts.interceptors.BalancedPool
+      : []
     this[kFactory] = factory
 
     for (const upstream of upstreams) {
@@ -79,7 +79,7 @@ class BalancedPool extends PoolBase {
   }
 
   addUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
+    const upstreamOrigin = parseOrigin(upstream).origin
 
     if (this[kClients].find((pool) => (
       pool[kUrl].origin === upstreamOrigin &&
@@ -88,7 +88,7 @@ class BalancedPool extends PoolBase {
     ))) {
       return this
     }
-    const pool = this[kFactory](upstreamOrigin, this[kOptions])
+    const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]))
 
     this[kAddClient](pool)
     pool.on('connect', () => {
@@ -128,7 +128,7 @@ class BalancedPool extends PoolBase {
   }
 
   removeUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
+    const upstreamOrigin = parseOrigin(upstream).origin
 
     const pool = this[kClients].find((pool) => (
       pool[kUrl].origin === upstreamOrigin &&
@@ -143,16 +143,6 @@ class BalancedPool extends PoolBase {
     return this
   }
 
-  getUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
-
-    return this[kClients].find((pool) => (
-      pool[kUrl].origin === upstreamOrigin &&
-      pool.closed !== true &&
-      pool.destroyed !== true
-    ))
-  }
-
   get upstreams () {
     return this[kClients]
       .filter(dispatcher => dispatcher.closed !== true && dispatcher.destroyed !== true)
@@ -167,14 +157,35 @@ class BalancedPool extends PoolBase {
       throw new BalancedPoolMissingUpstreamError()
     }
 
+    const dispatcher = this[kClients].find(dispatcher => (
+      !dispatcher[kNeedDrain] &&
+      dispatcher.closed !== true &&
+      dispatcher.destroyed !== true
+    ))
+
+    if (!dispatcher) {
+      return
+    }
+
+    const allClientsBusy = this[kClients].map(pool => pool[kNeedDrain]).reduce((a, b) => a && b, true)
+
+    if (allClientsBusy) {
+      return
+    }
+
     let counter = 0
 
-    let maxWeightIndex = -1
+    let maxWeightIndex = this[kClients].findIndex(pool => !pool[kNeedDrain])
 
     while (counter++ < this[kClients].length) {
       this[kIndex] = (this[kIndex] + 1) % this[kClients].length
       const pool = this[kClients][this[kIndex]]
 
+      // find pool index with the largest weight
+      if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
+        maxWeightIndex = this[kIndex]
+      }
+
       // decrease the current weight every `this[kClients].length`.
       if (this[kIndex] === 0) {
         // Set the current weight to the next lower weight.
@@ -184,30 +195,11 @@ class BalancedPool extends PoolBase {
           this[kCurrentWeight] = this[kMaxWeightPerServer]
         }
       }
-
-      // Skip unavailable pools after updating the current weight for this cycle.
-      if (
-        pool[kNeedDrain] ||
-        pool.closed === true ||
-        pool.destroyed === true
-      ) {
-        continue
-      }
-
-      // Track the best fallback if no pool matches the current weight.
-      if (maxWeightIndex === -1 || pool[kWeight] > this[kClients][maxWeightIndex][kWeight]) {
-        maxWeightIndex = this[kIndex]
-      }
-
-      if (pool[kWeight] >= this[kCurrentWeight]) {
+      if (pool[kWeight] >= this[kCurrentWeight] && (!pool[kNeedDrain])) {
         return pool
       }
     }
 
-    if (maxWeightIndex === -1) {
-      return
-    }
-
     this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]
     this[kIndex] = maxWeightIndex
     return this[kClients][maxWeightIndex]