5603006711

pending completion

Build # 5603006711

Build Type

push

github

Committed by

azjezz

Commit Message

chore: update dependencies

Signed-off-by: azjezz <azjezz@protonmail.com>

Run Details

4152 of 4194 relevant lines covered (99.0%)

49.74 hits per line

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

86.49

/src/Psl/Network/Internal/AbstractStreamServer.php

<?php

declare(strict_types=1);

namespace Psl\Network\Internal;

use Generator;
use Psl\Channel;
use Psl\Network;
use Psl\Network\StreamServerInterface;
use Revolt\EventLoop;

use function error_get_last;
use function fclose;
use function is_resource;
use function stream_socket_accept;

/**
 * @psalm-suppress UnnecessaryVarAnnotation
 */
abstract class AbstractStreamServer implements StreamServerInterface
{
    private const DEFAULT_IDLE_CONNECTIONS = 256;

    /**
     * @var closed-resource|resource|null $impl
     */
    private mixed $impl;

    /**
     * @var string
     */
    private string $watcher;

    /**
     * @var Channel\ReceiverInterface<array{true, Socket}|array{false, Network\Exception\RuntimeException}>
     */
    private Channel\ReceiverInterface $receiver;

    /**
     * @param resource $impl
     * @param int<1, max> $idleConnections
     */
    protected function __construct(mixed $impl, int $idleConnections = self::DEFAULT_IDLE_CONNECTIONS)
    {
        $this->impl = $impl;
        /**
         * @var Channel\SenderInterface<array{true, Socket}|array{false, Network\Exception\RuntimeException}> $sender
         */
        [$this->receiver, $sender] = Channel\bounded($idleConnections);
        $this->watcher = EventLoop::onReadable($impl, static function ($watcher, $resource) use ($sender): void {
            try {
                $sock = @stream_socket_accept($resource, timeout: 0.0);
                if ($sock !== false) {
                    $sender->send([true, new Socket($sock)]);

                    return;
                }

                // @codeCoverageIgnoreStart
                /** @var array{file: string, line: int, message: string, type: int} $err */
                $err = error_get_last();
                $sender->send([false, new Network\Exception\RuntimeException('Failed to accept incoming connection: ' . $err['message'], $err['type'])]);
                // @codeCoverageIgnoreEnd
            } catch (Channel\Exception\ClosedChannelException) {
                EventLoop::cancel($watcher);

                return;
            }
        });
    }

    /**
     * {@inheritDoc}
     */
    public function nextConnection(): Network\StreamSocketInterface
    {
        try {
            [$success, $result] = $this->receiver->receive();
        } catch (Channel\Exception\ClosedChannelException) {
            throw new Network\Exception\AlreadyStoppedException('Server socket has already been stopped.');
        }

        if ($success) {
            /** @var Socket $result */
            return $result;
        }

        /** @var Network\Exception\RuntimeException $result  */
        throw $result;
    }

    /**
     * {@inheritDoc}
     */
    public function incoming(): Generator
    {
        try {
            while (true) {
                [$success, $result] = $this->receiver->receive();
                if ($success) {
                    /** @var Socket $result */
                    yield null => $result;
                } else {
                    /** @var Network\Exception\RuntimeException $result  */
                    throw $result;
                }
            }
        } catch (Channel\Exception\ClosedChannelException) {
            return;
        }
    }

    /**
     * {@inheritDoc}
     */
    public function getLocalAddress(): Network\Address
    {
        if (!is_resource($this->impl)) {
            throw new Network\Exception\AlreadyStoppedException('Server socket has already been stopped.');
        }

        return Network\Internal\get_sock_name($this->impl);
    }

    public function __destruct()
    {
        /** @psalm-suppress MissingThrowsDocblock */
        $this->close();
    }

