Merge branch 'master' into destroyable

# Conflicts:
#	src/Internal/Workflow/Process/Scope.php

Author: roxblnfk

psalm-baseline.xml

@@ -1176,6 +1176,14 @@
     <PropertyNotSetInConstructor>
       <code><![CDATA[$coroutine]]></code>
     </PropertyNotSetInConstructor>
+    <RedundantCondition>
+      <code><![CDATA[$this->context?->destroy()]]></code>
+      <code><![CDATA[$this->scopeContext?->destroy()]]></code>
+    </RedundantCondition>
+    <TypeDoesNotContainNull>
+      <code><![CDATA[$this->context]]></code>
+      <code><![CDATA[$this->scopeContext]]></code>
+    </TypeDoesNotContainNull>
     <UndefinedInterfaceMethod>
       <code><![CDATA[catch]]></code>
       <code><![CDATA[finally]]></code>

src/Common/RetryOptions.php

@@ -68,6 +68,7 @@ class RetryOptions extends Options
      * is 1.0 then it is used for all retries.
      */
     #[Marshal(name: 'initial_interval', type: DurationJsonType::class, nullable: true)]
+    #[Marshal(name: 'InitialInterval', type: DurationJsonType::class, nullable: true)]
     public ?\DateInterval $initialInterval = self::DEFAULT_INITIAL_INTERVAL;
 
     /**
@@ -77,6 +78,7 @@ class RetryOptions extends Options
      * Note: Must be greater than 1.0
      */
     #[Marshal(name: 'backoff_coefficient')]
+    #[Marshal(name: 'BackoffCoefficient')]
     public float $backoffCoefficient = self::DEFAULT_BACKOFF_COEFFICIENT;
 
     /**
@@ -86,6 +88,7 @@ class RetryOptions extends Options
      * Default is 100x of {@see $initialInterval}.
      */
     #[Marshal(name: 'maximum_interval', type: DurationJsonType::class, nullable: true)]
+    #[Marshal(name: 'MaximumInterval', type: DurationJsonType::class, nullable: true)]
     public ?\DateInterval $maximumInterval = self::DEFAULT_MAXIMUM_INTERVAL;
 
     /**
@@ -96,6 +99,7 @@ class RetryOptions extends Options
      * @var int<0, max>
      */
     #[Marshal(name: 'maximum_attempts')]
+    #[Marshal(name: 'MaximumAttempts')]
     public int $maximumAttempts = self::DEFAULT_MAXIMUM_ATTEMPTS;
 
     /**
@@ -105,6 +109,7 @@ class RetryOptions extends Options
      * @var ExceptionsList
      */
     #[Marshal(name: 'non_retryable_error_types')]
+    #[Marshal(name: 'NonRetryableErrorTypes')]
     public array $nonRetryableExceptions = self::DEFAULT_NON_RETRYABLE_EXCEPTIONS;
 
     public function mergeWith(?MethodRetry $retry = null): self

src/Internal/Marshaller/MarshallingRule.php

@@ -13,9 +13,6 @@
 
 use Temporal\Internal\Marshaller\Type\TypeInterface;
 
