Concurrency: Allow custom timeout settings

[clementbirkle]

Currently, it's not possible to run tasks in Concurrency that take longer than 60 seconds to complete. This limitation stems from this line in the Laravel framework:
https://github.com/laravel/framework/blob/11.x/src/Illuminate/Process/PendingProcess.php#L44

It would be helpful to allow custom timeouts for tasks. For example:

$results = Concurrency::timeout(300)->run(...);

This way, developers could set a timeout for long-running tasks as needed.

[henzeb]

EDIT: looking into the code, I see public function timeout(int $timeout) isn't that what you were looking for?

EDIT2: it also has public function forever()

[clementbirkle]

Unfortunately, we can't interact with this class directly when using the Concurrency facade.

For example this code:

[$userCount, $orderCount] = Concurrency::timeout(300)->run([
    fn () => 10,
    fn () => 20,
]);

Throw this error:

Call to undefined method Illuminate\Concurrency\ProcessDriver::timeout()

[ahuggins]

Can confirm, it looks as if these methods are there, but also seems as if we can not use them. Wonder if it is possible to pass a config item or set a config before calling Concurrency::run()?

[sebj54]

A bit late to the party, but here is what I did:

app()->bind(Illuminate\Process\Factory::class, function () {
    return new class extends Illuminate\Process\Factory
    {
        public function newPendingProcess()
        {
            return parent::newPendingProcess()->forever();
        }
    };
});

You can use this snippet at the very beginning of a controller or globally in AppServiceProvider for instance.

[lfglopes]

Thanks!!

I did find that a bit too "intrusive" though and created a new Factory instead.

Someone might find it useful:

namespace App\Utils;

use Illuminate\Process\Factory as ProcessFactory;

class ForeverProcessFactory extends ProcessFactory
{
  public function newPendingProcess()
  {
      return parent::newPendingProcess()->forever();
  }
}

Usage:

use Illuminate\Concurrency\ProcessDriver;
use App\Utils\ForeverProcessFactory;

$processDriver = new ProcessDriver(App::make(ForeverProcessFactory::class));
$processDriver->run($tasks);

[Andrei-Dr]

This approach doesn't seem to work in Laravel 12 with Concurrency. Are there any plans to extend it so we can run Concurrency::timeout(123)->run() or Concurrency::forever()->run()?

[JorgeRui]

Yes please! Any plans on extending this? I'm currently working on trying to load a 2GB XML file into a database, and following on @christophrumpel video (he was working with csvs), but found out this could increase the speed from 1hour to around 5'.

https://github.com/christophrumpel/laravel-import-million-rows/blob/main/app/Traits/ImportHelper.php

But, after 60s, the process dies due to the timeout issue. Any plans on upgrading it?

[hjbdev]

If you're using the default process driver you can implement what the ProcessDriver does under the hood yourself like this:

<?php

use Illuminate\Console\Application;
use Illuminate\Process\Factory;
use Laravel\SerializableClosure\SerializableClosure;

$processFactory = app(Factory::class);
$command = Application::formatCommandString('invoke-serialized-closure');

$results = $processFactory->pool(function (Pool $pool) use ($tasks, $command) {
    foreach ($tasks as $key => $task) {
        $pool->as($key)->forever()->path(base_path())->env([
            'LARAVEL_INVOKABLE_CLOSURE' => serialize(new SerializableClosure($task)),
        ])->command($command);
    }
})->start()->wait();