Call an activity in a loop?

[feuzeu]

Hi,

To which extend is it advisable to call an activity in a while loop?
It seems to me that it is not recommended, since after the activity runs successfully the first time, the next calls will all return the same result without actually running the activity.

In the case I guessed it right, what is the right way to periodically check a long running operation on a third party service?
Is there an alternative to throwing an exception while the operation is still pending so the activity fails?

[rmcdaniel]

If you invoke ActivityStub::make() multiple times within a loop, it doesn't just return the same result as the first call. Instead, it will initiate and execute the activity for each call.

For example:

for ($i=0; $i < 2; $i++) {
    yield ActivityStub::make(SimpleActivity::class);
}

This is equivalent to:

yield ActivityStub::make(SimpleActivity::class);
yield ActivityStub::make(SimpleActivity::class);

In both instances, the activity will be executed twice. It's only when a workflow crashes and is reloaded that the same result might be fetched from the logs to avoid redundant operations. So, your activity will indeed run each time you call it in your loop.

[feuzeu]

Thanks for the answer.

That's the code in my workflow

        while($this->isStartable($this->status))
        {
            $this->status = yield ActivityStub::make(MakeActivity::class);

            while($this->isPending($this->status))
            {
                yield WorkflowStub::timer($this->checkInterval);
                $this->status = yield ActivityStub::make(CheckActivity::class);
            }

            yield WorkflowStub::await(fn() => $this->restarted && !$this->isWaiting($this->status));
        }

        return $this->status;

And this is the signal method.

    /**
     * @var bool
     */
    private bool $restarted = false;

    /**
     * @return void
     */
    #[SignalMethod]
    public function restart()
    {
        $this->restarted = true;
    }

I had to upgrade the app and restart the Laravel worker while the workflow was in waiting status, and after that, it kept returning to the waiting status after receiving the signal.
I think that I know understand why.

My next question is how to ensure that the CheckActivity is actually ran, and not fetched from the logs after the workflow is reloaded.

[feuzeu]

Do we need to have an option to bypass the logs for a specific call or for an activity?

[feuzeu]

What about adding the above method to the ActivityStub class?

    public static function force($activity, ...$arguments): PromiseInterface
    {
        // Same as make(), but without fetching the previous result from the logs.
        $context = WorkflowStub::getContext();
        $activity::dispatch($context->index, $context->now, $context->storedWorkflow, ...$arguments);

        ++$context->index;
        WorkflowStub::setContext($context);
        $deferred = new Deferred();
        return $deferred->promise();
    }

It's name may not be the best, so anyone can suggest another.

[rmcdaniel]

I am not sure I understand why you would want to do that?

[feuzeu]

I need to get the workflow out of the waiting status with the code I posted, after it has been reloaded.

If the CheckActivity activity result is loaded from the logs at that time, it will still return the value that made it enter the waiting status at the first place, and the workflow will stay in that status forever.
A solution to that issue is to force the execution of the CheckActivity activity, which may then return another result.

May be there's a way to rewrite the workflow to solve the issue?

[rmcdaniel]

It sounds like you are not using signals to their full potential. An activity should not be run in a loop to check status. You should send the status to the workflow.

[feuzeu]

The CheckActivity activity can return one of four results.

• Pending: the activity will be executed again after a given delay.
• Waiting: the workflow is paused and will be restarted after an external task is completed. I use the signal for that.
• Success or failure: the worflow ends with the same result.

How can I implement this use case?

[rmcdaniel]

The code you gave in #139 (comment) is how you would do that. I think the problem is that you are using $this->status inside WorkflowStub::await() as well as other places. You should use a separate variable.

[feuzeu]

Hi,

Finally I've decided to revert to a single call which throws an exception while the operation is pending, instead of a loop.
I'm not sure on how to garantee idempotency at workflow level while calling that activity in a loop.