SchedulerCommand.php

Go to the documentation of this file.

<?php
 
/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
 
namespace ‪TYPO3\CMS\Scheduler\Command;
 
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Input\InputOption;
use Symfony\Component\Console\Output\OutputInterface;
use Symfony\Component\Console\Style\SymfonyStyle;
use ‪TYPO3\CMS\Core\Core\Bootstrap;
use ‪TYPO3\CMS\Core\Utility\MathUtility;
use ‪TYPO3\CMS\Scheduler\Domain\Repository\SchedulerTaskRepository;
use ‪TYPO3\CMS\Scheduler\Scheduler;
use ‪TYPO3\CMS\Scheduler\Task\AbstractTask;
use ‪TYPO3\CMS\Scheduler\Validation\Validator\TaskValidator;
 
class ‪SchedulerCommand extends Command
{
    protected ‪$io;
 
    protected ‪$overwrittenTaskList;
 
    protected ‪$stopTasks = false;
 
    protected ‪$forceExecution;
 
    public function ‪__construct(
        protected readonly ‪Scheduler $scheduler,
        protected readonly ‪SchedulerTaskRepository $taskRepository
    ) {
        parent::__construct();
    }
 
    public function ‪configure()
    {
        $this
            ->setHelp('If no parameter is given, the scheduler executes any tasks that are overdue to run.
Call it like this: typo3/sysext/core/bin/typo3 scheduler:run --task=13 -f')
            ->addOption(
                'task',
                'i',
                InputOption::VALUE_OPTIONAL | InputOption::VALUE_IS_ARRAY,
                'UID of a specific task. Can be provided multiple times to execute multiple tasks sequentially.'
            )
            ->addOption(
                'force',
                'f',
                InputOption::VALUE_NONE,
                'Force execution of the task which is passed with --task option'
            )
            ->addOption(
                'stop',
                's',
                InputOption::VALUE_NONE,
                'Stop the task which is passed with --task option'
            );
    }
 
    protected function ‪execute(InputInterface $input, OutputInterface ‪$output): int
    {
        $this->io = new SymfonyStyle($input, ‪$output);
 
        // Make sure the _cli_ user is loaded
        ‪Bootstrap::initializeBackendAuthentication();
 
        ‪$overwrittenTaskList = $input->getOption('task');
        ‪$overwrittenTaskList = is_array(‪$overwrittenTaskList) ? ‪$overwrittenTaskList : [];
        ‪$overwrittenTaskList = array_filter(‪$overwrittenTaskList, static fn($value) => ‪MathUtility::canBeInterpretedAsInteger($value));
        ‪$overwrittenTaskList = array_map('intval', ‪$overwrittenTaskList);
        if (‪$overwrittenTaskList !== []) {
            $this->overwrittenTaskList = ‪$overwrittenTaskList;
        }
 
        $this->forceExecution = (bool)$input->getOption('force');
        $this->stopTasks = $this->‪shouldStopTasks((bool)$input->getOption('stop'));
        return $this->‪loopTasks() ? Command::SUCCESS : Command::FAILURE;
    }
 
    protected function ‪shouldStopTasks(bool $stopOption): bool
    {
        if (!$stopOption) {
            return false;
        }
 
        if ($this->overwrittenTaskList !== []) {
            return true;
        }
 
        if ($this->io->isVerbose()) {
            $this->io->warning('Stopping tasks is only possible when the --task option is provided.');
        }
        return false;
    }
 
    protected function ‪stopTask(‪AbstractTask $task)
    {
        $this->taskRepository->removeAllRegisteredExecutionsForTask($task);
        if ($this->io->isVeryVerbose()) {
            $this->io->writeln(sprintf('Task #%d was stopped', $task->‪getTaskUid()));
        }
    }
 
    protected function ‪getTask(int $taskUid): ?‪AbstractTask
    {
        $force = $this->stopTasks || ‪$this->forceExecution;
        if ($force) {
            return $this->taskRepository->findByUid($taskUid);
        }
 
        return $this->taskRepository->findNextExecutableTaskForUid($taskUid);
    }
 
    protected function ‪loopTasks(): bool
    {
        $hasError = false;
        do {
            $task = null;
            // Try getting the next task and execute it
            // If there are no more tasks to execute, an exception is thrown by \TYPO3\CMS\Scheduler\Scheduler::fetchTask()
            try {
                $task = $this->‪fetchNextTask();
                if ($task === null) {
                    break;
                }
                try {
                    $this->‪executeOrStopTask($task);
                } catch (\‪Exception $e) {
                    $this->io->getErrorStyle()->error($e->getMessage());
                    $hasError = true;
                    // We ignore any exception that may have been thrown during execution,
                    // as this is a background process.
                    // The exception message has been recorded to the database anyway
                    continue;
                }
            } catch (\UnexpectedValueException $e) {
                $this->io->getErrorStyle()->error($e->getMessage());
                $hasError = true;
                continue;
            }
        } while ($task !== null);
        // Record the run in the system registry
        $this->scheduler->recordLastRun();
        return !$hasError;
    }
 
    protected function ‪fetchNextTask(): ?‪AbstractTask
    {
        if ($this->overwrittenTaskList === null) {
            return $this->taskRepository->findNextExecutableTask();
        }
 
        if (count($this->overwrittenTaskList) === 0) {
            return null;
        }
 
        $taskUid = (int)array_shift($this->overwrittenTaskList);
        $task = $this->‪getTask($taskUid);
        if (!(new TaskValidator())->isValid($task)) {
            throw new \UnexpectedValueException(
                sprintf('The task #%d is not scheduled for execution or does not exist.', $taskUid),
                1547675557
            );
        }
        return $task;
    }
 
    protected function ‪executeOrStopTask(‪AbstractTask $task): void
    {
        if ($this->stopTasks) {
            $this->‪stopTask($task);
            return;
        }
 
        $this->scheduler->executeTask($task);
        if ($this->io->isVeryVerbose()) {
            $this->io->writeln(sprintf('Task #%d was executed', $task->‪getTaskUid()));
        }
    }
}