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\GeneralUtility;
use ‪TYPO3\CMS\Scheduler\Scheduler;
use ‪TYPO3\CMS\Scheduler\Task\AbstractTask;
 
class ‪SchedulerCommand extends Command
{
    protected ‪$hasTask = true;
 
    protected ‪$scheduler;
 
    protected ‪$io;
 
    protected ‪$overwrittenTaskList;
 
    protected ‪$stopTasks = false;
 
    protected ‪$forceExecution;
 
    public function ‪configure()
    {
        $this
            ->setDescription('Start the TYPO3 Scheduler from the command line.')
            ->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'
            );
    }
 
    public function ‪execute(InputInterface $input, OutputInterface ‪$output)
    {
        $this->io = new SymfonyStyle($input, ‪$output);
 
        // Make sure the _cli_ user is loaded
        ‪Bootstrap::initializeBackendAuthentication();
 
        $this->scheduler = GeneralUtility::makeInstance(Scheduler::class);
 
        ‪$overwrittenTaskList = $input->getOption('task');
        if (‪$overwrittenTaskList !== []) {
            $this->overwrittenTaskList = ‪$overwrittenTaskList;
        }
 
        $this->forceExecution = (bool)$input->getOption('force');
        $this->stopTasks = $this->‪shouldStopTasks((bool)$input->getOption('stop'));
        $this->‪loopTasks();
        return 0;
    }
 
    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)
    {
        $task->‪unmarkAllExecutions();
 
        if ($this->io->isVeryVerbose()) {
            $this->io->writeln(sprintf('Task #%d was stopped', $task->‪getTaskUid()));
        }
    }
 
    protected function ‪getTask(int $taskUid)
    {
        $force = $this->stopTasks || ‪$this->forceExecution;
        if ($force) {
            return $this->scheduler->fetchTask($taskUid);
        }
 
        $whereClause = 'uid = ' . (int)$taskUid . ' AND nextexecution != 0 AND nextexecution <= ' . ‪$GLOBALS['EXEC_TIME'];
        [$task] = $this->scheduler->fetchTasksWithCondition($whereClause);
        return $task;
    }
 
    protected function ‪loopTasks()
    {
        do {
            // 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();
                try {
                    $this->‪executeOrStopTask($task);
                } catch (\Exception $e) {
                    if ($this->io->isVerbose()) {
                        $this->io->warning($e->getMessage());
                    }
                    // 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 (\OutOfBoundsException $e) {
                if ($this->io->isVeryVerbose()) {
                    $this->io->writeln($e->getMessage());
                }
                $this->hasTask = !empty($this->overwrittenTaskList);
            } catch (\UnexpectedValueException $e) {
                if ($this->io->isVerbose()) {
                    $this->io->warning($e->getMessage());
                }
                continue;
            }
        } while ($this->hasTask);
        // Record the run in the system registry
        $this->scheduler->recordLastRun();
    }
 
    protected function ‪fetchNextTask(): AbstractTask
    {
        if ($this->overwrittenTaskList === null) {
            return $this->scheduler->fetchTask();
        }
 
        if (count($this->overwrittenTaskList) === 0) {
            throw new \OutOfBoundsException('No more tasks to execute', 1547675594);
        }
 
        $taskUid = (int)array_shift($this->overwrittenTaskList);
        $task = $this->‪getTask($taskUid);
        if (!$this->scheduler->isValidTaskObject($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()));
        }
    }
}