-/**
- * @internal
- */
 class MarshallingRule
 {
     /**

src/Internal/Marshaller/Type/ArrayType.php

@@ -63,6 +63,10 @@ public static function makeRule(\ReflectionProperty $property): ?MarshallingRule
      */
     public function parse($value, $current): array
     {
+        if ($value === null) {
+            return [];
+        }
+
         if (!\is_array($value)) {
             throw new \InvalidArgumentException(\sprintf(self::ERROR_INVALID_TYPE, \get_debug_type($value)));
         }

src/Internal/Transport/Router/DestroyWorkflow.php

@@ -17,6 +17,7 @@
 use Temporal\Internal\Support\GarbageCollector;
 use Temporal\Internal\Workflow\Process\Process;
 use Temporal\Internal\Workflow\ProcessCollection;
+use Temporal\Worker\FeatureFlags;
 use Temporal\Worker\LoopInterface;
 use Temporal\Worker\Transport\Command\ServerRequestInterface;
 
@@ -29,12 +30,14 @@ class DestroyWorkflow extends WorkflowProcessAwareRoute
     private const GC_TIMEOUT_SECONDS = 30;
 
     private GarbageCollector $gc;
+    private bool $throwDestructException;
 
     public function __construct(
         ProcessCollection $running,
         protected LoopInterface $loop,
     ) {
         $this->gc = new GarbageCollector(self::GC_THRESHOLD, self::GC_TIMEOUT_SECONDS);
+        $this->throwDestructException = FeatureFlags::$throwDestructMemorizedInstanceException;
         parent::__construct($running);
     }
 
@@ -51,7 +54,7 @@ public function kill(string $runId): array
         $process = $this->running
             ->pull($runId, "Unable to kill workflow because workflow process #$runId was not found");
 
-        $process->cancel(new DestructMemorizedInstanceException());
+        $this->throwDestructException and $process->cancel(new DestructMemorizedInstanceException());
         $this->loop->once(
             LoopInterface::ON_FINALLY,
             function () use ($process): void {

src/Internal/Workflow/Process/Scope.php

@@ -293,9 +293,17 @@ public function onAwait(Deferred $deferred): void
 
     public function destroy(): void
     {
-        $this->context->destroy();
-        $this->scopeContext->destroy();
-        unset($this->coroutine);
+        $this->context?->destroy();
+        $this->scopeContext?->destroy();
+        unset(
+            $this->coroutine,
+            $this->context,
+            $this->scopeContext,
+            $this->deferred,
+            $this->services,
+            $this->onCancel,
+            $this->onClose,
+        );
     }
 
     /**

src/Worker/FeatureFlags.php

@@ -4,6 +4,7 @@
 
 namespace Temporal\Worker;
 
+use Temporal\Exception\DestructMemorizedInstanceException;
 use Temporal\Workflow;
 
 /**
@@ -48,4 +49,11 @@ final class FeatureFlags
      * @since SDK 2.16.0
      */
     public static bool $cancelAbandonedChildWorkflows = true;
+
+    /**
+     * Throw {@see DestructMemorizedInstanceException} when a Workflow instance is destructed.
+     *
+     * @since SDK 2.16.0
+     */
+    public static bool $throwDestructMemorizedInstanceException = true;
 }

src/Workflow/WorkflowInfo.php

@@ -16,6 +16,7 @@
 use Temporal\Client\ClientOptions;
 use Temporal\Common\CronSchedule;
 use Temporal\Common\Priority;
+use Temporal\Common\RetryOptions;
 use Temporal\Common\TypedSearchAttributes;
 use Temporal\Internal\Marshaller\Meta\Marshal;
 use Temporal\Internal\Marshaller\Type\ArrayType;
@@ -105,6 +106,12 @@ final class WorkflowInfo
     #[Marshal(name: 'ParentWorkflowNamespace')]
     public ?string $parentNamespace = null;
 
+    /**
+     * @since SDK 2.16.0
+     */
+    #[Marshal(name: 'RootWorkflowExecution', type: NullableType::class, of: WorkflowExecution::class)]
+    public ?WorkflowExecution $rootExecution = null;
+
     #[Marshal(name: 'ParentWorkflowExecution', type: NullableType::class, of: WorkflowExecution::class)]
     public ?WorkflowExecution $parentExecution = null;
 
@@ -137,6 +144,12 @@ final class WorkflowInfo
     #[Marshal(name: 'Priority')]
     public Priority $priority;
 
+    /**
+     * @since SDK 2.16.0
+     */
+    #[Marshal(name: 'RetryPolicy')]
+    public ?RetryOptions $retryOptions = null;
+
     /**
      * WorkflowInfo constructor.
      */

tests/Acceptance/Extra/Activity/ActivityInfoTest.php

@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Temporal\Tests\Acceptance\Extra\Activity\ActivityInfo;
+
+use PHPUnit\Framework\Attributes\Test;
+use React\Promise\PromiseInterface;
+use Temporal\Activity;
+use Temporal\Client\WorkflowStubInterface;
+use Temporal\Common\RetryOptions;
+use Temporal\Tests\Acceptance\App\Attribute\Stub;
+use Temporal\Tests\Acceptance\App\TestCase;
+use Temporal\Workflow;
+use Temporal\Workflow\WorkflowInterface;
+use Temporal\Workflow\WorkflowMethod;
+
+class ActivityInfoTest extends TestCase
+{
+    #[Test]
+    public static function retryPolicy(
+        #[Stub('Extra_Activity_ActivityInfo', args: [TestWorkflow::ARG_RETRY_OPTIONS])]
+        WorkflowStubInterface $stub,
+    ): void {
+        self::markTestSkipped('See https://github.com/temporalio/sdk-php/issues/602');
+
+        $result = $stub->getResult(type: 'array');
+        self::assertSame([
+            "initial_interval" => ['seconds' => 1, 'nanos' => 0],
+            "backoff_coefficient" => 3,
+            "maximum_interval" => ['seconds' => 120, 'nanos' => 0],
+            "maximum_attempts" => 20,
+            "non_retryable_error_types" => [],
+        ], $result);
+    }
+}
+
+
+#[WorkflowInterface]
+class TestWorkflow
+{
+    public const ARG_RETRY_OPTIONS = 'retryPolicy';
+
+    #[WorkflowMethod(name: "Extra_Activity_ActivityInfo")]
+    public function handle(string $arg)
+    {
+        return yield match ($arg) {
+            self::ARG_RETRY_OPTIONS => $this->getRetryOptions(),
+        };
+    }
+
+    private function getRetryOptions(): PromiseInterface
+    {
+        return Workflow::newActivityStub(
+            TestActivity::class,
+            Activity\ActivityOptions::new()
+                ->withRetryOptions(
+                    RetryOptions::new()
+                        ->withMaximumAttempts(20)
+                        ->withBackoffCoefficient(3.0)
+                        ->withInitialInterval('1 second')
+                        ->withMaximumInterval('2 minutes'),
+                )
+                ->withScheduleToCloseTimeout(10),
+        )
+            ->retryOptions();
+    }
+}
+
+#[Activity\ActivityInterface(prefix: 'Extra_Activity_ActivityInfo.')]
+class TestActivity
+{
+    #[Activity\ActivityMethod]
+    public function retryOptions()
+    {
+        return Activity::getInfo()->retryOptions;
+    }
+}