• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

dg / dresscode / 42241447482

06 Nov 2026 03:04PM UTC coverage: 97.085% (+0.02%) from 97.064%
42241447482

push

github

dg
cli: the hidden option --profile writes where the time of a run went, the workers included

`--profile <file>` writes as JSON where the time of a run went, in nanoseconds: the phases (the start of the process,
the start of the container of PHPStan or of a derived one and its scopes, the parse, the passes, the gaps, the print,
the cycle collection, the run as a whole), every rule by the time of its callbacks, how often they ran and how often
they changed the tree, every gap rule by the time of its claims, every file with its size, rounds and passes, and the
peak memory of every process. A worker measures its own files and hands that over with every result and the parent
adds it up, so the totals do not depend on the number of workers. A run with the option leaves the result cache out,
a file served from the cache having nothing to measure.

It says where the time of a run goes, not only how much of it: a comparison of two revisions then names the rule or
the claim that moved. Without the option the engine only asks whether there is a profiler, and wraps a claim in
a measurement only when there is one.

137 of 148 new or added lines in 14 files covered. (92.57%)

110 existing lines in 13 files now uncovered.

29411 of 30294 relevant lines covered (97.09%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.11
/src/Engine/WorkerPool.php
1
<?php declare(strict_types=1);
2

3
/**
4
 * This file is part of the DressCode, a coding style and upgrade tool for PHP (https://dresscode.run)
5
 * Copyright (c) 2026 David Grudl (https://davidgrudl.com)
6
 */
7

8
namespace DressCode\Engine;
9

10
use DressCode\FileResult;
11
use function array_key_exists, count, dirname, function_exists, in_array, is_array, strlen;
12
use const PHP_OS_FAMILY, PHP_SAPI;
13

14

15
/**
16
 * Processes files in worker processes: a TCP server on the loopback hands the paths out one at a time,
17
 * a worker sends each result back as a line of JSON. The parent keeps the cache and the baseline, a worker
18
 * only processes and, when fixing, writes.
19
 * @internal
20
 */
21
final class WorkerPool
22
{
23
        /** microseconds the wait for the workers lasts at most while the progress is watched, so that a spinner turns */
24
        private const ProgressInterval = 100_000;
25

26
        /** seconds the end of a worker is waited for once its connection has closed */
27
        private const EndTimeout = 1;
28

29
        /**
30
         * The listening socket: from ext/sockets when available, because the stream layer on Windows waits 500 ms
31
         * for a socket to become writable before closing it, which a listening one never does.
32
         * @var \Socket|resource|null
33
         */
34
        private mixed $server = null;
35

36
        /** @var array<int, resource>  connected workers by socket id */
37
        private array $sockets = [];
38

39
        /** @var array<int, string>  what a worker sent after its last complete line, by socket id */
40
        private array $buffers = [];
41

42
        /** workers that have connected so far */
43
        private int $accepted = 0;
44

45
        /** workers started once the first has connected */
46
        private int $pending = 0;
47

48
        /** the address the workers connect to */
49
        private string $address = '';
50

51
        /** @var array<int, array{string, float, string}>  path in progress with the time it started and its content, by socket id */
52
        private array $inProgress = [];
53

54
        /** @var ?\Closure(string): string  path => content, read when the path is handed out */
55
        private ?\Closure $read = null;
56

57
        /** @var list<array{resource, string}>  process, file with its output */
58
        private array $workers = [];
59

60
        /** when the last worker was started */
61
        private float $spawnedAt = 0;
62

63
        /** @var list<string> */
64
        private array $queue = [];
65

66
        /** @var array<int, true>  workers asked for what they measured last, by socket id */
67
        private array $finishing = [];
68

69
        /** @var array<string, true>  the files the results depend on, as the workers sent them */
70
        private array $dependencies = [];
71

72
        /** @var array<string, true>  what the analyses of the workers tell the user about the run */
73
        private array $warnings = [];
74

75

76
        public function __construct(
77
                /** @var list<string> the worker command line; --worker with the address is appended */
78
                private readonly array $command,
1 ✔
79
                private readonly int $jobs,
1 ✔
80
                /** working directory of the workers */
81
                private readonly ?string $cwd = null,
1 ✔
82
                /** seconds a worker may spend on one file before the run fails, since a rule has most likely looped */
83
                private readonly int $taskTimeout = 300,
1 ✔
84
                /** seconds a worker may take to connect, the first one filling the cache the others share among them */
85
                private readonly int $connectTimeout = 300,
1 ✔
86
                /** with it, every worker hands over what it measured last once nothing is left, one that got no file among them */
87
                private readonly ?Profiler $profiler = null,
1 ✔
88
                /** the first worker fills a cache the others share before it connects, and they start after that */
89
                private readonly bool $warmFirst = false,
1 ✔
90
        ) {
91
        }
1 ✔
92

93

94
        /**
95
         * The workers a run of the files takes by default: a worker costs about the processing of a few files to start, so one
96
         * for every four files at most, and no more than the processors.
97
         */
98
        public static function countDefaultJobs(int $files): int
99
        {
100
                return max(1, min(self::detectCpuCount(), intdiv($files, 4)));
1 ✔
101
        }
102

103

104
        /** Processors the machine has, 1 when unknown. */
105
        public static function detectCpuCount(): int
106
        {
107
                $count = (int) getenv('NUMBER_OF_PROCESSORS');
1 ✔
108
                if ($count < 1 && is_readable('/proc/cpuinfo')) {
1 ✔
109
                        $count = preg_match_all('~^processor\s*:~m', (string) file_get_contents('/proc/cpuinfo'));
1 ✔
110
                }
111

112
                if ($count < 1 && in_array(PHP_OS_FAMILY, ['Darwin', 'BSD'], true) && function_exists('shell_exec')) {
1 ✔
UNCOV
113
                        $count = (int) @shell_exec('sysctl -n hw.ncpu 2>/dev/null'); // @ a failed command gives no count
×
114
                }
115

116
                return max(1, $count);
1 ✔
117
        }
118

119

120
        /**
121
         * The program of this very package, which a process of DressCode is started as: never the one the process itself was
122
         * started as, which for a test or an application embedding DressCode is another program.
123
         */
124
        public static function locateProgram(): string
125
        {
126
                return \Phar::running(returnPhar: false) ?: dirname(__DIR__, 2) . '/bin/dresscode';
1 ✔
127
        }
128

129

130
        /**
131
         * The PHP a process of DressCode is started with: the same binary with the same ini file, the binary alone loading the
132
         * default one, and the settings the process has beyond it; null where no CLI binary is found to start one.
133
         * @return ?list<string>
134
         */
135
        public static function buildPhpCommand(): ?array
136
        {
137
                $binary = self::findCliBinary();
1 ✔
138
                if ($binary === null) {
1 ✔
UNCOV
139
                        return null;
×
140
                }
141

142
                $ini = php_ini_loaded_file();
1 ✔
143
                $php = [$binary, ...($ini === false ? (php_ini_scanned_files() === false ? ['-n'] : []) : ['-c', $ini])];
1 ✔
144
                return [...$php, ...self::findIniOverrides($php)];
1 ✔
145
        }
146

147

148
        /** The binary of the process, or under another SAPI than CLI, such as CGI, the CLI binary beside it. */
149
        private static function findCliBinary(): ?string
150
        {
151
                if (PHP_SAPI === 'cli') {
1 ✔
152
                        return PHP_BINARY;
1 ✔
153
                }
154

UNCOV
155
                $path = dirname(PHP_BINARY) . '/php' . (PHP_OS_FAMILY === 'Windows' ? '.exe' : '');
×
UNCOV
156
                return is_file($path) ? $path : null;
×
157
        }
158

159

160
        /**
161
         * The settings the process has and the PHP of the command alone would not, those given by -d above all, as the
162
         * options -d that give them to a worker; PHP tells no process the options it started with, so the PHP of the
163
         * command is asked for its settings and they are compared.
164
         * @param  list<string>  $php
165
         * @return list<string>
166
         */
167
        private static function findIniOverrides(array $php): array
168
        {
169
                $null = PHP_OS_FAMILY === 'Windows' ? 'NUL' : '/dev/null';
1 ✔
170
                $process = @proc_open([...$php, '-r', 'echo serialize(ini_get_all(null, false));'], [1 => ['pipe', 'w'], 2 => ['file', $null, 'w']], $pipes); // @ no settings then
1 ✔
171
                if ($process === false) {
1 ✔
UNCOV
172
                        return [];
×
173
                }
174

175
                $base = @unserialize((string) stream_get_contents($pipes[1])); // @ a PHP that failed to start gives none
1 ✔
176
                fclose($pipes[1]);
1 ✔
177
                proc_close($process);
1 ✔
178
                $own = ini_get_all(details: false);
1 ✔
179
                if (!is_array($base) || $own === false) {
1 ✔
UNCOV
180
                        return [];
×
181
                }
182

183
                $options = [];
1 ✔
184
                foreach ($own as $name => $value) {
1 ✔
185
                        if (array_key_exists($name, $base) && $base[$name] !== $value) {
1 ✔
186
                                $options[] = '-d';
1 ✔
187
                                $options[] = "$name=$value";
1 ✔
188
                        }
189
                }
190

191
                return $options;
1 ✔
192
        }
193

194

195
        /**
196
         * The results by path, each as soon as it arrives; the content of a file is read when it is handed out, so that
197
         * only the files in progress are held.
198
         * @param  list<string>  $paths
199
         * @param  \Closure(string): string  $read  path => content
200
         * @param  ?\Closure(int, array<string, float>): void  $onProgress  files done and the paths in progress
201
         * @return \Generator<string, FileResult>
202
         * @throws \RuntimeException  when a worker fails
203
         */
204
        public function process(array $paths, \Closure $read, ?\Closure $onProgress = null): \Generator
1 ✔
205
        {
206
                $address = $this->listen();
1 ✔
207
                $this->queue = $paths;
1 ✔
208
                $this->read = $read;
1 ✔
209
                $done = 0;
1 ✔
210
                try {
211
                        $count = min($this->jobs, count($this->queue));
1 ✔
212
                        $this->address = $address;
1 ✔
213
                        $this->pending = $this->warmFirst ? $count - 1 : 0;
1 ✔
214
                        for ($i = $count - $this->pending; $i > 0; $i--) {
1 ✔
215
                                $this->workers[] = $this->spawn($address);
1 ✔
216
                        }
217

218
                        while ($done < count($paths) || $this->isFinishing()) {
1 ✔
219
                                foreach ($this->await(watched: $onProgress !== null) as $stream) {
1 ✔
220
                                        foreach ($this->receive((int) $stream) as $path => $result) {
1 ✔
221
                                                $done++;
1 ✔
222
                                                yield $path => $result;
1 ✔
223
                                        }
224
                                }
225

226
                                $this->checkWorkers($done < count($paths));
1 ✔
227
                                if ($onProgress !== null) {
1 ✔
UNCOV
228
                                        $onProgress($done, $this->getInProgress());
×
229
                                }
230
                        }
231

232
                } finally {
1 ✔
233
                        foreach ($this->sockets as $socket) {
1 ✔
234
                                fclose($socket);
1 ✔
235
                        }
236

237
                        $this->closeServer();
1 ✔
238
                        $this->stop();
1 ✔
239
                }
240
        }
1 ✔
241

242

243
        /**
244
         * The files the results of the workers depend on beyond the configuration, as they sent them.
245
         * @return list<string>
246
         */
247
        public function getDependencies(): array
248
        {
249
                return array_keys($this->dependencies);
1 ✔
250
        }
251

252

253
        /**
254
         * What the analyses of the workers tell the user about the run, each thing once.
255
         * @return list<string>
256
         */
257
        public function getWarnings(): array
258
        {
259
                return array_keys($this->warnings);
1 ✔
260
        }
261

262

263
        /** @return string  the address the workers connect to */
264
        private function listen(): string
265
        {
266
                if (function_exists('socket_create')) {
1 ✔
267
                        $server = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
1 ✔
268
                        if (
269
                                $server === false
1 ✔
270
                                || !socket_bind($server, '127.0.0.1')
1 ✔
271
                                || !socket_listen($server, $this->jobs)
1 ✔
272
                                || !socket_getsockname($server, $ip, $port)
1 ✔
273
                        ) {
UNCOV
274
                                throw new \RuntimeException('Cannot start the worker server: ' . socket_strerror(socket_last_error()));
×
275
                        }
276

277
                        $this->server = $server;
1 ✔
278
                        return "$ip:$port";
1 ✔
279
                }
280

UNCOV
281
                $context = stream_context_create(['socket' => ['tcp_nodelay' => true]]); // Nagle would delay every small message by an ACK
×
UNCOV
282
                $server = @stream_socket_server('tcp://127.0.0.1:0', $errno, $error, context: $context); // @ is escalated to exception
×
UNCOV
283
                if ($server === false) {
×
UNCOV
284
                        throw new \RuntimeException("Cannot start the worker server: $error");
×
285
                }
286

287
                $this->server = $server;
×
288
                return (string) stream_socket_get_name($server, remote: false);
×
289
        }
290

291

292
        /**
293
         * Waits for messages from the workers, accepting the ones that connect meanwhile; the listening socket
294
         * from ext/sockets is closed as soon as the last worker is in.
295
         * @param  bool  $watched  the progress is drawn, so the wait is short
296
         * @return list<resource>  connections with a message waiting
297
         */
298
        private function await(bool $watched): array
299
        {
300
                $read = array_values($this->sockets);
1 ✔
301
                $write = $except = [];
1 ✔
302
                $seconds = $watched ? 0 : 1;
1 ✔
303
                $microseconds = $watched ? self::ProgressInterval : 0;
1 ✔
304
                $server = $this->server;
1 ✔
305
                if ($server instanceof \Socket) {
1 ✔
306
                        $this->acceptPending($server, blocking: $read === []);
1 ✔
307
                        if ($this->accepted === count($this->workers)) {
1 ✔
308
                                $this->closeServer();
1 ✔
309
                        } else { // short waits while workers may still be connecting
310
                                $seconds = 0;
1 ✔
311
                                $microseconds = 10_000;
1 ✔
312
                        }
313
                } elseif ($server !== null) {
1 ✔
UNCOV
314
                        $read[] = $server;
×
315
                }
316

317
                if ($read === []) { // nothing connected: the workers are still starting, or they are gone
1 ✔
318
                        return [];
1 ✔
319
                }
320

321
                if (@stream_select($read, $write, $except, $seconds, $microseconds) === false) { // @ is escalated to exception
1 ✔
UNCOV
322
                        throw new \RuntimeException('Waiting for the workers failed.');
×
323
                }
324

325
                $streams = [];
1 ✔
326
                foreach ($read as $stream) {
1 ✔
327
                        if ($stream === $server) {
1 ✔
UNCOV
328
                                $this->acceptStream($stream);
×
329
                        } else {
330
                                $streams[] = $stream;
1 ✔
331
                        }
332
                }
333

334
                return $streams;
1 ✔
335
        }
336

337

338
        /** Accepts every worker waiting to connect; with nothing to do otherwise, waits for the first one. */
339
        private function acceptPending(\Socket $server, bool $blocking): void
340
        {
341
                while (true) {
1 ✔
342
                        $read = [$server];
1 ✔
343
                        $write = $except = null;
1 ✔
344
                        if (socket_select($read, $write, $except, $blocking ? 1 : 0) !== 1) {
1 ✔
345
                                return;
1 ✔
346
                        }
347

348
                        $blocking = false;
1 ✔
349
                        $connection = socket_accept($server);
1 ✔
350
                        if ($connection === false) {
1 ✔
UNCOV
351
                                return;
×
352
                        }
353

354
                        socket_set_option($connection, SOL_TCP, TCP_NODELAY, 1); // Nagle would delay every small message by an ACK
1 ✔
355
                        $stream = socket_export_stream($connection);
1 ✔
356
                        if ($stream === false) {
1 ✔
UNCOV
357
                                throw new \RuntimeException('Cannot use the connection of a worker.');
×
358
                        }
359

360
                        $this->acceptConnection($stream);
1 ✔
361
                }
362
        }
×
363

364

365
        /** @param resource $server */
366
        private function acceptStream($server): void
367
        {
UNCOV
368
                $socket = @stream_socket_accept($server, 0); // @ a false alarm is harmless
×
UNCOV
369
                if ($socket !== false) {
×
UNCOV
370
                        $this->acceptConnection($socket);
×
371
                }
UNCOV
372
        }
×
373

374

375
        /**
376
         * Registers the connection, starts the workers that waited for it, and hands it a path. It is read without
377
         * blocking: a worker may have sent only a part of its line, and waiting for the rest would stop the parent from
378
         * hearing the others and from noticing a worker that is stuck.
379
         * @param resource $socket
380
         */
381
        private function acceptConnection($socket): void
382
        {
383
                stream_set_blocking($socket, enable: false);
1 ✔
384
                $this->accepted++;
1 ✔
385
                for (; $this->pending > 0; $this->pending--) {
1 ✔
386
                        $this->workers[] = $this->spawn($this->address);
1 ✔
387
                }
388

389
                $id = (int) $socket;
1 ✔
390
                $this->sockets[$id] = $socket;
1 ✔
391
                $this->assign($id);
1 ✔
392
        }
1 ✔
393

394

395
        private function closeServer(): void
396
        {
397
                if ($this->server instanceof \Socket) {
1 ✔
398
                        socket_close($this->server);
1 ✔
399
                } elseif ($this->server !== null) {
1 ✔
UNCOV
400
                        fclose($this->server);
×
401
                }
402

403
                $this->server = null;
1 ✔
404
        }
1 ✔
405

406

407
        /**
408
         * The results the worker has finished sending, by path: every line answers the path in progress, and a line
409
         * about any other one is a failure, as is an ended worker with a path in progress.
410
         * @return array<string, FileResult>
411
         */
412
        private function receive(int $id): array
413
        {
414
                $socket = $this->sockets[$id] ?? null;
1 ✔
415
                if ($socket === null) {
1 ✔
UNCOV
416
                        return [];
×
417
                }
418

419
                $chunk = fread($socket, 1 << 20);
1 ✔
420
                if ($chunk === false || ($chunk === '' && feof($socket))) {
1 ✔
421
                        if (isset($this->inProgress[$id])) {
1 ✔
422
                                $end = $this->findWorkerFailure();
1 ✔
423
                                throw new \RuntimeException('A worker ended ' . ($end === null ? '' : "$end ") . "while processing `{$this->inProgress[$id][0]}`." . $this->collectErrors());
1 ✔
424
                        }
425

UNCOV
426
                        $this->disconnect($id);
×
UNCOV
427
                        return [];
×
428
                }
429

430
                $buffer = ($this->buffers[$id] ?? '') . $chunk;
1 ✔
431
                $results = [];
1 ✔
432
                while (($end = strpos($buffer, "\n")) !== false) {
1 ✔
433
                        $data = json_decode(substr($buffer, 0, $end), associative: true);
1 ✔
434
                        $buffer = substr($buffer, $end + 1);
1 ✔
435
                        if (isset($this->finishing[$id]) && is_array($data['profile'] ?? null)) {
1 ✔
436
                                $this->profiler?->merge($data['profile']);
1 ✔
437
                                $this->disconnect($id);
1 ✔
438
                                break;
1 ✔
439
                        }
440

441
                        [$path, , $code] = $this->inProgress[$id] ?? [null, null, ''];
1 ✔
442
                        if (!is_array($data) || $path === null || ($data['path'] ?? null) !== base64_encode($path)) {
1 ✔
443
                                throw new \RuntimeException('A worker sent an unexpected message.' . $this->collectErrors());
1 ✔
444
                        }
445

446
                        unset($this->inProgress[$id]);
1 ✔
447
                        foreach (is_array($data['dependencies'] ?? null) ? $data['dependencies'] : [] as $file) {
1 ✔
448
                                $this->dependencies[(string) $file] = true;
1 ✔
449
                        }
450

451
                        foreach (is_array($data['runWarnings'] ?? null) ? $data['runWarnings'] : [] as $warning) {
1 ✔
452
                                $this->warnings[(string) $warning] = true;
1 ✔
453
                        }
454

455
                        [$results[$path], $profile] = WorkerCodec::decode($data, $code);
1 ✔
456
                        if ($profile !== null) {
1 ✔
457
                                $this->profiler?->merge($profile);
1 ✔
458
                        }
459

460
                        $this->assign($id);
1 ✔
461
                }
462

463
                if (isset($this->sockets[$id]) && strlen($buffer)) {
1 ✔
464
                        $this->buffers[$id] = $buffer;
1 ✔
465
                } else {
466
                        unset($this->buffers[$id]);
1 ✔
467
                }
468

469
                return $results;
1 ✔
470
        }
471

472

473
        /** Hands the next path to the worker; when there is none, asks it for what it measured last, or closes its connection. */
474
        private function assign(int $id): void
475
        {
476
                $path = array_shift($this->queue);
1 ✔
477
                if ($path === null && $this->profiler !== null) {
1 ✔
478
                        $this->finishing[$id] = true;
1 ✔
479
                        fwrite($this->sockets[$id], json_encode(['finish' => true], JSON_THROW_ON_ERROR) . "\n");
1 ✔
480
                        return;
1 ✔
481
                } elseif ($path === null) {
1 ✔
482
                        $this->disconnect($id);
1 ✔
483
                        return;
1 ✔
484
                }
485

486
                $read = $this->read ?? throw new \LogicException('No run is in progress.');
1 ✔
487
                $this->inProgress[$id] = [$path, microtime(as_float: true), $read($path)];
1 ✔
488
                fwrite($this->sockets[$id], json_encode(['path' => base64_encode($path)], JSON_THROW_ON_ERROR) . "\n"); // a path need not be UTF-8
1 ✔
489
        }
1 ✔
490

491

492
        /** @return array<string, float>  path in progress => the time it started */
493
        private function getInProgress(): array
494
        {
UNCOV
495
                $paths = [];
×
UNCOV
496
                foreach ($this->inProgress as [$path, $since]) {
×
UNCOV
497
                        $paths[$path] = $since;
×
498
                }
499

UNCOV
500
                return $paths;
×
501
        }
502

503

504
        private function disconnect(int $id): void
505
        {
506
                fclose($this->sockets[$id]);
1 ✔
507
                unset($this->sockets[$id], $this->inProgress[$id], $this->buffers[$id], $this->finishing[$id]);
1 ✔
508
        }
1 ✔
509

510

511
        /**
512
         * Whether the run still waits for what the workers measured last: from one asked for it, and from one still
513
         * starting, which gets nothing to process but has its peak memory.
514
         */
515
        private function isFinishing(): bool
516
        {
517
                if ($this->profiler === null) {
1 ✔
518
                        return false;
1 ✔
519
                } elseif ($this->finishing !== []) {
1 ✔
520
                        return true;
1 ✔
521
                }
522

523
                // which process a connection belongs to is unknown, so a worker done with its work is waited for too, until it exits
524
                return $this->accepted < count($this->workers)
1 ✔
525
                        && array_any($this->workers, fn(array $worker) => proc_get_status($worker[0])['running']);
1 ✔
526
        }
527

528

529
        /** @return array{resource, string}  process, file with its output */
530
        private function spawn(string $address): array
531
        {
532
                $output = (string) tempnam(sys_get_temp_dir(), 'dresscode-worker-');
1 ✔
533
                $process = @proc_open( // @ is escalated to exception
1 ✔
534
                        [...$this->command, '--worker', $address],
1 ✔
535
                        [0 => ['pipe', 'r'], 1 => ['file', $output, 'a'], 2 => ['file', $output, 'a']],
1 ✔
536
                        $pipes,
537
                        $this->cwd,
1 ✔
538
                );
539
                if ($process === false) {
1 ✔
UNCOV
540
                        throw new \RuntimeException('Cannot start a worker process: `' . implode(' ', $this->command) . '`');
×
541
                }
542

543
                fclose($pipes[0]);
1 ✔
544
                $this->spawnedAt = microtime(as_float: true);
1 ✔
545
                return [$process, $output];
1 ✔
546
        }
547

548

549
        /**
550
         * A worker that exited with an error, one that has spent longer than the timeout on a file, a worker the run waits
551
         * for that has not connected within its timeout, or every worker gone while results are missing fails the run.
552
         */
553
        private function checkWorkers(bool $resultsMissing): void
554
        {
555
                $running = false;
1 ✔
556
                foreach ($this->workers as [$process]) {
1 ✔
557
                        $status = proc_get_status($process);
1 ✔
558
                        if ($status['running']) {
1 ✔
559
                                $running = true;
1 ✔
560
                        } elseif ($status['exitcode'] !== 0) {
1 ✔
561
                                throw new \RuntimeException('A worker ended ' . self::formatEnd($status) . '.' . $this->collectErrors());
1 ✔
562
                        }
563
                }
564

565
                foreach ($this->inProgress as [$path, $since]) {
1 ✔
566
                        if (microtime(as_float: true) - $since > $this->taskTimeout) {
1 ✔
567
                                throw new \RuntimeException("A worker has spent more than $this->taskTimeout s on `$path`; a rule has most likely looped." . $this->collectErrors());
1 ✔
568
                        }
569
                }
570

571
                if (
572
                        $this->sockets === []
1 ✔
573
                        && $this->accepted < count($this->workers)
1 ✔
574
                        && microtime(as_float: true) - $this->spawnedAt > $this->connectTimeout
1 ✔
575
                ) {
576
                        throw new \RuntimeException("A worker has not connected within $this->connectTimeout s." . $this->collectErrors());
1 ✔
577
                }
578

579
                if (!$running && $resultsMissing) {
1 ✔
UNCOV
580
                        throw new \RuntimeException('The workers ended before processing every file.' . $this->collectErrors());
×
581
                }
582
        }
1 ✔
583

584

585
        /**
586
         * How a worker that failed ended, given a moment to end, because its connection closes before its process is gone;
587
         * null where none has failed.
588
         */
589
        private function findWorkerFailure(): ?string
590
        {
591
                $deadline = microtime(as_float: true) + self::EndTimeout;
1 ✔
592
                do {
593
                        foreach ($this->workers as [$process]) {
1 ✔
594
                                $status = proc_get_status($process);
1 ✔
595
                                if (!$status['running'] && $status['exitcode'] !== 0) {
1 ✔
596
                                        return self::formatEnd($status);
1 ✔
597
                                }
598
                        }
599

600
                        usleep(10_000);
1 ✔
601
                } while (microtime(as_float: true) < $deadline);
1 ✔
602

UNCOV
603
                return null;
×
604
        }
605

606

607
        /**
608
         * How a process ended, for a message: its exit code, one of Windows in the form it is known by (`0xC0000005` for a
609
         * crash of PHP itself), or the signal that ended it.
610
         * @param  array{signaled: bool, termsig: int, exitcode: int}  $status
611
         */
612
        private static function formatEnd(array $status): string
613
        {
614
                $code = $status['exitcode'];
1 ✔
615
                return match (true) {
616
                        $status['signaled'] => "on signal {$status['termsig']}",
1 ✔
617
                        PHP_OS_FAMILY === 'Windows' && ($code < 0 || $code > 0xFFFF) => sprintf('with code 0x%08X', $code & 0xFFFFFFFF),
1 ✔
618
                        default => "with code $code",
1 ✔
619
                };
620
        }
621

622

623
        private function collectErrors(): string
624
        {
625
                $errors = '';
1 ✔
626
                foreach ($this->workers as [, $output]) {
1 ✔
627
                        $errors .= trim((string) @file_get_contents($output)); // @ file may have been deleted meanwhile
1 ✔
628
                }
629

630
                return $errors === '' ? '' : "\n$errors";
1 ✔
631
        }
632

633

634
        private function stop(): void
635
        {
636
                foreach ($this->workers as [$process, $output]) {
1 ✔
637
                        if (proc_get_status($process)['running']) {
1 ✔
638
                                proc_terminate($process);
1 ✔
639
                        }
640

641
                        proc_close($process);
1 ✔
642
                        @unlink($output); // @ file may have been deleted meanwhile
1 ✔
643
                }
644

645
                $this->workers = $this->sockets = $this->inProgress = $this->buffers = [];
1 ✔
646
                $this->accepted = $this->pending = 0;
1 ✔
647
                $this->read = null;
1 ✔
648
        }
1 ✔
649
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc