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

dg / dresscode / 42040857956

05 Nov 2026 12:36PM UTC coverage: 97.783% (+0.7%) from 97.051%
42040857956

push

github

dg
PhpStan: the types take the extensions of the project

The extensions were those phpstan/extension-installer registered in the installation DressCode runs from, so the types
depended on how DressCode was installed. A global one saw none, and reported a null from preg_replace() that the PHPStan
of a project with nette/phpstan-rules does not see, where the fix it offers fails that PHPStan; one made by
composer create-project brought its own nette/phpstan-rules into every project.

Now they are what the installer of the project includes, read from its installed.json, and only the classes of the
extensions are loaded from its vendor, the process keeping the packages of its own installation. This also lets an
extension that phpstan.neon includes by a path into vendor start.

1a3eaac4-d0da-4312-8c24-b7fb27c7b977

34 of 34 new or added lines in 3 files covered. (100.0%)

188 existing lines in 44 files now uncovered.

23290 of 23818 relevant lines covered (97.78%)

0.98 hits per line

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

85.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, 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
        /** seconds the end of a worker is waited for once its connection has closed */
24
        private const EndTimeout = 1;
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<string, true>  the files the results depend on, as the workers sent them */
64
        private array $dependencies = [];
65

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

69

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

85

86
        /** Processors the machine has, 1 when unknown. */
87
        public static function detectCpuCount(): int
88
        {
89
                $count = (int) getenv('NUMBER_OF_PROCESSORS');
1 ✔
90
                if ($count < 1 && is_readable('/proc/cpuinfo')) {
1 ✔
91
                        $count = preg_match_all('~^processor\s*:~m', (string) file_get_contents('/proc/cpuinfo'));
1 ✔
92
                }
93

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

98
                return max(1, $count);
1 ✔
99
        }
100

101

102
        /**
103
         * The PHP a process of DressCode is started with: the same binary with the same ini file, the binary alone loading the
104
         * default one, and the settings the process has beyond it; null where no CLI binary is found to start one.
105
         * @return ?list<string>
106
         */
107
        public static function buildPhpCommand(): ?array
108
        {
109
                $binary = self::findCliBinary();
1 ✔
110
                if ($binary === null) {
1 ✔
UNCOV
111
                        return null;
×
112
                }
113

114
                $ini = php_ini_loaded_file();
1 ✔
115
                $php = [$binary, ...($ini === false ? (php_ini_scanned_files() === false ? ['-n'] : []) : ['-c', $ini])];
1 ✔
116
                return [...$php, ...self::findIniOverrides($php)];
1 ✔
117
        }
118

119

120
        /**
121
         * The PHP a worker is started with, on Windows without OPcache: the workers share its memory there, and PHP with JIT
122
         * crashes once they fill it.
123
         * @return ?list<string>
124
         */
125
        public static function buildWorkerPhpCommand(): ?array
126
        {
127
                $php = self::buildPhpCommand();
1 ✔
128
                return $php === null || PHP_OS_FAMILY !== 'Windows' ? $php : [...$php, '-d', 'opcache.enable_cli=0'];
1 ✔
129
        }
130

131

132
        /** The binary of the process, or under another SAPI than CLI, such as CGI, the CLI binary beside it. */
133
        private static function findCliBinary(): ?string
134
        {
135
                if (PHP_SAPI === 'cli') {
1 ✔
136
                        return PHP_BINARY;
1 ✔
137
                }
138

UNCOV
139
                $path = dirname(PHP_BINARY) . '/php' . (PHP_OS_FAMILY === 'Windows' ? '.exe' : '');
×
UNCOV
140
                return is_file($path) ? $path : null;
×
141
        }
142

143

144
        /**
145
         * The settings the process has and the PHP of the command alone would not, those given by -d above all, as the
146
         * options -d that give them to a worker; PHP tells no process the options it started with, so the PHP of the
147
         * command is asked for its settings and they are compared.
148
         * @param  list<string>  $php
149
         * @return list<string>
150
         */
151
        private static function findIniOverrides(array $php): array