    /**
     * {@inheritDoc}
     */
    public function close(): void
    {
        EventLoop::disable($this->watcher);
        if (null === $this->impl) {
            return;
        }

        $this->receiver->close();
        $resource = $this->impl;
        $this->impl = null;
        if (is_resource($resource)) {
            fclose($resource);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function getStream(): mixed
    {
        /** @var resource */
        return $this->impl;
    }
}

1	<?php
2
3	declare(strict_types=1);
4
5	namespace Psl\Network\Internal;
6
7	use Generator;
8	use Psl\Channel;
9	use Psl\Network;
10	use Psl\Network\StreamServerInterface;
11	use Revolt\EventLoop;
12
13	use function error_get_last;
14	use function fclose;
15	use function is_resource;
16	use function stream_socket_accept;
17
18	/**
19	* @psalm-suppress UnnecessaryVarAnnotation
20	*/
21	abstract class AbstractStreamServer implements StreamServerInterface
22	{
23	private const DEFAULT_IDLE_CONNECTIONS = 256;
24
25	/**
26	* @var closed-resource\|resource\|null $impl
27	*/
28	private mixed $impl;
29
30	/**
31	* @var string
32	*/
33	private string $watcher;
34
35	/**
36	* @var Channel\ReceiverInterface<array{true, Socket}\|array{false, Network\Exception\RuntimeException}>
37	*/
38	private Channel\ReceiverInterface $receiver;
39
40	/**
41	* @param resource $impl
42	* @param int<1, max> $idleConnections
43	*/
44	protected function __construct(mixed $impl, int $idleConnections = self::DEFAULT_IDLE_CONNECTIONS)
45	{
46	$this->impl = $impl;	11✔
47	/**
48	* @var Channel\SenderInterface<array{true, Socket}\|array{false, Network\Exception\RuntimeException}> $sender
49	*/
50	[$this->receiver, $sender] = Channel\bounded($idleConnections);	11✔
51	$this->watcher = EventLoop::onReadable($impl, static function ($watcher, $resource) use ($sender): void {	11✔
52	try {
53	$sock = @stream_socket_accept($resource, timeout: 0.0);	7✔
54	if ($sock !== false) {	7✔
55	$sender->send([true, new Socket($sock)]);	7✔
56
57	return;	7✔
58	}
59
60	// @codeCoverageIgnoreStart
61	/** @var array{file: string, line: int, message: string, type: int} $err */
62	$err = error_get_last();
63	$sender->send([false, new Network\Exception\RuntimeException('Failed to accept incoming connection: ' . $err['message'], $err['type'])]);
64	// @codeCoverageIgnoreEnd
65	} catch (Channel\Exception\ClosedChannelException) {	×
66	EventLoop::cancel($watcher);	×
67
68	return;	×
69	}
70	});	11✔
71	}
72
73	/**
74	* {@inheritDoc}
75	*/
76	public function nextConnection(): Network\StreamSocketInterface
77	{
78	try {
79	[$success, $result] = $this->receiver->receive();	8✔
80	} catch (Channel\Exception\ClosedChannelException) {	2✔
81	throw new Network\Exception\AlreadyStoppedException('Server socket has already been stopped.');	2✔
82	}
83
84	if ($success) {	6✔
85	/** @var Socket $result */
86	return $result;	6✔
87	}
88
89	/** @var Network\Exception\RuntimeException $result */
90	throw $result;	×
91	}
92
93	/**
94	* {@inheritDoc}
95	*/
96	public function incoming(): Generator
97	{
98	try {
99	while (true) {	1✔
100	[$success, $result] = $this->receiver->receive();	1✔
101	if ($success) {	1✔
102	/** @var Socket $result */
103	yield null => $result;	1✔
104	} else {
105	/** @var Network\Exception\RuntimeException $result */
106	throw $result;	×
107	}
108	}
109	} catch (Channel\Exception\ClosedChannelException) {	1✔
110	return;	1✔
111	}
112	}
113
114	/**
115	* {@inheritDoc}
116	*/
117	public function getLocalAddress(): Network\Address
118	{
119	if (!is_resource($this->impl)) {	7✔
120	throw new Network\Exception\AlreadyStoppedException('Server socket has already been stopped.');	2✔
121	}
122
123	return Network\Internal\get_sock_name($this->impl);	5✔
124	}
125
126	public function __destruct()
127	{
128	/** @psalm-suppress MissingThrowsDocblock */
129	$this->close();	11✔
130	}
131
132	/**
133	* {@inheritDoc}
134	*/
135	public function close(): void
136	{
137	EventLoop::disable($this->watcher);	11✔
138	if (null === $this->impl) {	11✔
139	return;	11✔
140	}
141
142	$this->receiver->close();	11✔
143	$resource = $this->impl;	11✔
144	$this->impl = null;	11✔
145	if (is_resource($resource)) {	11✔
146	fclose($resource);	11✔
147	}
148	}
149
150	/**
151	* {@inheritDoc}
152	*/
153	public function getStream(): mixed
154	{
155	/** @var resource */
156	return $this->impl;	2✔
157	}
158	}

azjezz / psl / 5603006711

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

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