How to chain dispatchers?

[Dzieni]

Might be related to #1957 but I'm not 100% sure.

Let's say I have a following piece of code:

import {fetch, Pool} from 'undici'

const pool = new Pool('https://httpstat.us', {
	connections: 2,
})

const result = await Promise.all(
	Array(5)
		.fill(undefined)
		.map(() =>
			fetch('https://httpstat.us/200?sleep=1000', {
				dispatcher: pool,
			}).then(r => r.text())
		)
)

console.log(result)

Works just fine. Now I have an app that is connecting through the proxy:

setGlobalDispatcher(
	new ProxyAgent({
		uri: 'http://127.0.0.1:8080',
	})
)

How to configure the Pool in a way that all the connections are initiated through the proxy configured globally? I've tried something like this:

const pool = new Pool('https://httpstat.us', {
	connections: 2,
	factory: () => getGlobalDispatcher(),
})

But then the pooling is overriden by the defaults of ProxyAgent.

The hacky way I found is stealing the parameters used by the factory in the ProxyAgent:

let connect

setGlobalDispatcher(
	new ProxyAgent({
		uri: 'http://127.0.0.1:8080',
		factory: (...args) => {
			connect = args[1].connect
			return new Pool(...args)
		},
	})
)

// dummy request to trigger the factory
await fetch('https://httpstat.us').then(r => r.blob())

const pool = new Pool('https://httpstat.us', {
	connections: 2,
	factory: (origin, opts) => new Client(origin, {...opts, connect}),
})

The problem is I don't see any legal way to scrape the connect function from the ProxyAgent.

[metcoder95]

Hey! You can also do it the other way around. When instantiating ProxyAgent, you can pass the option factory: (...args) => new Pool(...args), in this way the pool is used as client and you pass the connect options down the path.

When setting a setGlobalDispatcher, fetch will also make use of such a dispatcher, there's no need to pass it once more when calling fetch.

An example might be:

let pool;
setGlobalDispatcher(
	new ProxyAgent({
		uri: 'http://127.0.0.1:8080',
		factory: (...args) => {
			pool = new Pool(...args)
			return pool;
		},
	})
)

// dummy request to trigger the factory
await fetch('https://httpstat.us').then(r => r.blob())

[Dzieni]

When instantiating ProxyAgent

I wanted to avoid doing this on that level. The app is supposed to have different dispatchers (with different pooling, timeout handling, etc) depending on the API it interacts with, so setting this up globally would be too messy.

I wanted to achieve a behavior similar to the libraries like global-agent - you set up an environment variable that makes all the requests go through the proxy, and parts like timeout handling are not overriden.

If chaining dispatchers is not possible, I'll probably go for something like this:

if (process.env.PROXY_URL) {
	// for the places that don't care about custom pooling and timeout handling
	setGlobalDispatcher(new ProxyAgent(process.env.PROXY_URL))
}

const customDispatcher = new (process.env.PROXY_URL ? ProxyAgent : Agent)({
	uri: process.env.PROXY_URL,
	connections: 5,
	// ...etc
})

The disadvantage is that you have to use process.env.PROXY_URL in multiple places, and that's something I wanted to avoid.

[metcoder95]

Well, it also is important to understand that ProxyAgent sits in front of the Pool implementation. Both themselves are Dispatchers.

global-agent

Yes, sadly it patches the global http agent, Here you can replicate the same with setGlobalDispatcher. You can create a custom Dispatcher that works as an abstraction and decides based on a config flag what kind or the same URL, which of the two pools to use.