Merge pull request #62 from reactphp-parallel/make-public-close-method-that-will-shutdown-everything

Add close method that will shutdown the entire proxy

Author: WyriHaximus

infection.json.dist

@@ -71,6 +71,7 @@
         "MethodCallRemoval": {
             "ignore": [
                 "ReactParallel\\ObjectProxy\\Proxy::__destruct",
+                "ReactParallel\\ObjectProxy\\Proxy::close",
                 "ReactParallel\\ObjectProxy\\Proxy::create",
                 "ReactParallel\\ObjectProxy\\Proxy::thread",
                 "ReactParallel\\ObjectProxy\\Proxy\\Handler::__destruct",

phpstan.neon

@@ -14,6 +14,7 @@ parameters:
 	ergebnis:
 		classesAllowedToBeExtended:
 			- Exception
+			- RuntimeException
 			- Monolog\Handler\AbstractHandler
 			- ReactParallel\ObjectProxy\Generated\ProxyList
 

src/ClosedException.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ReactParallel\ObjectProxy;
+
+use RuntimeException;
+
+final class ClosedException extends RuntimeException
+{
+    public static function create(): self
+    {
+        return new self('Proxy has been closed previously and cannot be used anymore');
+    }
+}

src/Proxy.php

@@ -23,6 +23,7 @@
 use function serialize;
 use function unserialize;
 
+use const WyriHaximus\Constants\Boolean\FALSE_;
 use const WyriHaximus\Constants\Boolean\TRUE_;
 
 final class Proxy extends ProxyList
@@ -38,6 +39,8 @@ final class Proxy extends ProxyList
     /** @var array<Channel> */
     private array $destruct = [];
 
+    private bool $closed = FALSE_;
+
     public function __construct(Configuration $configuration)
     {
         $this->factory  = $configuration->factory();
@@ -54,11 +57,19 @@ public function __construct(Configuration $configuration)
 
     public function has(string $interface): bool
     {
+        if ($this->closed === TRUE_) {
+            throw ClosedException::create();
+        }
+
         return array_key_exists($interface, self::KNOWN_INTERFACE);
     }
 
     public function share(object $object, string $interface): object
     {
+        if ($this->closed === TRUE_) {
+            throw ClosedException::create();
+        }
+
         if ($this->has($interface) === self::HASNT_PROXYABLE_INTERFACE) {
             throw NonExistentInterface::create($interface);
         }
@@ -74,6 +85,10 @@ public function share(object $object, string $interface): object
 
     public function create(object $object, string $interface): object
     {
+        if ($this->closed === TRUE_) {
+            throw ClosedException::create();
+        }
+
         if ($this->has($interface) === self::HASNT_PROXYABLE_INTERFACE) {
             throw NonExistentInterface::create($interface);
         }
@@ -94,6 +109,10 @@ public function create(object $object, string $interface): object
 
     public function thread(object $object, string $interface): object
     {
+        if ($this->closed === TRUE_) {
+            throw ClosedException::create();
+        }
+
         if ($this->has($interface) === self::HASNT_PROXYABLE_INTERFACE) {
             throw NonExistentInterface::create($interface);
         }
@@ -128,13 +147,24 @@ static function (string $object, string $interface, string $hash, Channel $in, C
         return $instance->create();
     }
 
-    public function __destruct()
+    public function close(): void
     {
+        if ($this->closed === TRUE_) {
+            throw ClosedException::create();
+        }
+
+        $this->closed = TRUE_;
+
         foreach ($this->destruct as $destruct) {
             $destruct->send('bye');
             $destruct->close();
         }
 
         $this->in->close();
     }
+
+    public function __destruct()
+    {
+        $this->close();
+    }
 }

tests/ProxyTest.php

@@ -13,6 +13,7 @@
 use React\Promise\PromiseInterface;
 use React\Promise\Timer\TimeoutException;
 use ReactParallel\Factory;
+use ReactParallel\ObjectProxy\ClosedException;
 use ReactParallel\ObjectProxy\Configuration;
 use ReactParallel\ObjectProxy\Configuration\Metrics;
 use ReactParallel\ObjectProxy\Generated\WyriHaximus__Metrics_RegistryProxy;
@@ -306,4 +307,74 @@ public function provideBooleans(): iterable
         yield 'true' => [TRUE_];
         yield 'false' => [FALSE_];
     }
+
+    /**
+     * @test
+     */
+    public function cannotCloseProxyTwice(): void
+    {
+        self::expectException(ClosedException::class);
+
+        $loop    = EventLoopFactory::create();
+        $factory = new Factory($loop);
+        $proxy   = new Proxy(new Configuration($factory));
+        $proxy->close();
+        $proxy->close();
+    }
+
+    /**
+     * @test
+     */
+    public function cannotUseClosedProxyHas(): void
+    {
+        self::expectException(ClosedException::class);
+
+        $loop    = EventLoopFactory::create();
+        $factory = new Factory($loop);
+        $proxy   = new Proxy(new Configuration($factory));
+        $proxy->close();
+        $proxy->has('string');
+    }
+
+    /**
+     * @test
+     */
+    public function cannotUseClosedProxyShare(): void
+    {
+        self::expectException(ClosedException::class);
+
+        $loop    = EventLoopFactory::create();
+        $factory = new Factory($loop);
+        $proxy   = new Proxy(new Configuration($factory));
+        $proxy->close();
+        $proxy->share(new stdClass(), 'string');
+    }
+
+    /**
+     * @test
+     */
+    public function cannotUseClosedProxyThread(): void
+    {
+        self::expectException(ClosedException::class);
+
+        $loop    = EventLoopFactory::create();
+        $factory = new Factory($loop);
+        $proxy   = new Proxy(new Configuration($factory));
+        $proxy->close();
+        $proxy->thread(new stdClass(), 'string');
+    }
+
+    /**
+     * @test
+     */
+    public function cannotUseClosedProxyCreate(): void
+    {
+        self::expectException(ClosedException::class);
+
+        $loop    = EventLoopFactory::create();
+        $factory = new Factory($loop);
+        $proxy   = new Proxy(new Configuration($factory));
+        $proxy->close();
+        $proxy->create(new stdClass(), 'string');
+    }
 }