152
        {
153
                $null = PHP_OS_FAMILY === 'Windows' ? 'NUL' : '/dev/null';
1 ✔
154
                $process = @proc_open([...$php, '-r', 'echo serialize(ini_get_all(null, false));'], [1 => ['pipe', 'w'], 2 => ['file', $null, 'w']], $pipes); // @ no settings then
1 ✔
155
                if ($process === false) {
1 ✔
UNCOV
156
                        return [];
×
157
                }
158

159
                $base = @unserialize((string) stream_get_contents($pipes[1])); // @ a PHP that failed to start gives none
1 ✔
160
                fclose($pipes[1]);
1 ✔
161
                proc_close($process);
1 ✔
162
                $own = ini_get_all(details: false);
1 ✔
163
                if (!is_array($base) || $own === false) {
1 ✔
UNCOV
164
                        return [];
×
165
                }
166

167
                $options = [];
1 ✔
168
                foreach ($own as $name => $value) {
1 ✔
169
                        if (array_key_exists($name, $base) && $base[$name] !== $value) {
1 ✔
170
                                $options[] = '-d';
1 ✔
171
                                $options[] = "$name=$value";
1 ✔
172
                        }
173
                }
174

175
                return $options;
1 ✔
176
        }
177

178

179
        /**
180
         * The results by path, each as soon as it arrives; the content of a file is read when it is handed out, so that
181
         * only the files in progress are held.
182
         * @param  list<string>  $paths
183
         * @param  \Closure(string): string  $read  path => content
184
         * @param  ?\Closure(int, array<string, float>): void  $onProgress  files done and the paths in progress
185
         * @return \Generator<string, FileResult>
186
         * @throws \RuntimeException  when a worker fails
187
         */
188
        public function process(array $paths, \Closure $read, ?\Closure $onProgress = null): \Generator
1 ✔
189
        {
190
                $address = $this->listen();
1 ✔
191
                $this->queue = $paths;
1 ✔
192
                $this->read = $read;
1 ✔
193
                $done = 0;
1 ✔
194
                try {
195
                        $count = min($this->jobs, count($this->queue));
1 ✔
196
                        $this->address = $address;
1 ✔
197
                        $this->pending = $this->warmFirst ? $count - 1 : 0;
1 ✔
198
                        for ($i = $count - $this->pending; $i > 0; $i--) {
1 ✔
199
                                $this->workers[] = $this->spawn($address);
1 ✔
200
                        }
201

202
                        while ($done < count($paths)) {
1 ✔
203
                                foreach ($this->await() as $stream) {
1 ✔
204
                                        foreach ($this->receive((int) $stream) as $path => $result) {
1 ✔
205
                                                $done++;
1 ✔
206
                                                yield $path => $result;
1 ✔
207
                                        }
208
                                }
209

210
                                $this->checkWorkers($done < count($paths));
1 ✔
211
                                if ($onProgress !== null) {
1 ✔
UNCOV
212
                                        $onProgress($done, $this->getInProgress());
×
213
                                }
214
                        }
215

216
                } finally {
1 ✔
217
                        foreach ($this->sockets as $socket) {
1 ✔
218
                                fclose($socket);
1 ✔
219
                        }
220

221
                        $this->closeServer();
1 ✔
222
                        $this->stop();
1 ✔
223
                }
224
        }
1 ✔
225

226

227
        /**
228
         * The files the results of the workers depend on beyond the configuration, as they sent them.
229
         * @return list<string>
230
         */
231
        public function getDependencies(): array
232
        {
233
                return array_keys($this->dependencies);
1 ✔
234
        }
235

236

237
        /**
238
         * What the analyses of the workers tell the user about the run, each thing once.
239
         * @return list<string>
240
         */
241
        public function getWarnings(): array
242
        {
243
                return array_keys($this->warnings);
1 ✔
244
        }
245

246

247
        /** @return string  the address the workers connect to */
248
        private function listen(): string
249
        {
250
                if (function_exists('socket_create')) {
1 ✔
251
                        $server = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
1 ✔
252
                        if (
253
                                $server === false
1 ✔
254
                                || !socket_bind($server, '127.0.0.1')
1 ✔
255
                                || !socket_listen($server, $this->jobs)
1 ✔
256
                                || !socket_getsockname($server, $ip, $port)
1 ✔
257
                        ) {
UNCOV
258
                                throw new \RuntimeException('Cannot start the worker server: ' . socket_strerror(socket_last_error()));
×
259
                        }
260

261
                        $this->server = $server;
1 ✔
262
                        return "$ip:$port";
1 ✔
263
                }
264

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

271
                $this->server = $server;
×
UNCOV
272
                return (string) stream_socket_get_name($server, remote: false);
×
273
        }
274

275

276
        /**
277
         * Waits for messages from the workers, accepting the ones that connect meanwhile; the listening socket
278
         * from ext/sockets is closed as soon as the last worker is in.
279
         * @return list<resource>  connections with a message waiting
280
         */
