nack requeue error

[shellphy]

In roadrunner-php jobs sdk, I found that the parameters of nack message passing are:

$this->respond(Type::NACK, [
    'message' => (string) $message,
    'redelivery' => $redelivery,
    'delay_seconds' => $this->delay,
]);

and

private function respond(int $type, array $data = []): void
{
    if ($this->completed === null) {
        try {
            $body = \json_encode(['type' => $type, 'data' => $data], JSON_THROW_ON_ERROR);

            $this->worker->respond(new Payload($body));
        } catch (\JsonException $e) {
            throw new SerializationException($e->getMessage(), $e->getCode(), $e);
        } catch (\Throwable $e) {
            throw new JobsException($e->getMessage(), (int)$e->getCode(), $e);
        }
        $this->completed = $type;
    }
}

The message structure defined in golang's jobs plugin is:

package protocol

type errorResp struct {
	Msg     string              `json:"message"`
	Delay   int                 `json:"delay_seconds"`
	Headers map[string][]string `json:"headers"`
	Requeue bool                `json:"requeue"`
}

One is redelivery and the other is requeue, which makes nack's requeue ineffective

[rustatian]

Hey @shellphy 👋
Requeue is used on the RR's part. respond was preserved to not break backward compatibility. You should simply use nack.

[shellphy]

I am using nats jobs, and nats jobs cannot use delay_seconds when requeue is used, but delay_seconds can be used in nack.

[rustatian]

Could you please rephrase? I'm not sure if I'm following.

[shellphy]

That is, I am using the nats jobs driver and I want to delay retry if the task fails.

If I use requeue() with delay_seconds, the nats jobs driver is not supported:

func (c *Driver) requeue(item *Item) error {
	const op = errors.Op("nats_requeue")
	if item.Options.Delay > 0 {
		return errors.E(op, errors.Str("nats doesn't support delayed messages, see: https://github.com/nats-io/nats-streaming-server/issues/324"))
	}
    ...
...

If I use nack() with delay_seconds, the nats jobs driver is supported, and then the delay option will only take effect if requeue=true:

func (i *Item) NackWithOptions(requeue bool, delay int) error {
	if atomic.LoadUint64(i.Options.stopped) == 1 {
		return errors.Str("failed to NACK the JOB, the pipeline is probably stopped")
	}

	// if the user requested to requeue the message
	if requeue {
		return i.Options.nakWithDelay(time.Second * time.Duration(delay))
	}

	// if the user requested to delete the message
	return i.Options.term()
}

However, when passing nack messages in php, Only redelevery but no requeue

[rustatian]

Yes, this is how it works. requeue as you may see - private. You should use NackWithOptions.

[shellphy]

But the requeue parameter is always false in NackWithOptions

[shellphy]

Is there a plan to solve this problem?

[rustatian]

No, requeue is not always false.

[rustatian]

I'm not sure how did you determine, that requeue is always false. It is an in arg in the method. You can't say it's always false without the caller.

[shellphy]

Because the response struct is:

package protocol

type errorResp struct {
	Msg     string              `json:"message"`
	Delay   int                 `json:"delay_seconds"`
	Headers map[string][]string `json:"headers"`
	Requeue bool                `json:"requeue"`
}

No requeue field is sent in nack().

[rustatian]

If you're sure this is the bug - send a PR into the PHP library.

[shellphy]

ok