Remove $retryProducer from WorkerInterface::process()

It was only ever supplied by `SynchronousPushHandler`, so that a message
failed under `SyncQueueProducer` could be re-queued into the producer that
executed it. With no broker behind that producer, such a retry is an
immediate recursive re-execution in the same call stack: it blocks the
caller for the whole attempt budget, grows the stack by one frame per
attempt, and silently drops the backoff, since `DelayEnvelope` needs an
adapter to be honored.

Retry destinations are now resolved uniformly in both modes: an explicit
`targetQueue`, or `QueueProducerProviderInterface` keyed by the execution
queue name. When neither is configured, retry fails with
`InvalidQueueConfigException` instead of degrading silently.

`SynchronousPushHandler` now takes the queue name instead of the producer,
which also removes the self-reference from `SyncQueueProducer`.

Author: vjik

docs/guide/en/error-handling-advanced.md

@@ -19,7 +19,6 @@ This document covers advanced internals of the failure handling pipeline, built-
     - the message
     - the caught exception
     - the logical queue name
-    - an optional direct retry producer (provided for synchronous producer execution)
 
 4. A failure pipeline is selected by queue name
 
@@ -84,7 +83,7 @@ This interface has the only method `processFailure` with these parameters:
 - [`FailureHandlingRequest $request`](../../../src/Middleware/FailureHandling/FailureHandlingRequest.php) - a request for a message handling. It consists of
     - a [message](../../../src/Message/MessageInterface.php)
     - a `Throwable $exception` object thrown on the `request` handling
