├── LICENSE
├── composer.json
├── src
    ├── FiberLoop.php
    └── RejectedException.php
└── stubs
    ├── Fiber.php
    ├── FiberError.php
    ├── FiberExit.php
    └── ReflectionFiber.php


/LICENSE:
--------------------------------------------------------------------------------
 1 | 
 2 | The MIT License (MIT)
 3 | 
 4 | Copyright (c) 2020 Aaron Piotrowski
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "trowski/react-fiber",
 3 |     "description": "ReactPHP + ext-fiber",
 4 |     "keywords": [
 5 |         "async",
 6 |         "asynchronous",
 7 |         "concurrency",
 8 |         "promise",
 9 |         "awaitable",
10 |         "future",
11 |         "non-blocking",
12 |         "event",
13 |         "event-loop"
14 |     ],
15 |     "license": "MIT",
16 |     "authors": [
17 |         {
18 |             "name": "Aaron Piotrowski",
19 |             "email": "aaron@trowski.com"
20 |         }
21 |     ],
22 |     "require": {
23 |         "php": ">=8",
24 |         "ext-fiber": "*",
25 |         "react/event-loop": "^1",
26 |         "react/promise": "^2.2"
27 |     },
28 |     "require-dev": {
29 |         "phpunit/phpunit": "^9",
30 |         "react/http": "^1.1",
31 |         "react/promise-stream": "^1.2"
32 |     },
33 |     "autoload": {
34 |         "psr-4": {
35 |             "Trowski\\ReactFiber\\": "src"
36 |         }
37 |     },
38 |     "autoload-dev": {
39 |         "psr-4": {
40 |             "Trowski\\ReactFiber\\Test\\": "test"
41 |         }
42 |     },
43 |     "scripts": {
44 |         "test": "@php -dzend.assertions=1 -dassert.exception=1 ./vendor/bin/phpunit",
45 |         "code-style": "@php ./vendor/bin/php-cs-fixer fix"
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/FiberLoop.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Trowski\ReactFiber;
  4 | 
  5 | use React\EventLoop\LoopInterface;
  6 | use React\EventLoop\TimerInterface;
  7 | use React\Promise\ExtendedPromiseInterface;
  8 | use React\Promise\Promise;
  9 | use React\Promise\PromiseInterface;
 10 | 
 11 | /**
 12 |  * This class adds async() and await() methods to LoopInterface.
 13 |  */
 14 | final class FiberLoop implements LoopInterface
 15 | {
 16 |     private LoopInterface $loop;
 17 | 
 18 |     private \Fiber $fiber;
 19 | 
 20 |     public function __construct(LoopInterface $loop)
 21 |     {
 22 |         $this->loop = $loop;
 23 |     }
 24 | 
 25 |     public function addReadStream($stream, $listener): void
 26 |     {
 27 |         $this->loop->addReadStream($stream, $listener);
 28 |     }
 29 | 
 30 |     public function addWriteStream($stream, $listener): void
 31 |     {
 32 |         $this->loop->addWriteStream($stream, $listener);
 33 |     }
 34 | 
 35 |     public function removeReadStream($stream): void
 36 |     {
 37 |         $this->loop->removeReadStream($stream);
 38 |     }
 39 | 
 40 |     public function removeWriteStream($stream): void
 41 |     {
 42 |         $this->loop->removeWriteStream($stream);
 43 |     }
 44 | 
 45 |     public function addTimer($interval, $callback): TimerInterface
 46 |     {
 47 |         return $this->loop->addTimer($interval, $callback);
 48 |     }
 49 | 
 50 |     public function addPeriodicTimer($interval, $callback): TimerInterface
 51 |     {
 52 |         return $this->loop->addPeriodicTimer($interval, $callback);
 53 |     }
 54 | 
 55 |     public function cancelTimer(TimerInterface $timer): void
 56 |     {
 57 |         $this->loop->cancelTimer($timer);
 58 |     }
 59 | 
 60 |     public function futureTick($listener): void
 61 |     {
 62 |         $this->loop->futureTick($listener);
 63 |     }
 64 | 
 65 |     public function addSignal($signal, $listener): void
 66 |     {
 67 |         $this->loop->addSignal($signal, $listener);
 68 |     }
 69 | 
 70 |     public function removeSignal($signal, $listener): void
 71 |     {
 72 |         $this->loop->removeSignal($signal, $listener);
 73 |     }
 74 | 
 75 |     public function run(): void
 76 |     {
 77 |         $this->loop->run();
 78 |     }
 79 | 
 80 |     public function stop(): void
 81 |     {
 82 |         $this->loop->stop();
 83 |     }
 84 | 
 85 |     /**
 86 |      * @template TValue
 87 |      *
 88 |      * @param PromiseInterface $promise
 89 |      *
 90 |      * @psalm-param PromiseInterface<TValue> $promise
 91 |      *
 92 |      * @return mixed
 93 |      *
 94 |      * @psalm-return TValue
 95 |      *
 96 |      * @throws \Throwable
 97 |      */
 98 |     public function await(PromiseInterface $promise): mixed
 99 |     {
100 |         $fiber = \Fiber::getCurrent();
101 |         $method = $promise instanceof ExtendedPromiseInterface ? 'done' : 'then';
102 | 
103 |         $resolved = false;
104 | 
105 |         if ($fiber === null) {
106 |             // Awaiting from {main}.
107 |             if (!isset($this->fiber) || $this->fiber->isTerminated()) {
108 |                 $this->fiber = $loop = new \Fiber(fn() => $this->run());
109 |                 // Run event loop to completion on shutdown.
110 |                 \register_shutdown_function(static function () use ($loop): void {
111 |                     if ($loop->isSuspended()) {
112 |                         $loop->resume();
113 |                     }
114 |                 });
115 |             }
116 | 
117 |             $promise->{$method}(
118 |                 function (mixed $value) use (&$resolved): void {
119 |                     $resolved = true;
120 |                     $this->futureTick(static fn() => \Fiber::suspend(static fn() => $value));
121 |                 },
122 |                 function (mixed $reason) use (&$resolved): void {
123 |                     $resolved = true;
124 |                     $exception = $reason instanceof \Throwable ? $reason : new RejectedException($reason);
125 |                     $this->futureTick(static fn() => \Fiber::suspend(static fn() => throw $exception));
126 |                 }
127 |             );
128 | 
129 |             $lambda = $this->fiber->isStarted() ? $this->fiber->resume() : $this->fiber->start();
130 | 
131 |             if (!$resolved) {
132 |                 throw new \Error('Event loop suspended or exited without resolving the promise');
133 |             }
134 | 
135 |             return $lambda();
136 |         }
137 | 
138 |         if (isset($this->fiber) && $fiber === $this->fiber) {
139 |             throw new \Error(\sprintf("Cannot call %s::%s() from a loop event handler callback", self::class, __METHOD__));
140 |         }
141 | 
142 |         $promise->{$method}(
143 |             function (mixed $value) use (&$resolved, $fiber): void {
144 |                 $resolved = true;
145 |                 $this->futureTick(static fn() => $fiber->resume($value));
146 |             },
147 |             function (mixed $reason) use (&$resolved, $fiber): void {
148 |                 $resolved = true;
149 |                 $exception = $reason instanceof \Throwable ? $reason : new RejectedException($reason);
150 |                 $this->futureTick(static fn() => $fiber->throw($exception));
151 |             }
152 |         );
153 | 
154 |         try {
155 |             $result = \Fiber::suspend();
156 |         } finally {
157 |             if (!$resolved) {
158 |                 throw new \Error('Fiber resumed before the promise was resolved');
159 |             }
160 |         }
161 | 
162 |         return $result;
163 |     }
164 | 
165 | 
166 |     /**
167 |      * Create a new fiber (green-thread) using the given callback. The returned promise is
168 |      * resolved with the return value of the callback once the fiber completes execution.
169 |      *
170 |      * @template TReturn
171 |      *
172 |      * @param callable $callback
173 |      * @param mixed ...$args
174 |      *
175 |      * @psalm-param callable(mixed ...$args):TReturn $callback
176 |      *
177 |      * @return ExtendedPromiseInterface
178 |      *
179 |      * @psalm-return ExtendedPromiseInterface<TReturn>
180 |      */
181 |     public function async(callable $callback, mixed ...$args): ExtendedPromiseInterface
182 |     {
183 |         return new Promise(function (callable $resolve, callable $reject) use ($callback, $args): void {
184 |             $fiber = new \Fiber(function () use ($resolve, $reject, $callback, $args): void {
185 |                 try {
186 |                     $resolve($callback(...$args));
187 |                 } catch (\Throwable $exception) {
188 |                     $reject($exception);
189 |                 }
190 |             });
191 | 
192 |             $this->futureTick(static fn() => $fiber->start());
193 |         });
194 |     }
195 | }
196 | 


--------------------------------------------------------------------------------
/src/RejectedException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Trowski\ReactFiber;
 4 | 
 5 | final class RejectedException extends \Exception
 6 | {
 7 |     private mixed $reason;
 8 | 
 9 |     public function __construct(mixed $reason)
10 |     {
11 |         parent::__construct("Promise was rejected");
12 |         $this->reason = $reason;
13 |     }
14 | 
15 |     public function getReason(): mixed
16 |     {
17 |         return $this->reason;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/stubs/Fiber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | final class Fiber
 4 | {
 5 |     /**
 6 |      * @param callable $callback Function to invoke when starting the fiber.
 7 |      */
 8 |     public function __construct(callable $callback) { }
 9 | 
10 |     /**
11 |      * Starts execution of the fiber. Returns when the fiber suspends or terminates.
12 |      *
13 |      * @param mixed ...$args Arguments passed to fiber function.
14 |      *
15 |      * @return mixed Value from the first suspension point.
16 |      *
17 |      * @throw FiberError If the fiber is running or terminated.
18 |      * @throw Throwable If the fiber callable throws an uncaught exception.
19 |      */
20 |     public function start(mixed ...$args): mixed { }
21 | 
22 |     /**
23 |      * Resumes the fiber, returning the given value from {@see Fiber::suspend()}.
24 |      * Returns when the fiber suspends or terminates.
25 |      *
26 |      * @param mixed $value
27 |      *
28 |      * @return mixed Value from the next suspension point or NULL if the fiber terminates.
29 |      *
30 |      * @throw FiberError If the fiber is running or terminated.
31 |      * @throw Throwable If the fiber callable throws an uncaught exception.
32 |      */
33 |     public function resume(mixed $value = null): mixed { }
34 | 
35 |     /**
36 |      * Throws the given exception into the fiber from {@see Fiber::suspend()}.
37 |      * Returns when the fiber suspends or terminates.
38 |      *
39 |      * @param Throwable $exception
40 |      *
41 |      * @return mixed Value from the next suspension point or NULL if the fiber terminates.
42 |      *
43 |      * @throw FiberError If the fiber is running or terminated.
44 |      * @throw Throwable If the fiber callable throws an uncaught exception.
45 |      */
46 |     public function throw(Throwable $exception): mixed { }
47 | 
48 |     /**
49 |      * @return bool True if the fiber has been started.
50 |      */
51 |     public function isStarted(): bool { }
52 | 
53 |     /**
54 |      * @return bool True if the fiber is suspended.
55 |      */
56 |     public function isSuspended(): bool { }
57 | 
58 |     /**
59 |      * @return bool True if the fiber is currently running.
60 |      */
61 |     public function isRunning(): bool { }
62 | 
63 |     /**
64 |      * @return bool True if the fiber has completed execution.
65 |      */
66 |     public function isTerminated(): bool { }
67 | 
68 |     /**
69 |      * @return mixed Return value of the fiber callback.
70 |      *
71 |      * @throws FiberError If the fiber has not terminated or did not return a value.
72 |      */
73 |     public function getReturn(): mixed { }
74 | 
75 |     /**
76 |      * @return self|null Returns the currently executing fiber instance or NULL if in {main}.
77 |      */
78 |     public static function getCurrent(): ?self { }
79 | 
80 |     /**
81 |      * Suspend execution of the fiber. The fiber may be resumed with {@see Fiber::resume()} or {@see Fiber::throw()}.
82 |      *
83 |      * Cannot be called from {main}.
84 |      *
85 |      * @param mixed $value Value to return from {@see Fiber::resume()} or {@see Fiber::throw()}.
86 |      *
87 |      * @return mixed Value provided to {@see Fiber::resume()}.
88 |      *
89 |      * @throws Throwable Exception provided to {@see Fiber::throw()}.
90 |      */
91 |     public static function suspend(mixed $value = null): mixed { }
92 | }
93 | 


--------------------------------------------------------------------------------
/stubs/FiberError.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Exception thrown due to invalid fiber actions, such as resuming a terminated fiber.
 5 |  */
 6 | final class FiberError extends Error
 7 | {
 8 |     /**
 9 |      * Constructor throws to prevent user code from throwing FiberError.
10 |      */
11 |     public function __construct()
12 |     {
13 |         throw new \Error('The "FiberError" class is reserved for internal use and cannot be manually instantiated');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/stubs/FiberExit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * Exception thrown when destroying a fiber. This exception cannot be caught by user code.
 5 |  */
 6 | final class FiberExit extends Exception
 7 | {
 8 |     /**
 9 |      * Constructor throws to prevent user code from throwing FiberExit.
10 |      */
11 |     public function __construct()
12 |     {
13 |         throw new \Error('The "FiberExit" class is reserved for internal use and cannot be manually instantiated');
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/stubs/ReflectionFiber.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | class ReflectionFiber
 4 | {
 5 |     /**
 6 |      * @param Fiber $fiber Any Fiber object, including those that are not started or have
 7 |      *                     terminated.
 8 |      */
 9 |     public function __construct(Fiber $fiber) { }
10 | 
11 |     /**
12 |      * @return string Current file of fiber execution.
13 |      */
14 |     public function getExecutingFile(): string { }
15 | 
16 |     /**
17 |      * @return int Current line of fiber execution.
18 |      */
19 |     public function getExecutingLine(): int { }
20 | 
21 |     /**
22 |      * @param int $options Same flags as {@see debug_backtrace()}.
23 |      *
24 |      * @return array Fiber backtrace, similar to {@see debug_backtrace()}
25 |      *               and {@see ReflectionGenerator::getTrace()}.
26 |      */
27 |     public function getTrace(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT): array { }
28 | 
29 |     /**
30 |      * @return bool True if the fiber has been started.
31 |      */
32 |     public function isStarted(): bool { }
33 | 
34 |     /**
35 |      * @return bool True if the fiber is currently suspended.
36 |      */
37 |     public function isSuspended(): bool { }
38 | 
39 |     /**
40 |      * @return bool True if the fiber is currently running.
41 |      */
42 |     public function isRunning(): bool { }
43 | 
44 |     /**
45 |      * @return bool True if the fiber has completed execution (either returning or
46 |      *              throwing an exception), false otherwise.
47 |      */
48 |     public function isTerminated(): bool { }
49 | }
50 | 


--------------------------------------------------------------------------------