[Website] Fix Bad Gateway and optimize PHP workers (#3219)

## Motivation for the change, related issues

This PR fixes Bad Gateway (502) errors that occur when multiple
concurrent requests are made to the PHP request handler.

## Implementation details

1. **The primary PHP instance was not used for enqueued requests.**
Instead, all enqueued requests needed to wait for the secondary
instances, and the primary instance only served new requests directly,
never from the queue.

The fix refactors `PHPProcessManager` to a pool-based design where all
spawned instances (including primary) are added to an idle pool,
`acquirePHPInstance()` takes from the pool or spawns new ones if needed,
and instances are returned to the pool for reuse. All PHP instances
should be automatically rotated every 400 requests.

3. **Increased instance wait timeout from 5s to 30s:** When all PHP
instances are busy, new requests wait for one to become available. The
previous 5s timeout was likely a bit too short for some scenarios. This
timeout limits wait time for an available instance, not PHP execution
time.

4. **Semaphore stale resolver bug:** When a semaphore acquire timed out,
its resolver remained in the queue. Later releases would notify these
stale resolvers instead of actual waiting requests. The fix removes
timed-out resolvers from the queue.

## Testing Instructions (or ideally a Blueprint)

The fix can be verified by running concurrent requests in the browser
console:

```javascript
const iframe = document.querySelector('iframe');
const playground = iframe.contentWindow.playground;
const start = Date.now();
const requests = [
  playground.run({ code: '<?php sleep(4); echo "done1";' }),
  playground.run({ code: '<?php sleep(4); echo "done2";' }),
  playground.run({ code: '<?php sleep(4); echo "done3";' }),
  playground.run({ code: '<?php sleep(4); echo "done4";' }),
  playground.run({ code: '<?php sleep(4); echo "done5";' }),
  playground.run({ code: '<?php sleep(4); echo "done6";' }),
  // Add more and modify sleep time as needed for testing.
];
const results = await Promise.allSettled(requests);
console.log('Total time:', Date.now() - start, 'ms');
console.log(results);
```

On `trunk`, some of these promises would be rejected. In this branch,
all should succeed.

Author: JanJakes

packages/php-wasm/node/src/test/php-instance-manager.spec.ts

@@ -159,7 +159,7 @@ describe('PHPProcessManager', () => {
 		);
 	});
 