281
        private function await(): array
282
        {
283
                $read = array_values($this->sockets);
1 ✔
284
                $write = $except = [];
1 ✔
285
                $seconds = 1;
1 ✔
286
                $microseconds = 0;
1 ✔
287
                $server = $this->server;
1 ✔
288
                if ($server instanceof \Socket) {
1 ✔
289
                        $this->acceptPending($server, blocking: $read === []);
1 ✔
290
                        if ($this->accepted === count($this->workers)) {
1 ✔
291
                                $this->closeServer();
1 ✔
292
                        } else { // short waits while workers may still be connecting
293
                                $seconds = 0;
1 ✔
294
                                $microseconds = 10_000;
1 ✔
295
                        }
296
                } elseif ($server !== null) {
1 ✔
UNCOV
297
                        $read[] = $server;
×
298
                }
299

300
                if ($read === []) { // nothing connected: the workers are still starting, or they are gone
1 ✔
301
                        return [];
1 ✔
302
                }
303

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

308
                $streams = [];
1 ✔
309
                foreach ($read as $stream) {
1 ✔
310
                        if ($stream === $server) {
1 ✔
311
                                $this->acceptStream($stream);
×
312
                        } else {
313
                                $streams[] = $stream;
1 ✔
314
                        }
315
                }
316

317
                return $streams;
1 ✔
318
        }
319

320

321
        /** Accepts every worker waiting to connect; with nothing to do otherwise, waits for the first one. */
322
        private function acceptPending(\Socket $server, bool $blocking): void
323
        {
324
                while (true) {
1 ✔
325
                        $read = [$server];
1 ✔
326
                        $write = $except = null;
1 ✔
327
                        if (socket_select($read, $write, $except, $blocking ? 1 : 0) !== 1) {
1 ✔
328
                                return;
1 ✔
329
                        }
330

331
                        $blocking = false;
1 ✔
332
                        $connection = socket_accept($server);
1 ✔
333
                        if ($connection === false) {
1 ✔
UNCOV
334
                                return;
×
335
                        }
336

337
                        socket_set_option($connection, SOL_TCP, TCP_NODELAY, 1); // Nagle would delay every small message by an ACK
1 ✔
338
                        $stream = socket_export_stream($connection);
1 ✔
339
                        if ($stream === false) {
1 ✔
UNCOV
340
                                throw new \RuntimeException('Cannot use the connection of a worker.');
×
341
                        }
342

343
                        $this->acceptConnection($stream);
1 ✔
344
                }
UNCOV
345
        }
×
346

347

348
        /** @param resource $server */
349
        private function acceptStream($server): void
350
        {
UNCOV
351
                $socket = @stream_socket_accept($server, 0); // @ a false alarm is harmless
×
UNCOV
352
                if ($socket !== false) {
×
UNCOV
353
                        $this->acceptConnection($socket);
×
354
                }
UNCOV
355
        }
×
356

357

358
        /**
359
         * Registers the connection, starts the workers that waited for it, and hands it a path. It is read without
360
         * blocking: a worker may have sent only a part of its line, and waiting for the rest would stop the parent from
361
         * hearing the others and from noticing a worker that is stuck.
362
         * @param resource $socket
363
         */
364
        private function acceptConnection($socket): void
365
        {
366
                stream_set_blocking($socket, enable: false);
1 ✔
367
                $this->accepted++;
1 ✔
368
                for (; $this->pending > 0; $this->pending--) {
1 ✔
369
                        $this->workers[] = $this->spawn($this->address);
1 ✔
370
                }
371

372
                $id = (int) $socket;
1 ✔
373
                $this->sockets[$id] = $socket;
1 ✔
374
                $this->assign($id);
1 ✔
375
        }
1 ✔
376

377

378
        private function closeServer(): void
379
        {
380
                if ($this->server instanceof \Socket) {
1 ✔
381
                        socket_close($this->server);
1 ✔
382
                } elseif ($this->server !== null) {
1 ✔
UNCOV
383
                        fclose($this->server);
×
384
                }
385

386
                $this->server = null;
1 ✔
387
        }
1 ✔
388

389

390
        /**
391
         * The results the worker has finished sending, by path: every line answers the path in progress, and a line
392
         * about any other one is a failure, as is an ended worker with a path in progress.
393
         * @return array<string, FileResult>
394
         */