-    - the logical queue name the message came from and, when available, a direct retry producer
+    - the logical queue name the message came from
 - `FailureHandlerInterface $handler` - failure strategy pipeline continuation. Your Middleware should call `$handler->handleFailure($request)` when the middleware itself should not interrupt failure pipeline execution.
 
 > Note: your strategy have to check by its own if it should be applied. Look into [`SendAgainMiddleware::suits()`](../../../src/Middleware/FailureHandling/Implementation/SendAgainMiddleware.php#L54) for an example.

docs/guide/en/error-handling.md

@@ -87,8 +87,8 @@ Failures of messages that arrived in the `failed-messages` queue directly (bypas
 
  - `id` - A unique string. Allows to use this strategy more than once for the same message, just like in example above.
  - `maxAttempts` - Maximum attempts count for this strategy with the given $id before it will give up.
- - `targetQueue` - An optional `QueueProducerInterface` for an explicit retry destination. When it is `null`, synchronous execution supplies its originating producer; asynchronous execution resolves the originating queue name through `producerProvider`.
- - `producerProvider` - The `QueueProducerProviderInterface` used to resolve the source producer for asynchronous retries when no `targetQueue` is supplied. Configure it, or provide `targetQueue`; otherwise retry fails with a configuration error.
+ - `targetQueue` - An optional `QueueProducerInterface` for an explicit retry destination. When it is `null`, the originating queue name is resolved through `producerProvider`.
+ - `producerProvider` - The `QueueProducerProviderInterface` used to resolve the source producer when no `targetQueue` is supplied. Configure it, or provide `targetQueue`; otherwise retry fails with a configuration error.
 
  State tracking:
 
@@ -106,8 +106,8 @@ It's configured via constructor parameters, too. Here they are:
  - `delayInitial` - The initial delay that will be applied to a message for the first time. It must be a positive float. 
  - `delayMaximum` - The maximum delay which can be applied to a single message. Must be above the `delayInitial`.
  - `exponent` - Message handling delay will be multiplied by exponent each time it fails.
- - `queue` - An optional `QueueProducerInterface` retry destination. When it is `null`, synchronous execution supplies its originating producer; asynchronous execution resolves the originating queue name through `producerProvider`.
- - `producerProvider` - The `QueueProducerProviderInterface` used for that asynchronous source-producer lookup.
+ - `queue` - An optional `QueueProducerInterface` retry destination. When it is `null`, the originating queue name is resolved through `producerProvider`.
+ - `producerProvider` - The `QueueProducerProviderInterface` used for that source-producer lookup.
 
  Requirements:
 

docs/guide/en/queue-capabilities.md

@@ -20,4 +20,4 @@ $definitions = [
 
 `QueueFactoryProvider` accepts factory definitions in each role. `PredefinedQueueProvider` uses the same outer shape but each role value must already be its respective interface instance. A raw definition such as `'orders' => ['class' => AsyncQueueProducer::class]`, an empty role map, and unknown role keys are invalid.
 
-`QueueInterface`, `Queue`, and `QueueProviderInterface` were removed before release. Replace them with `QueueProducerInterface`, `SyncQueueProducer` / `AsyncQueueProducer` / `QueueConsumer`, and the relevant typed provider. Synchronous consumers retain no-op `run()` and `listen()` behavior when no adapter is configured. Default retry of an asynchronously consumed message resolves a producer for the execution queue name through a configured producer provider; if none is available it fails with an actionable configuration error rather than dropping the message.
+`QueueInterface`, `Queue`, and `QueueProviderInterface` were removed before release. Replace them with `QueueProducerInterface`, `SyncQueueProducer` / `AsyncQueueProducer` / `QueueConsumer`, and the relevant typed provider. Synchronous consumers retain no-op `run()` and `listen()` behavior when no adapter is configured. Default retry resolves a producer for the execution queue name through a configured producer provider, in both synchronous and asynchronous execution; if none is available it fails with an actionable configuration error rather than dropping the message.

src/Debug/QueueWorkerInterfaceProxy.php

@@ -5,7 +5,6 @@
 namespace Yiisoft\Queue\Debug;
 
 use Yiisoft\Queue\Message\MessageInterface;
-use Yiisoft\Queue\QueueProducerInterface;
 use Yiisoft\Queue\Worker\WorkerInterface;
 
 /**
@@ -18,12 +17,9 @@ public function __construct(
         private readonly QueueCollector $collector,
     ) {}
 
-    public function process(
-        MessageInterface $message,
-        string $queueName,
-        ?QueueProducerInterface $retryProducer = null,
-    ): void {
+    public function process(MessageInterface $message, string $queueName): void
+    {
         $this->collector->collectWorkerProcessing($message, $queueName);
-        $this->worker->process($message, $queueName, $retryProducer);
+        $this->worker->process($message, $queueName);
     }
 }

src/Middleware/FailureHandling/FailureHandlingRequest.php

@@ -6,15 +6,13 @@
 
 use Throwable;
 use Yiisoft\Queue\Message\MessageInterface;
-use Yiisoft\Queue\QueueProducerInterface;
 
 final class FailureHandlingRequest
 {
     public function __construct(
         private MessageInterface $message,
         private Throwable $exception,
         private string $queueName,
-        private ?QueueProducerInterface $retryProducer = null,
     ) {}
 
     public function getMessage(): MessageInterface
@@ -33,12 +31,6 @@ public function getQueueName(): string
         return $this->queueName;
     }
 
-    /** Direct retry target used by synchronous producer execution, if any. */
-    public function getRetryProducer(): ?QueueProducerInterface
-    {
-        return $this->retryProducer;
-    }
-
     public function withMessage(MessageInterface $message): self
     {
         $instance = clone $this;

src/Middleware/FailureHandling/Implementation/ExponentialDelayMiddleware.php

@@ -63,9 +63,6 @@ private function producer(FailureHandlingRequest $request): QueueProducerInterfa
         if ($this->queue !== null) {
             return $this->queue;
         }
-        if ($request->getRetryProducer() !== null) {
-            return $request->getRetryProducer();
-        }
         if ($this->producerProvider === null) {
             throw new InvalidQueueConfigException(sprintf('Cannot retry queue "%s": configure a producer target or QueueProducerProviderInterface.', $request->getQueueName()));
         }

src/Middleware/FailureHandling/Implementation/SendAgainMiddleware.php

@@ -40,7 +40,7 @@ public function processFailure(FailureHandlingRequest $request, FailureHandlerIn
             return $handler->handleFailure($request);
         }
         $envelope = new FailureEnvelope($message, [$this->getMetaKey() => $this->getAttempts($message) + 1]);
-        $producer = $this->targetQueue ?? $request->getRetryProducer() ?? $this->sourceProducer($request);
+        $producer = $this->targetQueue ?? $this->sourceProducer($request);
         $envelope = $producer->push($envelope);
         return $request->withMessage($envelope);
     }

src/Middleware/Push/SynchronousPushHandler.php

@@ -5,7 +5,6 @@
 namespace Yiisoft\Queue\Middleware\Push;
 
 use Yiisoft\Queue\Message\MessageInterface;
-use Yiisoft\Queue\QueueProducerInterface;
 use Yiisoft\Queue\Worker\WorkerInterface;
 
 /**
@@ -15,12 +14,12 @@ final class SynchronousPushHandler implements PushHandlerInterface
 {
     public function __construct(
         private readonly WorkerInterface $worker,
-        private readonly QueueProducerInterface $queue,
+        private readonly string $queueName,
     ) {}
 
     public function handlePush(MessageInterface $message): MessageInterface
     {
-        $this->worker->process($message, $this->queue->getQueueName(), $this->queue);
+        $this->worker->process($message, $this->queueName);
 
         return $message;
     }

src/SyncQueueProducer.php

@@ -34,7 +34,7 @@ public function __construct(
         $this->dispatcher = new PushMiddlewareDispatcher(
             middlewareFactory: $middlewareConfig->middlewareFactory,
             middlewareDefinitions: [...$middlewareConfig->commonMiddlewareDefinitions, ...$middlewareDefinitions],
-            finalHandler: new SynchronousPushHandler($worker, $this),
+            finalHandler: new SynchronousPushHandler($worker, $this->queueName),
         );
     }
 

src/Worker/Worker.php

@@ -15,7 +15,6 @@
 use Yiisoft\Queue\Middleware\FailureHandling\FailureFinalHandler;
 use Yiisoft\Queue\Middleware\FailureHandling\FailureHandlingRequest;
 use Yiisoft\Queue\Middleware\FailureHandling\FailureMiddlewareDispatcher;
-use Yiisoft\Queue\QueueProducerInterface;
 use Yiisoft\Queue\Message\IdEnvelope;
 
 final class Worker implements WorkerInterface
@@ -30,11 +29,8 @@ public function __construct(
     /**
      * @throws Throwable
      */
-    public function process(
-        MessageInterface $message,
-        string $queueName,
-        ?QueueProducerInterface $retryProducer = null,
-    ): void {
+    public function process(MessageInterface $message, string $queueName): void
+    {
         $messageId = IdEnvelope::fromMessage($message)->getId();
         if ($messageId === null) {
             $this->logger->info('Processing message without ID.');
@@ -48,7 +44,7 @@ public function process(
             $finalHandler = new ConsumeFinalHandler($handler->handle(...));
             $this->consumeMiddlewareDispatcher->dispatch($request, $finalHandler);
         } catch (Throwable $exception) {
-            $request = new FailureHandlingRequest($request->getMessage(), $exception, $request->getQueueName(), $retryProducer);
+            $request = new FailureHandlingRequest($request->getMessage(), $exception, $request->getQueueName());
 
             try {
                 $this->failureMiddlewareDispatcher->dispatch($request, new FailureFinalHandler());