Switch to use the global event-loop

Author: WyriHaximus

composer.json

@@ -5,7 +5,7 @@
     "require": {
         "php": "^7.4",
         "dragonmantank/cron-expression": "^3.1",
-        "react/event-loop": "^1.1",
+        "react/event-loop": "dev-global-event-loop-accessor-part-four as 1.2.0",
         "react/promise": "^2.7",
         "thecodingmachine/safe": "^1.3",
         "wyrihaximus/constants": "^1.6",
@@ -31,6 +31,12 @@
             "WyriHaximus\\Tests\\React\\Cron\\": "tests/"
         }
     },
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/wyrihaximus-labs/event-loop"
+        }
+    ],
     "scripts": {
         "post-install-cmd": [
             "composer normalize"

composer.lock

@@ -1,28 +1,27 @@
 <?php
 
 use React\EventLoop\Factory;
+use React\EventLoop\Loop;
 use React\Promise\PromiseInterface;
 use function React\Promise\resolve;
-use WyriHaximus\React\Action;
 use WyriHaximus\React\Cron;
 
 require 'vendor/autoload.php';
 
-$loop = Factory::create();
-
-Cron::createHighPrecision(
-    $loop,
-    new Action(
+Cron::create(
+    new Cron\Action(
         'Hour', // Identifier used for mutex locking locking
+        1, // TTL for Mutex Locking (usually a few times the maximum time this cron should take)
         '@hourly', // The cron expression used to schedule this action
         function (): PromiseInterface { // The callable ran when this action is due according to it's schedule
             echo 'Another hour has passed!', PHP_EOL;
 
             return resolve(true); // This callable MUST return a promise, which is used for releasing the mutex lock
         }
     ),
-    new Action(
+    new Cron\Action(
         'Minute',
+        300,
         '* * * * *',
         function (): PromiseInterface {
             echo 'Another minute has passed!', PHP_EOL;
@@ -32,4 +31,4 @@ function (): PromiseInterface {
     )
 );
 
-$loop->run();
+Loop::get()->run();

example.php

@@ -4,7 +4,6 @@
 
 namespace WyriHaximus\React;
 
-use React\EventLoop\LoopInterface;
 use React\Promise\PromiseInterface;
 use WyriHaximus\React\Cron\ActionInterface;
 use WyriHaximus\React\Cron\Scheduler;
@@ -21,9 +20,9 @@ final class Cron
 
     private MutexInterface $mutex;
 
-    private function __construct(LoopInterface $loop, MutexInterface $mutex, ActionInterface ...$actions)
+    private function __construct(MutexInterface $mutex, ActionInterface ...$actions)
     {
-        $this->scheduler = new Scheduler($loop);
+        $this->scheduler = new Scheduler();
         $this->actions   = $actions;
         $this->mutex     = $mutex;
 
@@ -32,14 +31,14 @@ private function __construct(LoopInterface $loop, MutexInterface $mutex, ActionI
         });
     }
 
-    public static function create(LoopInterface $loop, ActionInterface ...$actions): self
+    public static function create(ActionInterface ...$actions): self
     {
-        return new self($loop, new Memory(), ...$actions);
+        return new self(new Memory(), ...$actions);
     }
 
-    public static function createWithMutex(LoopInterface $loop, MutexInterface $mutex, ActionInterface ...$actions): self
+    public static function createWithMutex(MutexInterface $mutex, ActionInterface ...$actions): self
     {
-        return new self($loop, $mutex, ...$actions);
+        return new self($mutex, ...$actions);
     }
 
     public function stop(): void

src/Cron.php

@@ -4,7 +4,7 @@
 
 namespace WyriHaximus\React\Cron;
 
-use React\EventLoop\LoopInterface;
+use React\EventLoop\Loop;
 use React\EventLoop\TimerInterface;
 
 use function microtime;
@@ -23,18 +23,14 @@ final class Scheduler
     private const ACTIVE         = true;
     private const INACTIVE       = false;
 
-    private LoopInterface $loop;
-
     /** @var callable[] */
     private array $ticks = [];
 
     private ?TimerInterface $timer = null;
     private bool $active           = self::ACTIVE;
 
-    public function __construct(LoopInterface $loop)
+    public function __construct()
     {
-        $this->loop = $loop;
-
         $this->align();
     }
 
@@ -79,14 +75,14 @@ private function tick(): void
     private function align(): void
     {
         if ($this->timer instanceof TimerInterface) {
-            $this->loop->cancelTimer($this->timer);
+            Loop::get()->cancelTimer($this->timer);
             $this->timer = null;
         }
 
         $currentSecond = (int) date('s', (int) $this->time());
 
         if ($currentSecond >= ONE && $currentSecond <= self::TIER_SLOW) {
-            $this->timer = $this->loop->addTimer(self::TIER_SLOW - $currentSecond, function (): void {
+            $this->timer = Loop::get()->addTimer(self::TIER_SLOW - $currentSecond, function (): void {
                 $this->timer = null;
                 $this->align();
             });
@@ -95,7 +91,7 @@ private function align(): void
         }
 
         if ($currentSecond > self::TIER_SLOW && $currentSecond <= self::TIER_MEDIUM) {
-            $this->timer = $this->loop->addTimer(ONE, function (): void {
+            $this->timer = Loop::get()->addTimer(ONE, function (): void {
                 $this->timer = null;
                 $this->align();
             });
@@ -104,7 +100,7 @@ private function align(): void
         }
 
         if ($currentSecond === self::TIER_FAST) {
-            $this->timer = $this->loop->addTimer(0.001, function (): void {
+            $this->timer = Loop::get()->addTimer(0.001, function (): void {
                 $this->timer = null;
                 $this->align();
             });
@@ -114,7 +110,7 @@ private function align(): void
 
         $this->tick();
 
-        $this->timer = $this->loop->addPeriodicTimer(self::MINUTE_SECONDS, function (): void {
+        $this->timer = Loop::get()->addPeriodicTimer(self::MINUTE_SECONDS, function (): void {
             $this->tick();
         });
     }
@@ -127,6 +123,6 @@ public function stop(): void
             return;
         }
 
-        $this->loop->cancelTimer($this->timer);
+        Loop::get()->cancelTimer($this->timer);
     }
 }

src/Cron/Scheduler.php

@@ -4,16 +4,13 @@
 
 namespace WyriHaximus\Tests\React\Cron;
 
-use React\EventLoop\Factory;
-use React\EventLoop\LoopInterface;
+use React\EventLoop\Loop;
 use React\Promise\Deferred;
 use WyriHaximus\AsyncTestUtilities\AsyncTestCase;
 use WyriHaximus\React\Cron;
 use WyriHaximus\React\Cron\Action;
 use WyriHaximus\React\Mutex\Memory;
 
-use function array_unshift;
-
 final class CronFunctionalTest extends AsyncTestCase
 {
     /**
@@ -23,13 +20,11 @@ public function provideFactoryMethods(): iterable
     {
         yield 'default' => [
             'create',
-            Factory::create(),
             [],
         ];
 
         yield 'default_mutex' => [
             'createWithMutex',
-            Factory::create(),
             [
                 new Memory(),
             ],
@@ -42,7 +37,7 @@ public function provideFactoryMethods(): iterable
      * @test
      * @dataProvider provideFactoryMethods
      */
-    public function scheduling(string $factoryMethod, LoopInterface $loop, array $args): void
+    public function scheduling(string $factoryMethod, array $args): void
     {
         $ran      = false;
         $ranTimes = 0;
@@ -63,11 +58,10 @@ public function scheduling(string $factoryMethod, LoopInterface $loop, array $ar
             $deferred->resolve();
         });
 
-        array_unshift($args, $loop);
         $args[] = $action;
         /** @phpstan-ignore-next-line */
         $cron = Cron::$factoryMethod(...$args);
-        $this->await($deferred->promise(), $loop, 150);
+        $this->await($deferred->promise(), Loop::get(), 150);
 
         self::assertTrue($ran);
         self::assertSame(2, $ranTimes);
@@ -79,14 +73,14 @@ public function scheduling(string $factoryMethod, LoopInterface $loop, array $ar
      * @test
      * @dataProvider provideFactoryMethods
      */
-    public function mutexLockOnlyAllowsTheSameActionOnce(string $factoryMethod, LoopInterface $loop, array $args): void
+    public function mutexLockOnlyAllowsTheSameActionOnce(string $factoryMethod, array $args): void
     {
         $ran      = false;
         $ranTimes = 0;
         $cron     = null;
         $deferred = new Deferred();
-        $action   = new Action('name', 0.1, '* * * * *', static function () use (&$ran, &$ranTimes, &$cron, $loop, $deferred): void {
-            $loop->futureTick(static function () use (&$ran, &$ranTimes, &$cron, $deferred): void {
+        $action   = new Action('name', 0.1, '* * * * *', static function () use (&$ran, &$ranTimes, &$cron, $deferred): void {
+            Loop::get()->futureTick(static function () use (&$ran, &$ranTimes, &$cron, $deferred): void {
                 $ran = true;
                 $ranTimes++;
 
@@ -102,12 +96,11 @@ public function mutexLockOnlyAllowsTheSameActionOnce(string $factoryMethod, Loop
             });
         });
 
-        array_unshift($args, $loop);
         $args[] = $action;
         $args[] = $action;
         /** @phpstan-ignore-next-line */
         $cron = Cron::$factoryMethod(...$args);
-        $this->await($deferred->promise(), $loop, 150);
+        $this->await($deferred->promise(), Loop::get(), 150);
 
         self::assertTrue($ran);
         self::assertSame(2, $ranTimes);