Actively wait for loop shutdown

danog · danog · commit 064b1d8d2aa2 · 2023-01-24T15:49:37.000+01:00
diff --git a/lib/Loop.php b/lib/Loop.php
@@ -10,6 +10,7 @@
 
 namespace danog\Loop;
 
+use Amp\DeferredFuture;
 use AssertionError;
 use Revolt\EventLoop;
 use Stringable;
@@ -45,6 +46,10 @@ abstract class Loop implements Stringable
      * Resume deferred ID.
      */
     private ?string $resumeImmediate = null;
+    /**
+     * Shutdown deferred.
+     */
+    private ?DeferredFuture $shutdownDeferred = null;
 
     /**
      * Report pause, can be overriden for logging.
@@ -65,6 +70,9 @@ public function start(): bool
         if ($this->running) {
             return false;
         }
+        if ($this->shutdownDeferred) {
+            $this->shutdownDeferred->getFuture()->await();
+        }
         $this->running = true;
         if (!$this->resume()) {
             // @codeCoverageIgnoreStart
@@ -97,6 +105,14 @@ public function stop(): bool
         }
         if ($this->paused) {
             $this->exitedLoop();
+        } else {
+            if ($this->shutdownDeferred !== null) {
+                // @codeCoverageIgnoreStart
+                throw new AssertionError("Shutdown deferred is not null!");
+                // @codeCoverageIgnoreEnd
+            }
+            $this->shutdownDeferred = new DeferredFuture;
+            $this->shutdownDeferred->getFuture()->await();
         }
         return true;
     }
@@ -166,6 +182,11 @@ private function exitedLoopInternal(): void
             // @codeCoverageIgnoreEnd
         }
         $this->exitedLoop();
+        if ($this->shutdownDeferred !== null) {
+            $d = $this->shutdownDeferred;
+            $this->shutdownDeferred = null;
+            EventLoop::queue($d->complete(...));
+        }
     }
     /**
      * Signal that loop was started.
diff --git a/test/LoopTest.php b/test/LoopTest.php
@@ -23,7 +23,7 @@ class LoopTest extends Fixtures
     /**
      * Execute pre-start assertions.
      */
-    protected function assertPreStart(BasicInterface&Loop $loop): void
+    private function assertPreStart(BasicInterface&Loop $loop): void
     {
         $this->assertEquals(self::LOOP_NAME, "$loop");
 
@@ -37,41 +37,38 @@ protected function assertPreStart(BasicInterface&Loop $loop): void
     }
     /**
      * Execute after-start assertions.
-     *
-     * @param bool           $running Whether we should expect the loop to be running
-     * @param bool           $running Whether we should actually start the loop by returning control to the event loop
-     *
      */
-    protected function assertAfterStart(BasicInterface&Loop $loop, bool $running = true, bool $start = true): void
+    private function assertAfterStart(BasicInterface&Loop $loop, int $prevRun = 0): void
     {
-        if ($start) {
-            self::waitTick();
-        }
+        self::waitTick();
         $this->assertTrue($loop->inited());
 
-        if ($running) {
+        if ($prevRun === 0) {
             $this->assertFalse($loop->ran());
+        } else {
+            $this->assertTrue($loop->ran());
         }
-        $this->assertEquals($running, $loop->isRunning());
 
-        $this->assertEquals(1, $loop->startCounter());
-        $this->assertEquals($running ? 0 : 1, $loop->endCounter());
+        $this->assertTrue($loop->isRunning());
 
-        $this->assertEquals($running, !$loop->start());
-        $this->assertEquals($running, !$loop->isPaused());
+        $this->assertEquals($prevRun+1, $loop->startCounter());
+        $this->assertEquals($prevRun, $loop->endCounter());
+
+        $this->assertFalse($loop->start());
+        $this->assertFalse($loop->isPaused());
     }
     /**
      * Execute final assertions.
      */
-    protected function assertFinal(BasicInterface&Loop $loop): void
+    private function assertFinal(BasicInterface&Loop $loop, int $count = 1): void
     {
         $this->assertTrue($loop->ran());
         $this->assertFalse($loop->isRunning());
 
         $this->assertTrue($loop->inited());
 
-        $this->assertEquals(1, $loop->startCounter());
-        $this->assertEquals(1, $loop->endCounter());
+        $this->assertEquals($count, $loop->startCounter());
+        $this->assertEquals($count, $loop->endCounter());
     }
     /**
      * Test basic loop.
@@ -92,7 +89,7 @@ public function testLoop(): void
     /**
      * Test basic loop.
      */
-    public function testLoopStopFromInside(): void
+    public function testLoopStopFromOutside(): void
     {
         $loop = new class() extends Loop implements BasicInterface {
             use Basic;
@@ -103,7 +100,6 @@ public function loop(): ?float
             {
                 $this->inited = true;
                 delay(0.1);
-                $this->stop();
                 $this->ran = true;
                 return 1000.0;
             }
@@ -112,10 +108,46 @@ public function loop(): ?float
         $this->assertTrue($loop->start());
         $this->assertAfterStart($loop);
 
+        $this->assertTrue($loop->stop());
         delay(0.110);
 
         $this->assertFinal($loop);
     }
+    /**
+     * Test basic loop.
+     */
+    public function testLoopStopFromOutsideRestart(): void
+    {
+        $loop = new class() extends Loop implements BasicInterface {
+            use Basic;
+            /**
+             * Loop implementation.
+             */
+            public function loop(): ?float
+            {
+                $this->inited = true;
+                delay(0.1);
+                $this->ran = true;
+                return 1000.0;
+            }
+        };
+        $this->assertPreStart($loop);
+        $this->assertTrue($loop->start());
+        $this->assertAfterStart($loop);
+
+        EventLoop::queue(function () use ($loop): void {
+            $this->assertTrue($loop->stop());
+        });
+        self::waitTick();
+
+        $this->assertTrue($loop->start());
+        $this->assertAfterStart($loop, 1);
+
+        $this->assertTrue($loop->stop());
+        delay(0.110);
+
+        $this->assertFinal($loop, 2);
+    }
     /**
      * Test basic exception in loop.
      */
