Release 1.1.0 (#83)

* Update dependencies

* Update daprd

* feat: add shutdown (#80)

* feat: add shutdown

* Adds params and throw attributes

* Add param description

* Add a helper to shutdown at the end of the request

* Ensure unit tests using the mock client will fail if they try to call the sidecar after shutting it down.

* Use POST to shutdown

Co-authored-by: Rob Landers <[email protected]>

* Add actor reference (#71)

* Add actor reference

* Add 'get from interface'

* Use interface instead

* fix bad var name

* Add actor reference to tests

* Implement an actor reference and address

* ok, I think I like the way it works now

* Add deprecation to actor reference

* Revert format change

* Revert comment

* Add more tests

* not going to deprecate actor proxy

After thinking about it and trying to understand usages, I don't think this should be deprecated at this time.

Co-authored-by: Hugome <[email protected]>

Author: withinboredom

composer.json

@@ -42,7 +42,7 @@
       "docker-compose up -d"
     ],
     "dapr-init": [
-      "dapr init --runtime-version 1.0.0"
+      "dapr init --runtime-version 1.1.0"
     ],
     "clean": [
       "docker-compose stop",

composer.lock

@@ -2,7 +2,7 @@
 version: "3"
 services:
   placement:
-    image: daprio/dapr:1.0.1
+    image: daprio/dapr:1.1.0
     command: [ "./placement","-port","50006" ]
   dev:
     build:
@@ -20,7 +20,7 @@ services:
       - dev
     network_mode: service:dev
   dev-daprd:
-    image: daprio/daprd:1.0.1
+    image: daprio/daprd:1.1.0
     command: [ "./daprd","-app-id","dev","-app-port","80","-placement-host-address","placement:50006","-components-path","/components" ]
     volumes:
       - ./components:/components

docker-compose.yml

@@ -6,6 +6,8 @@
 define('STORE', 'statestore');
 
 use Dapr\Actors\ActorProxy;
+use Dapr\Actors\ActorReference;
+use Dapr\Actors\Generators\ProxyFactory;
 use Dapr\Actors\IActor;
 use Dapr\Actors\Reminder;
 use Dapr\Actors\Timer;
@@ -58,13 +60,14 @@ public function increment(int $amount = 1): void
 
 $app->get(
     '/test/actors',
-    function (ActorProxy $actorProxy, DaprClient $client, LoggerInterface $logger) {
-        $id = uniqid(prefix: 'actor_');
+    function (ProxyFactory $proxyFactory, DaprClient $client, LoggerInterface $logger) {
+        $id        = uniqid(prefix: 'actor_');
+        $reference = new ActorReference($id, 'SimpleActor');
 
         /**
          * @var ISimpleActor|IActor $actor
          */
-        $actor = $actorProxy->get(ISimpleActor::class, $id);
+        $actor = $reference->bind(ISimpleActor::class, $proxyFactory);
         $body  = [];
 
         $logger->critical('Created actor proxy');
@@ -73,6 +76,10 @@ function (ActorProxy $actorProxy, DaprClient $client, LoggerInterface $logger) {
         $body = assert_equals($body, 1, $actor->get_count(), 'Actor should have data');
         $logger->critical('Incremented actor');
 
+        // get the actor proxy again
+        $reference = ActorReference::get($actor);
+        $actor     = $reference->bind(ISimpleActor::class, $proxyFactory);
+
         $reminder = new Reminder(
             name: 'increment',
             due_time: new DateInterval('PT1S'),

src/index.php

@@ -6,6 +6,7 @@
 use Dapr\Actors\Generators\ProxyFactory;
 use DI\DependencyException;
 use DI\NotFoundException;
+use JetBrains\PhpStorm\Deprecated;
 use LogicException;
 use Psr\Log\LoggerInterface;
 use ReflectionClass;
@@ -29,15 +30,15 @@ public function __construct(protected ProxyFactory $proxyFactory, protected Logg
      * Returns an actor proxy
      *
      * @param string $interface
-     * @param mixed $id The id to proxy for
+     * @param string $id
      * @param string|null $override_type Allow overriding the Dapr type for a given interface
      *
      * @return object
-     * @throws ReflectionException
      * @throws DependencyException
      * @throws NotFoundException
+     * @throws ReflectionException
      */
-    public function get(string $interface, mixed $id, string|null $override_type = null): object
+    public function get(string $interface, string $id, string|null $override_type = null): object
     {
         $this->logger?->debug('Getting actor proxy for {i}||{id}', ['i' => $interface, 'id' => $id]);
 

src/lib/Actors/ActorProxy.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace Dapr\Actors;
+
+use Dapr\Actors\Attributes\DaprType;
+use Dapr\Actors\Generators\ProxyFactory;
+use Dapr\Deserialization\Deserializers\IDeserialize;
+use Dapr\Deserialization\IDeserializer;
+use Dapr\Serialization\ISerializer;
+use Dapr\Serialization\Serializers\ISerialize;
+use LogicException;
+use ReflectionClass;
+
+/**
+ * Class ActorReference
+ * @package Dapr\Actors
+ */
+final class ActorReference implements IActorReference, ISerialize, IDeserialize
+{
+    public function __construct(private string $id, private string $actor_type)
+    {
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public static function get(mixed $actor): IActorReference
+    {
+        $id = $actor?->get_id();
+
+        if ($id === null) {
+            throw new LogicException('actor(proxy) must implement get_id()');
+        }
+
+        $detected_dapr_type = self::get_dapr_type($actor);
+
+        $dapr_type = $actor->DAPR_TYPE ?? $detected_dapr_type?->type;
+
+        if ($dapr_type === null) {
+            throw new LogicException('Missing DaprType attribute on '.$actor::class);
+        }
+
+        return new self(id: $id, actor_type: $dapr_type);
+    }
+
+    private static function get_dapr_type(object|string $type): DaprType|null
+    {
+        $reflector = new ReflectionClass($type);
+        /**
+         * @var DaprType|null $type_attribute
+         */
+        $type_attribute = ($reflector->getAttributes(DaprType::class)[0] ?? null)?->newInstance();
+
+        return $type_attribute;
+    }
+
+    public static function deserialize(mixed $value, IDeserializer $deserializer): mixed
+    {
+        return new ActorReference(id: $value['ActorId'], actor_type: $value['ActorType']);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function bind(string $interface, ProxyFactory $proxy_factory): mixed
+    {
+        return $proxy_factory->get_generator($interface, $this->actor_type)->get_proxy(
+            $this->id
+        );
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function get_actor_id(): string
+    {
+        return $this->id;
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function get_actor_type(): string
+    {
+        return $this->actor_type;
+    }
+
+    /**
+     * @param ActorReference $value
+     * @param ISerializer $serializer
+     *
+     * @return array
+     */
+    public function serialize(mixed $value, ISerializer $serializer): array
+    {
+        return ['ActorId' => $value->id, 'ActorType' => $value->actor_type];
+    }
+}

src/lib/Actors/ActorReference.php

@@ -2,7 +2,6 @@
 
 namespace Dapr\Actors;
 
-use Dapr\Actors\Internal\Caches\CacheInterface;
 use Dapr\Actors\Internal\Caches\FileCache;
 use Dapr\Actors\Internal\Caches\NoCache;
 use Dapr\Deserialization\IDeserializer;
@@ -14,7 +13,6 @@
 use DI\FactoryInterface;
 use DI\NotFoundException;
 use Exception;
-use JetBrains\PhpStorm\ArrayShape;
 use Psr\Log\LoggerInterface;
 use ReflectionClass;
 use ReflectionException;
@@ -69,7 +67,7 @@ public function do_method(IActor $actor, string $method, mixed $arg): mixed
 
     public function deactivate_actor(IActor $actor, string $dapr_type): void
     {
-        $id = $actor->get_id();
+        $id                 = $actor->get_id();
         $activation_tracker = hash('sha256', $dapr_type.$id);
         $activation_tracker = rtrim(
                                   sys_get_temp_dir(),
@@ -247,7 +245,8 @@ protected function begin_transaction(
      */
     protected function get_actor(ReflectionClass $reflection, string $dapr_type, string $id, array $states): IActor
     {
-        $states['id']       = $id;
+        $states['id'] = $id;
+        $this->container->set(ActorReference::class, new ActorReference($id, $dapr_type));
         $actor              = $this->factory->make($reflection->getName(), $states);
         $activation_tracker = hash('sha256', $dapr_type.$id);
         $activation_tracker = rtrim(

src/lib/Actors/ActorRuntime.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Dapr\Actors;
+
+use Dapr\Actors\Generators\ProxyFactory;
+
+/**
+ * Class IActorReference
+ * @package Dapr\Actors
+ */
+interface IActorReference
+{
+    /**
+     * Get a reference from a given actor that implements IActor
+     *
+     * @param IActor $actor The actor or actor interface to extract the reference from
+     *
+     * @return IActorReference The actor's reference
+     */
+    public static function get(mixed $actor): IActorReference;
+
+    /**
+     * Get an actor reference bound to a given interface.
+     *
+     * @param string $interface The interface of the actor
+     * @param ProxyFactory $proxy_factory The proxy factory to use
+     *
+     * @return IActor The actor's reference
+     */
+    public function bind(string $interface, ProxyFactory $proxy_factory): mixed;
+
+    /**
+     * @return string The actor id
+     */
+    public function get_actor_id(): string;
+
+    /**
+     * @return string The actor type
+     */
+    public function get_actor_type(): string;
+}

src/lib/Actors/IActorReference.php

@@ -201,4 +201,26 @@ public function delete(string $url, ?array $params = []): DaprResponse
 
         return $response;
     }
+
+    /**
+     * Shutdown the sidecar.
+     *
+     * @return void
+     * @param array $metadata Metadata to pass to the shutdown endpoint
+     *
+     * @throws DaprException
+     */
+    public function shutdown(array $metadata = []): void
+    {
+        $this->post("/shutdown", $metadata);
+    }
+
+    /**
+     * Shutdown the sidecar at the end of the current request.
+     *
+     * @param array $metadata Metadata to pass to the shutdown endpoint
+     */
+    public function schedule_shutdown(array $metadata): void {
+        register_shutdown_function(fn() => $this->shutdown($metadata));
+    }
 }

src/lib/DaprClient.php

@@ -19,6 +19,14 @@
 class TestClient extends DaprClient
 {
     public array $responses = [];
+    private bool $is_shutdown = false;
+
+    /**
+     * Asserts that the sidecar isn't shutdown
+     */
+    private function fail_if_shutdown() {
+        Assert::assertFalse($this->is_shutdown, 'The sidecar was previously shutdown.');
+    }
 
     /**
      * @param string $url
@@ -29,6 +37,7 @@ class TestClient extends DaprClient
      */
     public function get(string $url, ?array $params = null): DaprResponse
     {
+        $this->fail_if_shutdown();
         $url = $this->get_api_path($url, $params);
         $url = "GET $url";
         $this->validate($url, '');
@@ -102,6 +111,7 @@ public function register_get(string $path, int $code, mixed $data): void
      */
     public function post(string $url, mixed $data, ?array $params = null): DaprResponse
     {
+        $this->fail_if_shutdown();
         $url = $this->get_api_path($url, $params);
         $url = "POST $url";
         $this->validate($url, json_encode($data, JSON_PRETTY_PRINT));
@@ -143,6 +153,7 @@ public function register_post(
      */
     public function delete(string $url, ?array $params = null): DaprResponse
     {
+        $this->fail_if_shutdown();
         $url = $this->get_api_path($url, $params);
         $url = "DELETE $url";
         $this->validate($url, '');
@@ -160,4 +171,15 @@ public function register_delete(string $path, $expected_code): void
         $response->code                    = $expected_code;
         $this->responses["DELETE $path"][] = $response;
     }
+
+    public function shutdown(array $metadata = []): void
+    {
+        parent::shutdown($metadata);
+        $this->is_shutdown = true;
+    }
+
+    public function schedule_shutdown(array $metadata): void
+    {
+        // noop because a unit test will never hit it
+    }
 }