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

dg / dresscode / 41360495725

01 Nov 2026 10:58PM UTC coverage: 96.734%. Remained the same
41360495725

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%)

75 existing lines in 10 files now uncovered.

29297 of 30286 relevant lines covered (96.73%)

0.97 hits per line

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

84.52
/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
        /**
27
         * The listening socket: from ext/sockets when available, because the stream layer on Windows waits 500 ms
28
         * for a socket to become writable before closing it, which a listening one never does.
29
         * @var \Socket|resource|null
30
         */
31
        private mixed $server = null;
32

33
        /** @var array<int, resource>  connected workers by socket id */
34
        private array $sockets = [];
35

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

39
        /** workers that have connected so far */
40
        private int $accepted = 0;
41

42
        /** workers started once the first has connected */
43
        private int $pending = 0;
44

45
        /** the address the workers connect to */
46
        private string $address = '';
47

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

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

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

57
        /** when the last worker was started */
58
        private float $spawnedAt = 0;
59

60
        /** @var list<string> */
61
        private array $queue = [];
62

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

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

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

72

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

90

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

100

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

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

113
                return max(1, $count);
1 ✔
114
        }
115

116

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

126

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

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

144

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

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

156

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

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

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

188
                return $options;
1 ✔
189
        }
190

191

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

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

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

229
                } finally {
1 ✔
230
                        foreach ($this->sockets as $socket) {
1 ✔
231
                                fclose($socket);
1 ✔
232
                        }
233

234
                        $this->closeServer();
1 ✔
235
                        $this->stop();
1 ✔
236
                }
237
        }
1 ✔
238

239

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

249

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

259

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

274
                        $this->server = $server;
1 ✔
275
                        return "$ip:$port";
1 ✔
276
                }
277

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

284
                $this->server = $server;
×
285
                return (string) stream_socket_get_name($server, remote: false);
×
286
        }
287

288

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

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

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

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

331
                return $streams;
1 ✔
332
        }
333

334

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

345
                        $blocking = false;
1 ✔
346
                        $connection = socket_accept($server);
1 ✔
347
                        if ($connection === false) {
1 ✔
UNCOV
348
                                return;
×
349
                        }
350

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

357
                        $this->acceptConnection($stream);
1 ✔
358
                }
359
        }
×
360

361

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

371

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

386
                $id = (int) $socket;
1 ✔
387
                $this->sockets[$id] = $socket;
1 ✔
388
                $this->assign($id);
1 ✔
389
        }
1 ✔
390

391

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

400
                $this->server = null;
1 ✔
401
        }
1 ✔
402

403

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

416
                $chunk = fread($socket, 1 << 20);
1 ✔
417
                if ($chunk === false || ($chunk === '' && feof($socket))) {
1 ✔
418
                        if (isset($this->inProgress[$id])) {
×
UNCOV
419
                                throw new \RuntimeException("A worker ended while processing `{$this->inProgress[$id][0]}`." . $this->collectErrors());
×
420
                        }
421

UNCOV
422
                        $this->disconnect($id);
×
423
                        return [];
×
424
                }
425

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

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

442
                        unset($this->inProgress[$id]);
1 ✔
443
                        foreach (is_array($data['dependencies'] ?? null) ? $data['dependencies'] : [] as $file) {
1 ✔
444
                                $this->dependencies[(string) $file] = true;
1 ✔
445
                        }
446

447
                        foreach (is_array($data['runWarnings'] ?? null) ? $data['runWarnings'] : [] as $warning) {
1 ✔
448
                                $this->warnings[(string) $warning] = true;
1 ✔
449
                        }
450

451
                        [$results[$path], $profile] = WorkerCodec::decode($data, $code);
1 ✔
452
                        if ($profile !== null) {
1 ✔
453
                                $this->profiler?->merge($profile);
1 ✔
454
                        }
455

456
                        $this->assign($id);
1 ✔
457
                }
458

459
                if (isset($this->sockets[$id]) && strlen($buffer)) {
1 ✔
460
                        $this->buffers[$id] = $buffer;
1 ✔
461
                } else {
462
                        unset($this->buffers[$id]);
1 ✔
463
                }
464

465
                return $results;
1 ✔
466
        }
467

468

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

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

487

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

UNCOV
496
                return $paths;
×
497
        }
498

499

500
        private function disconnect(int $id): void
501
        {
502
                fclose($this->sockets[$id]);
1 ✔
503
                unset($this->sockets[$id], $this->inProgress[$id], $this->buffers[$id], $this->finishing[$id]);
1 ✔
504
        }
1 ✔
505

506

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

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

524

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

539
                fclose($pipes[0]);
1 ✔
540
                $this->spawnedAt = microtime(as_float: true);
1 ✔
541
                return [$process, $output];
1 ✔
542
        }
543

544

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

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

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

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

580

581
        private function collectErrors(): string
582
        {
583
                $errors = '';
1 ✔
584
                foreach ($this->workers as [, $output]) {
1 ✔
585
                        $errors .= trim((string) @file_get_contents($output)); // @ file may have been deleted meanwhile
1 ✔
586
                }
587

588
                return $errors === '' ? '' : "\n$errors";
1 ✔
589
        }
590

591

592
        private function stop(): void
593
        {
594
                foreach ($this->workers as [$process, $output]) {
1 ✔
595
                        if (proc_get_status($process)['running']) {
1 ✔
596
                                proc_terminate($process);
1 ✔
597
                        }
598

599
                        proc_close($process);
1 ✔
600
                        @unlink($output); // @ file may have been deleted meanwhile
1 ✔
601
                }
602

603
                $this->workers = $this->sockets = $this->inProgress = $this->buffers = [];
1 ✔
604
                $this->accepted = $this->pending = 0;
1 ✔
605
                $this->read = null;
1 ✔
606
        }
1 ✔
607
}
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