395
        private function receive(int $id): array
396
        {
397
                $socket = $this->sockets[$id] ?? null;
1 ✔
398
                if ($socket === null) {
1 ✔
UNCOV
399
                        return [];
×
400
                }
401

402
                $chunk = fread($socket, 1 << 20);
1 ✔
403
                if ($chunk === false || ($chunk === '' && feof($socket))) {
1 ✔
404
                        if (isset($this->inProgress[$id])) {
1 ✔
405
                                $end = $this->findWorkerFailure();
1 ✔
406
                                throw new \RuntimeException('A worker ended ' . ($end === null ? '' : "$end ") . "while processing `{$this->inProgress[$id][0]}`." . $this->collectErrors());
1 ✔
407
                        }
408

UNCOV
409
                        $this->disconnect($id);
×
UNCOV
410
                        return [];
×
411
                }
412

413
                $buffer = ($this->buffers[$id] ?? '') . $chunk;
1 ✔
414
                $results = [];
1 ✔
415
                while (($end = strpos($buffer, "\n")) !== false) {
1 ✔
416
                        $data = json_decode(substr($buffer, 0, $end), associative: true);
1 ✔
417
                        $buffer = substr($buffer, $end + 1);
1 ✔
418
                        [$path, , $code] = $this->inProgress[$id] ?? [null, null, ''];
1 ✔
419
                        if (!is_array($data) || $path === null || ($data['path'] ?? null) !== base64_encode($path)) {
1 ✔
420
                                throw new \RuntimeException('A worker sent an unexpected message.' . $this->collectErrors());
1 ✔
421
                        }
422

423
                        unset($this->inProgress[$id]);
1 ✔
424
                        foreach (is_array($data['dependencies'] ?? null) ? $data['dependencies'] : [] as $file) {
1 ✔
425
                                $this->dependencies[(string) $file] = true;
1 ✔
426
                        }
427

428
                        foreach (is_array($data['runWarnings'] ?? null) ? $data['runWarnings'] : [] as $warning) {
1 ✔
429
                                $this->warnings[(string) $warning] = true;
1 ✔
430
                        }
431

432
                        $results[$path] = WorkerCodec::decode($data, $code);
1 ✔
433
                        $this->assign($id);
1 ✔
434
                }
435

436
                if (isset($this->sockets[$id]) && strlen($buffer)) {
1 ✔
437
                        $this->buffers[$id] = $buffer;
1 ✔
438
                } else {
439
                        unset($this->buffers[$id]);
1 ✔
440
                }
441

442
                return $results;
1 ✔
443
        }
444

445

446
        /** Hands the next path to the worker, or closes its connection when there is none. */
447
        private function assign(int $id): void