-	it('should not start a second PHP instance until the first getInstance() call when the primary instance is busy', async () => {
+	it('should reuse idle instances and only spawn when needed', async () => {
 		const phpFactory = vitest.fn(
 			async () => new PHP(await loadNodeRuntime(RecommendedPHPVersion))
 		);
@@ -169,39 +169,45 @@ describe('PHPProcessManager', () => {
 		});
 
 		expect(phpFactory).not.toHaveBeenCalled();
+
+		// First acquire spawns primary instance
 		const php1 = await mgr.acquirePHPInstance();
 		expect(phpFactory).toHaveBeenCalledTimes(1);
 		php1.reap();
 
+		// Second acquire reuses the now-idle primary
 		const php2 = await mgr.acquirePHPInstance();
 		expect(phpFactory).toHaveBeenCalledTimes(1);
 		php2.reap();
 
-		await mgr.acquirePHPInstance();
-		await mgr.acquirePHPInstance();
-		expect(phpFactory).toHaveBeenCalledTimes(3);
+		// Third acquire reuses primary again
+		const php3 = await mgr.acquirePHPInstance();
+		expect(phpFactory).toHaveBeenCalledTimes(1);
+
+		// Fourth acquire needs a new instance (primary is busy)
+		const php4 = await mgr.acquirePHPInstance();
+		expect(phpFactory).toHaveBeenCalledTimes(2);
+
+		php3.reap();
+		php4.reap();
 	});
 
-	it('should refuse to spawn two primary PHP instances', async () => {
+	it('should not spawn duplicate primary instances when called concurrently', async () => {
+		const phpFactory = vitest.fn(
+			async () => new PHP(await loadNodeRuntime(RecommendedPHPVersion))
+		);
 		const mgr = new PHPProcessManager({
-			phpFactory: async () =>
-				new PHP(await loadNodeRuntime(RecommendedPHPVersion)),
+			phpFactory,
 			maxPhpInstances: 5,
 		});
 
-		// A synchronous call. Do not await this promise on purpose.
-		mgr.getPrimaryPhp();
-
-		// No await here, because we want to check if a second,
-		// synchronous call throws an error if issued before
-		// the first call completes asynchronously.
-		try {
-			mgr.getPrimaryPhp();
-		} catch (e) {
-			expect(e).toBeInstanceOf(Error);
-			expect((e as Error).message).toContain(
-				'Requested spawning a primary PHP instance'
-			);
-		}
+		// Call getPrimaryPhp() twice concurrently - both should return the same instance
+		const [php1, php2] = await Promise.all([
+			mgr.getPrimaryPhp(),
+			mgr.getPrimaryPhp(),
+		]);
+
+		expect(php1).toBe(php2);
+		expect(phpFactory).toHaveBeenCalledTimes(1);
 	});
 });

packages/php-wasm/node/src/test/php-process-manager.spec.ts

@@ -73,7 +73,7 @@ describe('PHPProcessManager', () => {
 		);
 	});
 
-	it('should not start a second PHP instance until the first getInstance() call when the primary instance is busy', async () => {
+	it('should reuse idle instances and only spawn when needed', async () => {
 		const phpFactory = vitest.fn(
 			async () => new PHP(await loadNodeRuntime(RecommendedPHPVersion))
 		);
@@ -83,39 +83,45 @@ describe('PHPProcessManager', () => {
 		});
 
 		expect(phpFactory).not.toHaveBeenCalled();
+
+		// First acquire spawns primary instance
 		const php1 = await mgr.acquirePHPInstance();
 		expect(phpFactory).toHaveBeenCalledTimes(1);
 		php1.reap();
 
+		// Second acquire reuses the now-idle primary
 		const php2 = await mgr.acquirePHPInstance();
 		expect(phpFactory).toHaveBeenCalledTimes(1);
 		php2.reap();
 
-		await mgr.acquirePHPInstance();
-		await mgr.acquirePHPInstance();
-		expect(phpFactory).toHaveBeenCalledTimes(3);
+		// Third acquire reuses primary again
+		const php3 = await mgr.acquirePHPInstance();
+		expect(phpFactory).toHaveBeenCalledTimes(1);
+
+		// Fourth acquire needs a new instance (primary is busy)
+		const php4 = await mgr.acquirePHPInstance();
+		expect(phpFactory).toHaveBeenCalledTimes(2);
+
+		php3.reap();
+		php4.reap();
 	});
 
-	it('should refuse to spawn two primary PHP instances', async () => {
+	it('should not spawn duplicate primary instances when called concurrently', async () => {
+		const phpFactory = vitest.fn(
+			async () => new PHP(await loadNodeRuntime(RecommendedPHPVersion))
+		);
 		const mgr = new PHPProcessManager({
-			phpFactory: async () =>
-				new PHP(await loadNodeRuntime(RecommendedPHPVersion)),
+			phpFactory,
 			maxPhpInstances: 5,
 		});
 
-		// A synchronous call. Do not await this promise on purpose.
-		mgr.getPrimaryPhp();
-
-		// No await here, because we want to check if a second,
-		// synchronous call throws an error if issued before
-		// the first call completes asynchronously.
-		try {
-			mgr.getPrimaryPhp();
-		} catch (e) {
-			expect(e).toBeInstanceOf(Error);
-			expect((e as Error).message).toContain(
-				'Requested spawning a primary PHP instance'
-			);
-		}
+		// Call getPrimaryPhp() twice concurrently - both should return the same instance
+		const [php1, php2] = await Promise.all([
+			mgr.getPrimaryPhp(),
+			mgr.getPrimaryPhp(),
+		]);
+
+		expect(php1).toBe(php2);
+		expect(phpFactory).toHaveBeenCalledTimes(1);
 	});
 });