@emiliosp/pi-maestro 0.17.0 → 0.18.1

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

@@ -1,177 +0,0 @@
-'use strict'
-
-const { InvalidArgumentError, MaxOriginsReachedError } = require('../core/errors')
-const { kBusy, kClients, kConnected, kRunning, kPending, kClose, kDestroy, kDispatch, kUrl } = require('../core/symbols')
-const DispatcherBase = require('./dispatcher-base')
-const Pool = require('./pool')
-const Client = require('./client')
-const util = require('../core/util')
-
-const kOnConnect = Symbol('onConnect')
-const kOnDisconnect = Symbol('onDisconnect')
-const kOnConnectionError = Symbol('onConnectionError')
-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
-    ? new Client(origin, opts)
-    : new Pool(origin, opts)
-}
-
-class Agent extends DispatcherBase {
-  constructor ({ factory = defaultFactory, maxOrigins = Infinity, connect, ...options } = {}) {
-    if (typeof factory !== 'function') {
-      throw new InvalidArgumentError('factory must be a function.')
-    }
-
-    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
-      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')
-    }
-
-    super(options)
-
-    if (connect && typeof connect !== 'function') {
-      connect = { ...connect }
-    }
-
-    this[kOptions] = { ...util.deepClone(options), maxOrigins, connect }
-    this[kFactory] = factory
-    this[kClients] = new Map()
-    this[kOrigins] = new Set()
-
-    this[kOnDrain] = (origin, targets) => {
-      this.emit('drain', origin, [this, ...targets])
-    }
-
-    this[kOnConnect] = (origin, targets) => {
-      this.emit('connect', origin, [this, ...targets])
-    }
-
-    this[kOnDisconnect] = (origin, targets, err) => {
-      this.emit('disconnect', origin, [this, ...targets], err)
-    }
-
-    this[kOnConnectionError] = (origin, targets, err) => {
-      this.emit('connectionError', origin, [this, ...targets], err)
-    }
-  }
-
-  get [kRunning] () {
-    let ret = 0
-    for (const dispatcher of this[kClients].values()) {
-      ret += dispatcher[kRunning]
-    }
-    return ret
-  }
-
-  [kDispatch] (opts, handler) {
-    let origin
-    if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) {
-      origin = 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
-        .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)
-        })
-
-      this[kClients].set(key, dispatcher)
-      this[kOrigins].add(origin)
-    }
-
-    return dispatcher.dispatch(opts, handler)
-  }
-
-  [kClose] () {
-    const closePromises = []
-    for (const dispatcher of this[kClients].values()) {
-      closePromises.push(dispatcher.close())
-    }
-    this[kClients].clear()
-
-    return Promise.all(closePromises)
-  }
-
-  [kDestroy] (err) {
-    const destroyPromises = []
-    for (const dispatcher of this[kClients].values()) {
-      destroyPromises.push(dispatcher.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
-  }
-}
-
-module.exports = Agent

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

@@ -1,217 +0,0 @@
-'use strict'
-
-const {
-  BalancedPoolMissingUpstreamError,
-  InvalidArgumentError
-} = require('../core/errors')
-const {
-  PoolBase,
-  kClients,
-  kNeedDrain,
-  kAddClient,
-  kRemoveClient,
-  kGetDispatcher
-} = require('./pool-base')
-const Pool = require('./pool')
-const { kOriginless, kUrl } = require('../core/symbols')
-const util = require('../core/util')
-const kFactory = Symbol('factory')
-
-const kOptions = Symbol('options')
-const kGreatestCommonDivisor = Symbol('kGreatestCommonDivisor')
-const kCurrentWeight = Symbol('kCurrentWeight')
-const kIndex = Symbol('kIndex')
-const kWeight = Symbol('kWeight')
-const kMaxWeightPerServer = Symbol('kMaxWeightPerServer')
-const kErrorPenalty = Symbol('kErrorPenalty')
-
-/**
- * Calculate the greatest common divisor of two numbers by
- * using the Euclidean algorithm.
- *
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function getGreatestCommonDivisor (a, b) {
-  if (a === 0) return b
-
-  while (b !== 0) {
-    const t = b
-    b = a % b
-    a = t
-  }
-  return a
-}
-
-function defaultFactory (origin, opts) {
-  return new Pool(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.')
-    }
-
-    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[kIndex] = -1
-    this[kCurrentWeight] = 0
-
-    this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100
-    this[kErrorPenalty] = this[kOptions].errorPenalty || 15
-
-    if (!Array.isArray(upstreams)) {
-      upstreams = [upstreams]
-    }
-
-    this[kFactory] = factory
-
-    for (const upstream of upstreams) {
-      this.addUpstream(upstream)
-    }
-    this._updateBalancedPoolStats()
-  }
-
-  addUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
-
-    if (this[kClients].find((pool) => (
-      pool[kUrl].origin === upstreamOrigin &&
-      pool.closed !== true &&
-      pool.destroyed !== true
-    ))) {
-      return this
-    }
-    const pool = this[kFactory](upstreamOrigin, this[kOptions])
-
-    this[kAddClient](pool)
-    pool.on('connect', () => {
-      pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty])
-    })
-
-    pool.on('connectionError', () => {
-      pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
-      this._updateBalancedPoolStats()
-    })
-
-    pool.on('disconnect', (...args) => {
-      const err = args[2]
-      if (err && err.code === 'UND_ERR_SOCKET') {
-        // decrease the weight of the pool.
-        pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
-        this._updateBalancedPoolStats()
-      }
-    })
-
-    for (const client of this[kClients]) {
-      client[kWeight] = this[kMaxWeightPerServer]
-    }
-
-    this._updateBalancedPoolStats()
-
-    return this
-  }
-
-  _updateBalancedPoolStats () {
-    let result = 0
-    for (let i = 0; i < this[kClients].length; i++) {
-      result = getGreatestCommonDivisor(this[kClients][i][kWeight], result)
-    }
-
-    this[kGreatestCommonDivisor] = result
-  }
-
-  removeUpstream (upstream) {
-    const upstreamOrigin = util.parseOrigin(upstream).origin
-
-    const pool = this[kClients].find((pool) => (
-      pool[kUrl].origin === upstreamOrigin &&
-      pool.closed !== true &&
-      pool.destroyed !== true
-    ))
-
-    if (pool) {
-      this[kRemoveClient](pool)
-    }
-
-    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)
-      .map((p) => p[kUrl].origin)
-  }
-
-  [kGetDispatcher] () {
-    // We validate that pools is greater than 0,
-    // otherwise we would have to wait until an upstream
-    // is added, which might never happen.
-    if (this[kClients].length === 0) {
-      throw new BalancedPoolMissingUpstreamError()
-    }
-
-    let counter = 0
-
-    let maxWeightIndex = -1
-
-    while (counter++ < this[kClients].length) {
-      this[kIndex] = (this[kIndex] + 1) % this[kClients].length
-      const pool = this[kClients][this[kIndex]]
-
-      // decrease the current weight every `this[kClients].length`.
-      if (this[kIndex] === 0) {
-        // Set the current weight to the next lower weight.
-        this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]
-
-        if (this[kCurrentWeight] <= 0) {
-          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]) {
-        return pool
-      }
-    }
-
-    if (maxWeightIndex === -1) {
-      return
-    }
-
-    this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]
-    this[kIndex] = maxWeightIndex
-    return this[kClients][maxWeightIndex]
-  }
-}
-
-module.exports = BalancedPool