448
        {
449
                $path = array_shift($this->queue);
1 ✔
450
                if ($path === null) {
1 ✔
451
                        $this->disconnect($id);
1 ✔
452
                        return;
1 ✔
453
                }
454

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

460

461
        /** @return array<string, float>  path in progress => the time it started */
462
        private function getInProgress(): array
463
        {
UNCOV
464
                $paths = [];
×
UNCOV
465
                foreach ($this->inProgress as [$path, $since]) {
×
UNCOV
466
                        $paths[$path] = $since;
×
467
                }
468

UNCOV
469
                return $paths;
×
470
        }
471

472

473
        private function disconnect(int $id): void
474
        {
475
                fclose($this->sockets[$id]);
1 ✔
476
                unset($this->sockets[$id], $this->inProgress[$id], $this->buffers[$id]);
1 ✔
477
        }
1 ✔
478

479

480
        /** @return array{resource, string}  process, file with its output */
481
        private function spawn(string $address): array
482
        {
483
                $output = (string) tempnam(sys_get_temp_dir(), 'dresscode-worker-');
1 ✔
484
                $process = @proc_open( // @ is escalated to exception
1 ✔
485
                        [...$this->command, '--worker', $address],
1 ✔
486
                        [0 => ['pipe', 'r'], 1 => ['file', $output, 'a'], 2 => ['file', $output, 'a']],
1 ✔
487
                        $pipes,
488
                        $this->cwd,
1 ✔
489
                );
490
                if ($process === false) {
1 ✔
491
                        throw new \RuntimeException('Cannot start a worker process: `' . implode(' ', $this->command) . '`');
×
492
                }
493

494
                fclose($pipes[0]);
1 ✔
495
                $this->spawnedAt = microtime(as_float: true);
1 ✔
496
                return [$process, $output];
1 ✔
497
        }
498

499

500
        /**
501
         * A worker that exited with an error, one that has spent longer than the timeout on a file, a worker the run waits
502
         * for that has not connected within its timeout, or every worker gone while results are missing fails the run.
503
         */
504
        private function checkWorkers(bool $resultsMissing): void
505
        {
506
                $running = false;
1 ✔
507
                foreach ($this->workers as [$process]) {
1 ✔
508
                        $status = proc_get_status($process);
1 ✔
509
                        if ($status['running']) {
1 ✔
510
                                $running = true;
1 ✔
511
                        } elseif ($status['exitcode'] !== 0) {
1 ✔
512
                                throw new \RuntimeException('A worker ended ' . self::formatEnd($status) . '.' . $this->collectErrors());
1 ✔
513
                        }
514
                }
515

516
                foreach ($this->inProgress as [$path, $since]) {
1 ✔
517
                        if (microtime(as_float: true) - $since > $this->taskTimeout) {
1 ✔
518
                                throw new \RuntimeException("A worker has spent more than $this->taskTimeout s on `$path`; a rule has most likely looped." . $this->collectErrors());
1 ✔
519
                        }
520
                }
521

522
                if (
523
                        $this->sockets === []
1 ✔
524
                        && $this->accepted < count($this->workers)
1 ✔
525
                        && microtime(as_float: true) - $this->spawnedAt > $this->connectTimeout
1 ✔
526
                ) {
527
                        throw new \RuntimeException("A worker has not connected within $this->connectTimeout s." . $this->collectErrors());
1 ✔
528
                }
529

530
                if (!$running && $resultsMissing) {
1 ✔
UNCOV
531
                        throw new \RuntimeException('The workers ended before processing every file.' . $this->collectErrors());
×
532
                }
533
        }
1 ✔
534

535

536
        /**
537
         * How a worker that failed ended, given a moment to end, because its connection closes before its process is gone;
538
         * null where none has failed.
539
         */
540
        private function findWorkerFailure(): ?string
541
        {
542
                $deadline = microtime(as_float: true) + self::EndTimeout;
1 ✔
543
                do {
544
                        foreach ($this->workers as [$process]) {
1 ✔
545
                                $status = proc_get_status($process);
1 ✔
546
                                if (!$status['running'] && $status['exitcode'] !== 0) {
1 ✔
547
                                        return self::formatEnd($status);
1 ✔
548
                                }
549
                        }
550

551
                        usleep(10_000);
1 ✔
552
                } while (microtime(as_float: true) < $deadline);
1 ✔
553

UNCOV
554
                return null;
×
555
        }
556

557

558
        /**
559
         * How a process ended, for a message: its exit code, one of Windows in the form it is known by (`0xC0000005` for a
560
         * crash of PHP itself), or the signal that ended it.
561
         * @param  array{signaled: bool, termsig: int, exitcode: int}  $status
562
         */
563
        private static function formatEnd(array $status): string
564
        {
565
                $code = $status['exitcode'];
1 ✔
566
                return match (true) {
567
                        $status['signaled'] => "on signal {$status['termsig']}",
1 ✔
568
                        PHP_OS_FAMILY === 'Windows' && ($code < 0 || $code > 0xFFFF) => sprintf('with code 0x%08X', $code & 0xFFFFFFFF),
1 ✔
569
                        default => "with code $code",
1 ✔
570
                };
571
        }
572

573

574
        private function collectErrors(): string
575
        {
576
                $errors = '';
1 ✔
577
                foreach ($this->workers as [, $output]) {
1 ✔
578
                        $errors .= trim((string) @file_get_contents($output)); // @ file may have been deleted meanwhile
1 ✔
579
                }
580

581
                return $errors === '' ? '' : "\n$errors";
1 ✔
582
        }
583

584

585
        private function stop(): void
586
        {
587
                foreach ($this->workers as [$process, $output]) {
1 ✔
588
                        if (proc_get_status($process)['running']) {
1 ✔
589
                                proc_terminate($process);
1 ✔
590
                        }
591

592
                        proc_close($process);
1 ✔
593
                        @unlink($output); // @ file may have been deleted meanwhile
1 ✔
594
                }
595

596
                $this->workers = $this->sockets = $this->inProgress = $this->buffers = [];
1 ✔
597
                $this->accepted = $this->pending = 0;
1 ✔
598
                $this->read = null;
1 ✔
599
        }
1 ✔
600
}
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