Make the ReactPHP Tasque EventLoop thread "shout" any Throwables

src/TasqueEventLoop.php

@@ -13,9 +13,11 @@
 
 namespace Tasque\EventLoop;
 
+use LogicException;
 use Nytris\Core\Package\PackageContextInterface;
 use Nytris\Core\Package\PackageInterface;
 use React\EventLoop\Loop;
+use Tasque\Core\Thread\Control\ExternalControlInterface;
 use Tasque\Tasque;
 
 /**
@@ -28,6 +30,7 @@
 class TasqueEventLoop implements TasqueEventLoopInterface
 {
     private static bool $installed = false;
+    private static ?ExternalControlInterface $eventLoopThread = null;
 
     /**
      * @inheritDoc
@@ -45,13 +48,28 @@ public static function getVendor(): string
         return 'tasque';
     }
 
+    /**
+     * @inheritDoc
+     */
+    public static function getEventLoopThread(): ExternalControlInterface
+    {
+        if (self::$eventLoopThread === null) {
+            throw new LogicException(
+                'Event loop thread is not set - did you forget to install this package in nytris.config.php?'
+            );
+        }
+
+        return self::$eventLoopThread;
+    }
+
     /**
      * @inheritDoc
      */
     public static function install(PackageContextInterface $packageContext, PackageInterface $package): void
     {
         self::$installed = true;
 
+        // Don't tock-ify the ReactPHP event loop logic itself for efficiency.
         Tasque::excludeComposerPackage('react/event-loop');
 
         /*
@@ -85,18 +103,30 @@ public static function install(PackageContextInterface $packageContext, PackageI
         $tasque = new Tasque();
 
         // Run the ReactPHP event loop itself inside a Tasque green thread.
-        $eventLoopThread = $tasque->createThread(function () {
+        self::$eventLoopThread = $tasque->createThread(function () {
             Loop::run();
         });
 
-        $eventLoopThread->start();
+        // Propagate any Throwables from the event loop up to the main thread.
+        self::$eventLoopThread->shout();
+
+        self::$eventLoopThread->start();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public static function isInstalled(): bool
+    {
+        return self::$installed;
     }
 
     /**
      * @inheritDoc
      */
     public static function uninstall(): void
     {
+        self::$eventLoopThread = null;
         self::$installed = false;
     }
 }

src/TasqueEventLoopInterface.php

@@ -14,6 +14,7 @@
 namespace Tasque\EventLoop;
 
 use Nytris\Core\Package\PackageFacadeInterface;
+use Tasque\Core\Thread\Control\ExternalControlInterface;
 
 /**
  * Interface TasqueEventLoopInterface.
@@ -24,4 +25,8 @@
  */
 interface TasqueEventLoopInterface extends PackageFacadeInterface
 {
+    /**
+     * Fetches the Tasque thread that is running the ReactPHP event loop.
+     */
+    public static function getEventLoopThread(): ExternalControlInterface;
 }

tests/Unit/TasqueEventLoopTest.php

@@ -0,0 +1,96 @@
+<?php
+
+/*
+ * Tasque EventLoop - ReactPHP event loop using a Tasque green thread.
+ * Copyright (c) Dan Phillimore (asmblah)
+ * https://github.com/nytris/tasque-event-loop/
+ *
+ * Released under the MIT license.
+ * https://github.com/nytris/tasque-event-loop/raw/main/MIT-LICENSE.txt
+ */
+
+declare(strict_types=1);
+
+namespace Tasque\EventLoop\Tests\Unit;
+
+use LogicException;
+use Mockery\MockInterface;
+use Nytris\Core\Package\PackageContextInterface;
+use Nytris\Core\Package\PackageInterface;
+use Tasque\Core\Thread\Control\ExternalControlInterface;
+use Tasque\EventLoop\TasqueEventLoop;
+use Tasque\EventLoop\Tests\AbstractTestCase;
+use Tasque\Tasque;
+use Tasque\TasquePackageInterface;
+
+/**
+ * Class TasqueEventLoopTest.
+ *
+ * @author Dan Phillimore <dan@ovms.co>
+ */
+class TasqueEventLoopTest extends AbstractTestCase
+{
+    private MockInterface&PackageContextInterface $eventLoopPackageContext;
+    private MockInterface&PackageInterface $eventLoopPackage;
+    private MockInterface&PackageContextInterface $tasquePackageContext;
+    private MockInterface&TasquePackageInterface $tasquePackage;
+
+    public function setUp(): void
+    {
+        $this->eventLoopPackage = mock(PackageInterface::class);
+        $this->eventLoopPackageContext = mock(PackageContextInterface::class);
+        $this->tasquePackage = mock(TasquePackageInterface::class, [
+            'getSchedulerStrategy' => null,
+        ]);
+        $this->tasquePackageContext = mock(PackageContextInterface::class);
+
+        TasqueEventLoop::uninstall();
+    }
+
+    public function tearDown(): void
+    {
+        TasqueEventLoop::uninstall();
+    }
+
+    public function testPackageIsDefinedCorrectly(): void
+    {
+        static::assertSame('tasque', TasqueEventLoop::getVendor());
+        static::assertSame('event-loop', TasqueEventLoop::getName());
+    }
+
+    public function testGetEventLoopThreadRaisesExceptionWhenPackageNotLoaded(): void
+    {
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage(
+            'Event loop thread is not set - did you forget to install this package in nytris.config.php?'
+        );
+
+        TasqueEventLoop::getEventLoopThread();
+    }
+
+    public function testInstallCreatesTasqueEventLoopThread(): void
+    {
+        Tasque::install($this->tasquePackageContext, $this->tasquePackage);
+        TasqueEventLoop::install($this->eventLoopPackageContext, $this->eventLoopPackage);
+
+        static::assertInstanceOf(ExternalControlInterface::class, TasqueEventLoop::getEventLoopThread());
+    }
+
+    public function testInstallMarksTasqueEventLoopThreadAsShouting(): void
+    {
+        Tasque::install($this->tasquePackageContext, $this->tasquePackage);
+        TasqueEventLoop::install($this->eventLoopPackageContext, $this->eventLoopPackage);
+
+        static::assertTrue(TasqueEventLoop::getEventLoopThread()->isShouting());
+    }
+
+    public function testUninstallUninstallsTasqueEventLoop(): void
+    {
+        Tasque::install($this->tasquePackageContext, $this->tasquePackage);
+        TasqueEventLoop::install($this->eventLoopPackageContext, $this->eventLoopPackage);
+
+        TasqueEventLoop::uninstall();
+
+        static::assertFalse(TasqueEventLoop::isInstalled());
+    }
+}