Should we have cron jobs?

[graid2030]

It can be a new plugin like a service
example:

version: "3"

cron:
  analytics:
    mask: "0 0 1 * *" // or "@monthly"
    cron_name_in_log: true
    timeout_stop_sec: 100
    run_once: true // or process_num=1
    exec_timeout: 0s
    command: "php analytics.php"
    env:
      - foo: "BAR"
    user: "www-data"

[graid2030]

And it's a bit inconsistent

timeout_stop_sec: 100
exec_timeout: 0s

but we already have that.

[rustatian]

You can do that inside your PHP script or basically in any program you execute in the command option. But honestly speaking, there are much more specialized tools to do that rather than RR.

[rustatian]

But, you know, I'm always open to PRs. We also have a special community plugins section in the documentation. Thus, if you create such a plugin, I'd be happy to add it to our docs (RR can be built with external plugins with Velox).

[graid2030]

This is the same idea for which the "service" plugin exists. For example, I can add CronJobs to Kuber or install cron iinside container. But we already have RR, which manages PHP processes.

[graid2030]

I'm still testing the idea that it's not just me who cares about this. Writing a plugin just for myself, especially since I've already found a workaround, is a thankless task =)

[rustatian]

This is your contribution to OSS, definitely not a thankless task :)

[shellphy]

I had the same problem. My solution is the roadrunner service.

First I install an extension package jobbyphp/jobby in php and write a console php program:

<?php

declare(strict_types=1);

namespace App\Command;

use App\Libraries\Core\Yii;
use Jobby\Jobby;
use Symfony\Component\Console\Attribute\AsCommand;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

#[AsCommand(
    name: 'scheduler',
    description: '定时任务',
    hidden: false,
)]
final class SchedulerCommand extends Command
{
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $jobby = new Jobby();
        $this->registerTasks($jobby);

        while (true) {
            $waitTime = 60 - (time() % 60);
            sleep($waitTime);
            $jobby->run();
        }
    }

    private function registerTasks(Jobby $jobby)
    {
        $yii = Yii::aliases()->get('@root/yii');

        $jobby->add('HelloCommand', [
            'command' => "php {$yii} hello",
            'output' => Yii::aliases()->get('@runtime/logs/cron/hello.log'),
            'enable' => true,
            'schedule' => '* * * * *',
        ]);
    }
}

then add a cron service in rr.yml:

service:
  # 定时任务
  cron:
    service_name_in_log: true
    command: "php php/yii scheduler:run"
    timeout_stop_sec: 10

Isn't it more flexible to control how often timed tasks are executed in php?

[rauanmayemir]

One thing that worries me about having cron jobs in RR is that RR is supposed to be scaled horizontally meaning ran as multiple replicas, so you might be better off running a dedicated instance with crond, go-cron, or what have you.

[shellphy]

Using crond or go-cron is better, but if the roadrunner has multiple instances, there is still a problem. So the most thorough timing task data should be stored externally, such as in a database or cache, and then locked to avoid repeated execution, but for simple cases, the implementation in php is quite sufficient.

[shellphy]

I think we should implement a special scheduled task plugin, which is actually very general purpose.

For example, in our application, users can create a schedule to send regular emails to a specified group of customers at 9 o 'clock every day. These scheduled tasks can be dynamically configured, rather than written in crontab.

Of course, this can be done by writing a while (true) loop in php, and then monitoring and managing the process through roadrunner's service. At the php level, there are three ways to do this:
1, open a php process, and loop through the tasks that need to be executed in the process, the main problem is that if the task is time-consuming, it may block other tasks.
2, open a php main process, the main process is used to monitor the task that needs to be executed, and when it finds the task that needs to be executed, it opens a sub-process to perform the task, so that it will not block other tasks. But the main problem is that it's not very easy to monitor child processes in php, when does the child process end? What should I do if the memory is out?
3, open a php main process, when a task needs to be executed, push it to jobs and execute it in the consumer, but if it is a lot of time-consuming complex statistical tasks, it may need to run for 5 minutes, which will occupy the pool of jobs for a long time.

If this is done by a roadrunner, it can be done:

1. roadrunner can store scheduled task data entries to redis or database
2. roadrunner provides rpc methods to the php layer: rpc methods for creating, deleting, modifying and querying scheduled tasks
3. When roadrunner monitors that a task needs to be executed, php executes it through the pool worker, which can better monitor the scheduled task worker

[rustatian]

You can just use temporal with RR: https://docs.temporal.io/develop/php/schedules