Model locking and blocking

[RedmarBakker]

Hi there,

I would like to suggest to add locking and blocking functionality to already loaded models. Laravel does have a lockForUpdate option when you query the model, but there is no option for models that are already queried.

Scenario

For example when using Laravel Actions, I would like to have the ability to lock an already loaded model while doing an action.

ApproveOrder example:

/**
 * @param User $for
 * @param Order $order
 * @return void
 * @throws AuthorizationException
 */
public function handle(User $for, Order $order): void
{
    DB::transaction(function() use ($for, $order) {
        $order->lock();

        // Checking if not already approved...

        // Approve order...

        OrderApproved::dispatch($order);
    });
}

Or, block:

/**
 * @param User $for
 * @param Order $order
 * @return void
 * @throws AuthorizationException
 */
public function handle(User $for, Order $order): void
{
    $order->block(function(Order $order) use ($for) {
        // Checking if not already approved...

        // Approve order...

        OrderApproved::dispatch($order);
    });
}

Code

This would then be the underlaying logic, where the lock function is equivalent to refresh but then with lockForUpdate included in the query. Optionally, lock could be modified so that it returns itself.

/**
 * @return void
 */
public function lock(): void
{
    if (! $this->exists) {
        return;
    }

    $this->setRawAttributes(
        $this->setKeysForSelectQuery($this->newQueryWithoutScopes())
            ->lockForUpdate()
            ->useWritePdo()
            ->firstOrFail()
            ->attributes
    );

    $this->load(collect($this->relations)->reject(function ($relation) {
        return $relation instanceof Pivot
            || (is_object($relation) && in_array(AsPivot::class, class_uses_recursive($relation), true));
    })->keys()->all());

    $this->syncOriginal();
}

/**
 * @param callable $action
 * @return mixed
 */
public function block(callable $action): mixed
{
    return DB::transaction(function() use ($action) {
        $this->lock();

        return $action($this);
    });
}

I implemented this myself for my own projects. Would love to hear your thoughts.

Cheers!

[ghost]

What will lock and block do on a loaded model that exist already? That model exists in memory and php is not an async language so the model will not be altered by "another thread".

[RedmarBakker]

No it's not about just created models. This is about models that exist, else locking and blocking would make no sense at all indeed. So in this example the order already exists, there is an approve action executed. To make sure it is not possible to have multiple approvals executed simultaneously, locking would help fix this. And, this could be done by re-querying the model with a lockForUpdate, but that would be an ugly solution imo.

[ghost]

Now I understand. I also use lockForUpdate in a db transaction to prevent other parallel processes altering the row from db. I think this should not be embedded in the framework as it is a custom logic just for some clients.

[RedmarBakker]

To be more precise: php is obviously not multithreaded, but multiple requests will make it possible to execute multiple actions simultaneously, therefor locking a perfect solution. But locking and blocking functions on the instance itself would make sense too right? No just only on the query builder.

[RedmarBakker]

Now I understand. I also use lockForUpdate in a db transaction to prevent other parallel processes altering the row from db. I think this should not be embedded in the framework as it is a custom logic just for some clients.

So, you would re-query the model if you work with locking within actions (that receive an already loaded model as parameter)?

[ghost]

Yes. I have the model, then I start the transaction, i read the model again from write replica from db and do what I need with it. Then commit the transaction. If a parallel process tries the same it will die on trying to obtain the lock from db and that will he handled with a try catch. In a multi container application the db lock is the safest way and also atomic.