Add interceptors examples

README.md

@@ -161,4 +161,6 @@ The following samples demonstrate some of the more complex aspects associated wi
 
 - **[Subscription](https://github.com/temporalio/samples-php/tree/master/app/src/Subscription)**: Demonstrates a long-running process associated with a user ID. The process charges the user once every 30 days after a one month free trial period.
 
+- **[Interceptors](https://github.com/temporalio/samples-php/tree/master/app/src/Interceptors)**: Demonstrates how to use Workflow and Activity interceptors to implement custom logic.
+
 <!-- @@@SNIPEND -->

app/.rr.yaml

@@ -11,6 +11,10 @@ temporal:
   activities:
     num_workers: 4
 
+service:
+  interceptors:
+    command: "./rr serve -c ./src/Interceptors/.rr.yaml"
+
 logs:
-  level: debug
+  level: info
   mode: development

app/composer.json

@@ -1,7 +1,8 @@
 {
   "minimum-stability": "beta",
+  "prefer-stable": true,
   "require": {
-    "temporal/sdk": ">=2.6.0",
+    "temporal/sdk": ">=2.7.0",
     "spiral/tokenizer": ">=2.7"
   },
   "autoload": {

app/src/FileProcessing/README.md

@@ -1,6 +1,6 @@
 # FileProcessing sample
 
-This sample demonstrates how to how to use Task routing.
+This sample demonstrates how to use Task routing.
 
 This Workflow downloads a file, processes it, and uploads the result to a destination.
 Any worker can pick up the first Activity.

app/src/Interceptors/.rr.yaml

@@ -0,0 +1,14 @@
+version: "3"
+
+server:
+  command: "php worker.php"
+  env:
+    - TEMPORAL_CLI_ADDRESS: temporal:7233
+
+temporal:
+  address: "temporal:7233"
+  activities:
+    num_workers: 2
+
+logs:
+  level: info

app/src/Interceptors/Activity/Sleeper.php

@@ -0,0 +1,36 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors\Activity;
+
+use Temporal\Activity\ActivityInterface;
+use Temporal\Activity\ActivityMethod;
+use Temporal\Samples\Interceptors\Attribute\StartToCloseTimeout;
+
+#[StartToCloseTimeout(5)]
+#[ActivityInterface(prefix: 'Interceptors.')]
+class Sleeper
+{
+    #[ActivityMethod]
+    public function sleep(int $howToSleep)
+    {
+        \sleep($howToSleep);
+        return 'I am awake!';
+    }
+
+    #[StartToCloseTimeout(2)]
+    #[ActivityMethod]
+    public function sleep2(int $howToSleep)
+    {
+        \sleep($howToSleep);
+        return 'I am awake!';
+    }
+}

app/src/Interceptors/Attribute/ActivityOption.php

@@ -0,0 +1,16 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors\Attribute;
+
+interface ActivityOption
+{
+}

app/src/Interceptors/Attribute/StartToCloseTimeout.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors\Attribute;
+
+use Attribute;
+
+#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_METHOD)]
+final class StartToCloseTimeout implements ActivityOption
+{
+    public function __construct(
+        public readonly string|int|float|\DateInterval $timeout,
+    ) {
+    }
+}

app/src/Interceptors/ExecuteCommand.php

@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors;
+
+use Carbon\CarbonInterval;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Temporal\Client\WorkflowOptions;
+use Temporal\Samples\Interceptors\Workflow\TestActivityAttributesInterceptor;
+use Temporal\SampleUtils\Command;
+
+class ExecuteCommand extends Command
+{
+    protected const NAME = 'interceptors';
+    protected const DESCRIPTION = 'Execute workflow with interceptors';
+
+    public function execute(InputInterface $input, OutputInterface $output)
+    {
+        $workflow = $this->workflowClient->newWorkflowStub(
+            TestActivityAttributesInterceptor::class,
+            WorkflowOptions::new()
+                ->withTaskQueue('interceptors')
+                ->withWorkflowExecutionTimeout(CarbonInterval::minute())
+        );
+
+        $output->writeln("Starting <comment>Interceptors.TestActivityAttributesInterceptor</comment>... ");
+
+        $run = $this->workflowClient->start($workflow);
+
+        $output->writeln(
+            \sprintf(
+                'Started: WorkflowID=<fg=magenta>%s</fg=magenta>, RunID=<fg=magenta>%s</fg=magenta>',
+                $run->getExecution()->getID(),
+                $run->getExecution()->getRunID(),
+            ),
+        );
+
+        $output->writeln(\sprintf("Result:\n<info>%s</info>", \print_r($run->getResult(), true)));
+
+        return self::SUCCESS;
+    }
+}

app/src/Interceptors/Interceptor/ActivityAttributesInterceptor.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors\Interceptor;
+
+use React\Promise\PromiseInterface;
+use ReflectionAttribute;
+use Temporal\Interceptor\Trait\WorkflowOutboundCallsInterceptorTrait;
+use Temporal\Interceptor\WorkflowOutboundCalls\ExecuteActivityInput;
+use Temporal\Interceptor\WorkflowOutboundCallsInterceptor;
+use Temporal\Samples\Interceptors\Attribute;
+use Temporal\Samples\Interceptors\Attribute\ActivityOption;
+
+/**
+ * The interceptor is used to set activity options based on attributes that are
+ * implement {@see ActivityOption} interface.
+ */
+final class ActivityAttributesInterceptor implements WorkflowOutboundCallsInterceptor
+{
+    use WorkflowOutboundCallsInterceptorTrait;
+
+    public function executeActivity(ExecuteActivityInput $input, callable $next): PromiseInterface
+    {
+        if ($input->method === null) {
+            return $next($input);
+        }
+
+        $options = $input->options;
+
+        foreach ($this->iterateOptions($input->method) as $attribute) {
+            if ($attribute instanceof Attribute\StartToCloseTimeout) {
+                \error_log(\sprintf('Redeclare start_to_close timeout of %s to %s', $input->type, $attribute->timeout));
+                $options = $options->withStartToCloseTimeout($attribute->timeout);
+            }
+        }
+
+        return $next($input->with(options: $options));
+    }
+
+    /**
+     * @return iterable<int, ActivityOption>
+     */
+    private function iterateOptions(\ReflectionMethod $method): iterable
+    {
+        $class = $method->getDeclaringClass();
+        foreach ($class->getAttributes(Attribute\ActivityOption::class, ReflectionAttribute::IS_INSTANCEOF) as $attr) {
+            yield $attr->newInstance();
+        }
+
+        foreach ($method->getAttributes(Attribute\ActivityOption::class, ReflectionAttribute::IS_INSTANCEOF) as $attr) {
+            yield $attr->newInstance();
+        }
+    }
+}

app/src/Interceptors/Interceptor/RequestLoggerInterceptor.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors\Interceptor;
+
+use Psr\Log\LoggerInterface;
+use React\Promise\PromiseInterface;
+use Temporal\Interceptor\WorkflowOutboundRequestInterceptor;
+use Temporal\Worker\Transport\Command\RequestInterface;
+
+final class RequestLoggerInterceptor implements WorkflowOutboundRequestInterceptor
+{
+    public function __construct(
+        private LoggerInterface $logger,
+    ) {
+    }
+
+    public function handleOutboundRequest(RequestInterface $request, callable $next): PromiseInterface
+    {
+        $this->logger->info(
+            \sprintf('Sending request %s', $request->getName()),
+            [
+                'headers' => \iterator_to_array($request->getHeader()),
+                'options' => $request->getOptions(),
+            ]
+        );
+
+        return $next($request);
+    }
+}

app/src/Interceptors/README.md

@@ -0,0 +1,11 @@
+# Interceptors sample
+
+This sample demonstrates how you can use Interceptors.
+
+There are few interceptors:
+- RequestLoggerInterceptor - logs all internal requests from the Workflow into the RoadRunner log.
+- ActivityAttributesInterceptor - reads [ActivityOption](./Attribute/ActivityOption.php) attributes and applies them to the Activity options.
+
+```bash
+php ./app/app.php interceptors
+```

app/src/Interceptors/Workflow/TestActivityAttributesInterceptor.php

@@ -0,0 +1,72 @@
+<?php
+
+/**
+ * This file is part of Temporal package.
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Temporal\Samples\Interceptors\Workflow;
+
+use Temporal\Activity\ActivityOptions;
+use Temporal\Common\RetryOptions;
+use Temporal\Exception\Failure\ActivityFailure;
+use Temporal\Exception\Failure\ApplicationFailure;
+use Temporal\Internal\Workflow\ActivityProxy;
+use Temporal\Samples\Interceptors\Activity\Sleeper;
+use Temporal\Samples\Interceptors\Attribute\StartToCloseTimeout;
+use Temporal\Samples\Interceptors\Interceptor\ActivityAttributesInterceptor;
+use Temporal\Workflow;
+
+#[Workflow\WorkflowInterface]
+class TestActivityAttributesInterceptor
+{
+    private ActivityProxy|Sleeper $sleeper;
+
+    public function __construct()
+    {
+        $this->sleeper = Workflow::newActivityStub(
+            Sleeper::class,
+            ActivityOptions::new()
+                ->withStartToCloseTimeout(10)
+                ->withRetryOptions(
+                    RetryOptions::new()->withMaximumAttempts(1)
+                )
+        );
+    }
+
+    #[Workflow\WorkflowMethod('Interceptors.TestActivityAttributesInterceptor')]
+    public function execute()
+    {
+        // Sleep for 1 second.
+        yield $this->sleeper->sleep(1);
+
+        /**
+         * Sleep for 7 seconds. Should fail if the {@see ActivityAttributesInterceptor} is working because there
+         * is {@see StartToCloseTimeout} attribute on the {@see Sleeper} class with 5-seconds timeout.
+         */
+        try {
+            yield $this->sleeper->sleep(7);
+            throw new ApplicationFailure("ActivityAttributesInterceptor doesn't work on the class", 'TEST', true);
+        } catch (ActivityFailure) {
+            // OK
+        }
+
+
+        /**
+         * Sleep for 3 seconds. Should fail if the {@see ActivityAttributesInterceptor} is working because there
+         * is {@see StartToCloseTimeout} attribute on the {@see Sleeper::sleep2()} method with 2-seconds timeout.
+         */
+        try {
+            yield $this->sleeper->sleep2(3);
+            throw new ApplicationFailure("ActivityAttributesInterceptor doesn't work on the method", 'TEST', true);
+        } catch (ActivityFailure) {
+            // OK
+        }
+
+        return "OK";
+    }
+}