Timeouts, keepalives, and connection pooling.

import { Agent, createServer, request } from 'node:http';
import type { AddressInfo } from 'node:net';

type Limits = { connectMs: number; idleMs: number; totalMs: number };

function getText(port: number, agent: Agent, path: string, limits: Limits): Promise<string> {
	return new Promise((resolve, reject) => {
		const req = request({ host: '127.0.0.1', port, path, agent }, (response) => {
			response.setEncoding('utf8');
			let body = '';
			response.on('data', (chunk: string) => (body += chunk));
			response.on('end', () => {
				clearTimeout(totalTimer);
				if (connectTimer) clearTimeout(connectTimer);
				resolve(body.trim());
			});
		});

		const totalTimer = setTimeout(
			() => req.destroy(new Error('total request deadline exceeded')),
			limits.totalMs
		);
		let connectTimer: ReturnType<typeof setTimeout> | undefined;
		req.setTimeout(limits.idleMs, () => req.destroy(new Error('socket inactivity limit exceeded')));
		req.on('socket', (socket) => {
			if (!socket.connecting) return; // A reused connection has no new connect phase.
			connectTimer = setTimeout(
				() => socket.destroy(new Error('TCP connect deadline exceeded')),
				limits.connectMs
			);
			socket.once('connect', () => {
				if (connectTimer) clearTimeout(connectTimer);
			});
			socket.once('close', () => {
				if (connectTimer) clearTimeout(connectTimer);
			});
		});
		req.once('error', (error) => {
			clearTimeout(totalTimer);
			if (connectTimer) clearTimeout(connectTimer);
			reject(error);
		});
		req.end();
	});
}

async function main() {
	// The only origin is this process, bound to IPv4 loopback.
	const server = createServer((req, response) => {
		const peerPort = req.socket.remotePort;
		const delay = req.url === '/slow' ? 140 : req.url === '/very-slow' ? 250 : 0;
		setTimeout(() => {
			if (response.destroyed) return;
			response.writeHead(200, { 'content-type': 'text/plain' });
			response.end(`path=${req.url} peer-port=${peerPort}\n`);
		}, delay);
	});
	server.keepAliveTimeout = 1000;
	await new Promise<void>((resolve, reject) => {
		server.once('error', reject);
		server.listen(0, '127.0.0.1', resolve);
	});

	const address = server.address();
	if (!address || typeof address === 'string') throw new Error('Expected a local TCP address.');
	const agent = new Agent({ keepAlive: true, maxSockets: 1, maxFreeSockets: 1 });
	const port = (address as AddressInfo).port;
	const normalLimits = { connectMs: 500, idleMs: 500, totalMs: 1000 };

	try {
		// The second request waits in the Agent queue while /slow owns the one socket.
		const [slow, fast] = await Promise.all([
			getText(port, agent, '/slow', normalLimits),
			getText(port, agent, '/fast', normalLimits)
		]);
		console.log(slow);
		console.log(fast);

		try {
			await getText(port, agent, '/very-slow', {
				connectMs: 500,
				idleMs: 60,
				totalMs: 500
			});
		} catch (error) {
			console.log(`bounded slow request: ${(error as Error).message}`);
		}
	} finally {
		agent.destroy();
		await new Promise<void>((resolve) => server.close(() => resolve()));
	}
}

void main().catch((error: unknown) => {
	console.error(error);
	process.exitCode = 1;
});

package main

import (
	"context"
	"fmt"
	"io"
	"net"
	"net/http"
	"time"
)

func main() {
	started := make(chan struct{}, 1)
	mux := http.NewServeMux()
	mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		delay := time.Duration(0)
		switch r.URL.Path {
		case "/slow":
			delay = 140 * time.Millisecond
			select {
			case started <- struct{}{}:
			default:
			}
		case "/very-slow":
			delay = 500 * time.Millisecond
		}
		time.Sleep(delay)
		_, _ = fmt.Fprintf(w, "path=%s peer=%s\n", r.URL.Path, r.RemoteAddr)
	})

	listener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		panic(err)
	}
	server := &http.Server{Handler: mux}
	go func() { _ = server.Serve(listener) }()
	defer server.Close()

	transport := &http.Transport{
		MaxConnsPerHost:       1,
		MaxIdleConnsPerHost:   1,
		IdleConnTimeout:       300 * time.Millisecond,
		ResponseHeaderTimeout: 200 * time.Millisecond,
		DialContext: (&net.Dialer{
			Timeout: 100 * time.Millisecond,
		}).DialContext,
	}
	client := &http.Client{Transport: transport, Timeout: time.Second}
	defer transport.CloseIdleConnections()

	get := func(path string, budget time.Duration) (string, error) {
		ctx, cancel := context.WithTimeout(context.Background(), budget)
		defer cancel()
		req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://"+listener.Addr().String()+path, nil)
		if err != nil {
			return "", err
		}
		response, err := client.Do(req)
		if err != nil {
			return "", err
		}
		defer response.Body.Close()
		body, err := io.ReadAll(response.Body)
		return string(body), err
	}

	type result struct {
		body string
		err  error
	}
	slowResult := make(chan result, 1)
	go func() {
		body, err := get("/slow", 900*time.Millisecond)
		slowResult <- result{body: body, err: err}
	}()
	<-started // Make the slower request occupy the only connection before queuing /fast.
	fast, err := get("/fast", 900*time.Millisecond)
	if err != nil {
		panic(err)
	}
	slow := <-slowResult
	if slow.err != nil {
		panic(slow.err)
	}
	fmt.Print(slow.body)
	fmt.Print(fast)

	_, err = get("/very-slow", 900*time.Millisecond)
	fmt.Printf("bounded slow request: %v\n", err)
}