Add RecevObservable

Author: WyriHaximus

composer.json

@@ -14,23 +14,24 @@
         "ext-parallel": "*",
         "react/event-loop": "^1.1",
         "react/promise": "^2.7",
+        "reactivex/rxphp": "^2.0",
         "wyrihaximus/constants": "^1.4.3"
     },
     "require-dev": {
         "wyrihaximus/async-test-utilities": "^2.0",
         "wyrihaximus/ticking-promise": "^1.6"
     },
-    "extra": {
-        "unused": [
-            "ext-parallel"
-        ]
-    },
     "config": {
         "platform": {
             "php": "7.4"
         },
         "sort-packages": true
     },
+    "extra": {
+        "unused": [
+            "ext-parallel"
+        ]
+    },
     "autoload": {
         "psr-4": {
             "ReactParallel\\Streams\\": "src/"

composer.lock

@@ -1,6 +1,7 @@
 parameters:
 	checkMissingIterableValueType: false
-	ignoreErrors: []
+	ignoreErrors:
+	    - '#In method \"ReactParallel\\Streams\\RecvObservable::recv\", caught \"Throwable\" must be rethrown. Either catch a more specific exception or add a \"throw\" clause in the "catch" block to propagate the exception. More info: http:\/\/bit.ly\/failloud#'
 
 includes:
 	- vendor/wyrihaximus/async-test-utilities/rules.neon

phpstan.neon

@@ -0,0 +1,81 @@
+<?php declare(strict_types=1);
+
+namespace ReactParallel\Streams;
+
+use parallel\Events;
+use React\EventLoop\LoopInterface;
+use React\EventLoop\TimerInterface;
+use Rx\Disposable\CallbackDisposable;
+use Rx\DisposableInterface;
+use Rx\Observable;
+use Rx\ObserverInterface;
+use Rx\Subject\Subject;
+use Throwable;
+use function var_export;
+
+final class RecvObservable
+{
+    private LoopInterface $loop;
+
+    private Events $events;
+
+    public function __construct(LoopInterface $loop, Events $events)
+    {
+        $this->loop   = $loop;
+        $this->events = $events;
+    }
+
+    public function recv(): Observable
+    {
+        var_export([__FILE__, __LINE__, 'a']);
+        $subject = new Subject();
+
+        // Call 1K times per second
+        $timer = $this->loop->addPeriodicTimer(0.05, function () use (&$timer, $subject): void {
+            try {
+                while ($event = $this->events->poll()) {
+                    var_export([__FILE__, __LINE__, 'e', $event]);
+                    if ($event->type === Events\Event\Type::Read) {
+                        echo 'read', PHP_EOL;
+                        $subject->onNext($event->value);
+
+                        break;
+                    }
+
+                    if ($event->type !== Events\Event\Type::Close) {
+                        var_export([__FILE__, __LINE__, 'not:closed']);
+                        break;
+                    }
+
+                    echo 'close', PHP_EOL;
+
+                    $subject->onCompleted();
+
+                    if ($timer instanceof TimerInterface) {
+                        echo 'timer:a', PHP_EOL;
+                        $this->loop->cancelTimer($timer);
+                    }
+
+                    $subject->onCompleted();
+
+                    return;
+                }
+            } catch (Events\Error\Timeout $timeout) {
+                var_export([__FILE__, __LINE__, 'to']);
+                return;
+            } catch (Throwable $throwable) {
+                var_export([__FILE__, __LINE__, 't']);
+                echo $throwable;
+                if ($timer instanceof TimerInterface) {
+                    echo 'timer:b', PHP_EOL;
+                    $this->loop->cancelTimer($timer);
+                }
+
+                $subject->onError($throwable);
+            }
+        });
+
+        var_export([__FILE__, __LINE__, 'b']);
+        return $subject;
+    }
+}

src/RecvObservable.php

@@ -0,0 +1,62 @@
+<?php declare(strict_types=1);
+
+namespace ReactParallel\Tests\Streams;
+
+use parallel\Channel;
+use parallel\Events;
+use React\EventLoop\Factory;
+use React\Promise\ExtendedPromiseInterface;
+use ReactParallel\Streams\RecvObservable;
+use ReactParallel\Streams\SingleRecv;
+use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
+use ReactParallel\FutureToPromiseConverter\FutureToPromiseConverter;
+use ReactParallel\Runtime\Runtime;
+use parallel\Runtime\Error\Closed;
+use function sleep;
+use function WyriHaximus\React\timedPromise;
+use function parallel\run;
+
+/**
+ * @internal
+ */
+final class SingleRecvObservableTest extends AsyncTestCase
+{
+    /**
+     * @test
+     */
+    public function recv(): void
+    {
+        $d = bin2hex(random_bytes(13));
+
+        $loop = Factory::create();
+        $channel = Channel::make($d, Channel::Infinite);
+        $events = new Events();
+        $events->setTimeout(0);
+        $events->addChannel($channel);
+
+        $recvObservable = new RecvObservable($loop, $events);
+
+        run(function () use ($channel, $d): void {
+            sleep(1);
+            echo '1:send', PHP_EOL;
+            $channel->send(1);
+            echo '1:done', PHP_EOL;
+        });
+        run(function () use ($channel, $d): void {
+            sleep(2);
+            echo '2:send', PHP_EOL;
+            $channel->send(2);
+            echo '2:done', PHP_EOL;
+        });
+        run(function () use ($channel): void {
+            sleep(3);
+            echo '3:close', PHP_EOL;
+            $channel->close();
+            echo '3:done', PHP_EOL;
+        });
+
+        $rd = $this->await($recvObservable->recv()->toArray()->toPromise(), $loop, 3.3);
+
+        self::assertSame([$d, $d], $rd);
+    }
+}

tests/SingleRecvObservableTest.php

@@ -38,7 +38,6 @@ public function recv(): void
             $channel->send($d);
         });
 
-        $loop->run();
         $rd = $this->await($singleRecv->recv(), $loop, 3.3);
 
         self::assertSame($d, $rd);
@@ -63,7 +62,6 @@ public function timedOut(): void
             $channel->close();
         });
 
-        $loop->run();
         $rd = $this->await($singleRecv->recv(), $loop, 3.3);
 
         self::assertNull($rd);