HTTP caching and CDNs.

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

type Reply = { status: number; body: string; etag?: string };

function call(
	port: number,
	path: string,
	method = 'GET',
	headers: Record<string, string> = {}
): Promise<Reply> {
	return new Promise((resolve, reject) => {
		const req = request({ host: '127.0.0.1', port, path, method, headers }, (response) => {
			response.setEncoding('utf8');
			let body = '';
			response.on('data', (chunk: string) => (body += chunk));
			response.on('end', () =>
				resolve({
					status: response.statusCode ?? 0,
					body,
					etag: response.headers.etag
				})
			);
		});
		req.once('error', reject);
		req.end();
	});
}

async function main() {
	// This origin is private to the process and binds only to IPv4 loopback.
	let version = 1;
	const server = createServer((req, response) => {
		if (req.method === 'POST' && req.url === '/publish') {
			version += 1;
			response.writeHead(204);
			response.end();
			return;
		}
		if (req.method !== 'GET' || req.url !== '/catalog') {
			response.writeHead(404);
			response.end();
			return;
		}

		const etag = `"catalog-v${version}"`;
		const cacheControl = 'public, max-age=0, must-revalidate';
		response.setHeader('Cache-Control', cacheControl);
		response.setHeader('ETag', etag);
		if (req.headers['if-none-match'] === etag) {
			console.log(`origin: validator matched ${etag}; returning 304 without a body`);
			response.writeHead(304);
			response.end();
			return;
		}

		console.log(`origin: sending representation ${etag}`);
		response.writeHead(200, { 'content-type': 'application/json; charset=utf-8' });
		response.end(JSON.stringify({ version, items: ['router', 'switch', 'service'] }));
	});

	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 port = (address as AddressInfo).port;
	let stored: { etag: string; body: string } | undefined;

	async function readThroughCache() {
		const reply = await call(
			port,
			'/catalog',
			'GET',
			stored ? { 'if-none-match': stored.etag } : {}
		);
		if (reply.status === 304 && stored) {
			console.log(`client: reused stored body for ${stored.etag}: ${stored.body}`);
			return;
		}
		if (reply.status !== 200 || !reply.etag) throw new Error(`Unexpected response ${reply.status}`);
		stored = { etag: reply.etag, body: reply.body };
		console.log(`client: stored ${stored.etag}: ${stored.body}`);
	}

	try {
		await readThroughCache(); // 200: store a body and its validator.
		await readThroughCache(); // 304: validate, then reuse the stored body.
		await call(port, '/publish', 'POST'); // Change the local origin representation.
		await readThroughCache(); // 200: the old validator no longer matches.
	} finally {
		await new Promise<void>((resolve) => server.close(() => resolve()));
	}
}

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

package main

import (
	"fmt"
	"io"
	"net"
	"net/http"
	"sync"
)

func main() {
	// This origin is private to the process and binds only to IPv4 loopback.
	var mu sync.Mutex
	version := 1
	mux := http.NewServeMux()
	mux.HandleFunc("/publish", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			w.WriteHeader(http.StatusMethodNotAllowed)
			return
		}
		mu.Lock()
		version++
		mu.Unlock()
		w.WriteHeader(http.StatusNoContent)
	})
	mux.HandleFunc("/catalog", func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			w.WriteHeader(http.StatusMethodNotAllowed)
			return
		}
		mu.Lock()
		current := version
		mu.Unlock()

		etag := fmt.Sprintf(`"catalog-v%d"`, current)
		w.Header().Set("Cache-Control", "public, max-age=0, must-revalidate")
		w.Header().Set("ETag", etag)
		if r.Header.Get("If-None-Match") == etag {
			fmt.Printf("origin: validator matched %s; returning 304 without a body\n", etag)
			w.WriteHeader(http.StatusNotModified)
			return
		}

		fmt.Printf("origin: sending representation %s\n", etag)
		w.Header().Set("Content-Type", "application/json; charset=utf-8")
		_, _ = fmt.Fprintf(w, `{"version":%d,"items":["router","switch","service"]}`, current)
	})

	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()
	client := &http.Client{Transport: &http.Transport{DisableKeepAlives: true}}
	defer client.CloseIdleConnections()
	baseURL := "http://" + listener.Addr().String()
	var storedBody, storedETag string

	readThroughCache := func() error {
		req, err := http.NewRequest(http.MethodGet, baseURL+"/catalog", nil)
		if err != nil {
			return err
		}
		if storedETag != "" {
			req.Header.Set("If-None-Match", storedETag)
		}
		response, err := client.Do(req)
		if err != nil {
			return err
		}
		defer response.Body.Close()

		if response.StatusCode == http.StatusNotModified && storedETag != "" {
			fmt.Printf("client: reused stored body for %s: %s\n", storedETag, storedBody)
			return nil
		}
		if response.StatusCode != http.StatusOK {
			return fmt.Errorf("unexpected response: %s", response.Status)
		}
		body, err := io.ReadAll(response.Body)
		if err != nil {
			return err
		}
		storedBody = string(body)
		storedETag = response.Header.Get("ETag")
		if storedETag == "" {
			return fmt.Errorf("origin omitted ETag")
		}
		fmt.Printf("client: stored %s: %s\n", storedETag, storedBody)
		return nil
	}

	if err := readThroughCache(); err != nil {
		panic(err)
	}
	if err := readThroughCache(); err != nil {
		panic(err)
	}
	publish, err := http.NewRequest(http.MethodPost, baseURL+"/publish", nil)
	if err != nil {
		panic(err)
	}
	response, err := client.Do(publish)
	if err != nil {
		panic(err)
	}
	response.Body.Close()
	if err := readThroughCache(); err != nil {
		panic(err)
	}
}