Function strategyUsageTTL

packages/effect/src/internal/pool.ts:386–423

(ttl: Duration.DurationInput)

  )

const strategyUsageTTL = <A, E>(ttl: Duration.DurationInput) =>
  core.map(internalQueue.unbounded<PoolItem<A, E>>(), (queue) => {
    return identity<Strategy<A, E>>({
      run: (pool) => {
        const process: Effect<void> = core.suspend(() => {
          const excess = pool.activeSize - pool.targetSize
          if (excess <= 0) return core.void
          return queue.take.pipe(
            core.tap((item) => pool.invalidatePoolItem(item)),
            core.zipRight(process)
          )
        })
        return process.pipe(
          coreEffect.delay(ttl),
          coreEffect.forever
        )
      },
      onAcquire: (item) => queue.offer(item),
      reclaim(pool) {
        return core.suspend((): Effect<Option.Option<PoolItem<A, E>>> => {
          if (pool.invalidated.size === 0) {
            return coreEffect.succeedNone
          }
          const item = Iterable.head(
            Iterable.filter(pool.invalidated, (item) => !item.disableReclaim)
          )
          if (item._tag === "None") {
            return coreEffect.succeedNone
          }
          pool.invalidated.delete(item.value)
          if (item.value.refCount < pool.concurrency) {
            pool.available.add(item.value)
          }
          return core.as(queue.offer(item.value), item)
        })
      }
    })
  })

const reportUnhandledError = <E>(cause: Cause<E>) =>
  core.withFiberRuntime<void>((fiber) => {