Scheduler.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;
 
use Doctrine\DBAL\Exception as DBALException;
use Psr\Log\LoggerInterface;
use ‪TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Database\Query\QueryHelper;
use ‪TYPO3\CMS\Core\Registry;
use ‪TYPO3\CMS\Core\SingletonInterface;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Scheduler\Task\AbstractTask;
 
class ‪Scheduler implements ‪SingletonInterface
{
    protected LoggerInterface ‪$logger;
 
    public ‪$extConf = [];
 
    public function ‪__construct(LoggerInterface ‪$logger)
    {
        $this->logger = ‪$logger;
        // Get configuration from the extension manager
        $this->extConf = GeneralUtility::makeInstance(ExtensionConfiguration::class)->get('scheduler');
        if (empty($this->extConf['maxLifetime'])) {
            $this->extConf['maxLifetime'] = 1440;
        }
        // Clean up the serialized execution arrays
        $this->‪cleanExecutionArrays();
    }
 
    public function ‪addTask(AbstractTask $task)
    {
        $taskUid = $task->‪getTaskUid();
        if (empty($taskUid)) {
            ‪$fields = [
                'crdate' => ‪$GLOBALS['EXEC_TIME'],
                'disable' => (int)$task->‪isDisabled(),
                'description' => $task->‪getDescription(),
                'task_group' => $task->‪getTaskGroup(),
                'serialized_task_object' => 'RESERVED',
            ];
            $connection = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getConnectionForTable('tx_scheduler_task');
            $result = $connection->insert(
                'tx_scheduler_task',
                ‪$fields,
                ['serialized_task_object' => ‪Connection::PARAM_LOB]
            );
 
            if ($result) {
                $task->‪setTaskUid($connection->lastInsertId('tx_scheduler_task'));
                $task->‪save();
                $result = true;
            } else {
                $result = false;
            }
        } else {
            $result = false;
        }
        return $result;
    }
 
    protected function ‪cleanExecutionArrays()
    {
        $tstamp = ‪$GLOBALS['EXEC_TIME'];
        $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
        $queryBuilder = $connectionPool->getQueryBuilderForTable('tx_scheduler_task');
 
        // Select all tasks with executions
        // NOTE: this cleanup is done for disabled tasks too,
        // to avoid leaving old executions lying around
        $result = $queryBuilder->select('uid', 'serialized_executions', 'serialized_task_object')
            ->from('tx_scheduler_task')
            ->where(
                $queryBuilder->expr()->neq(
                    'serialized_executions',
                    $queryBuilder->createNamedParameter('', ‪Connection::PARAM_STR)
                ),
                $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, ‪Connection::PARAM_INT))
            )
            ->executeQuery();
        $maxDuration = $this->extConf['maxLifetime'] * 60;
        while ($row = $result->fetchAssociative()) {
            $executions = [];
            if ($serialized_executions = unserialize($row['serialized_executions'])) {
                foreach ($serialized_executions as $task) {
                    if ($tstamp - $task < $maxDuration) {
                        $executions[] = $task;
                    } else {
                        $schedulerTask = unserialize($row['serialized_task_object']);
                        if ($schedulerTask instanceof AbstractTask) {
                            $taskClass = get_class($schedulerTask);
                            $taskTime = date('Y-m-d H:i:s', $schedulerTask->getExecutionTime());
                        } else {
                            $taskClass = 'unknown task';
                            $taskTime = 'unknown time';
                        }
                        $this->‪log('Removing logged execution, assuming that the process is dead. Execution of \'' . $taskClass . '\' (UID: ' . $row['uid'] . ') was started at ' . $taskTime);
                    }
                }
            }
            $executionCount = count($executions);
            if (!is_array($serialized_executions) || count($serialized_executions) !== $executionCount) {
                if ($executionCount === 0) {
                    $value = '';
                } else {
                    $value = serialize($executions);
                }
                $connectionPool->getConnectionForTable('tx_scheduler_task')->update(
                    'tx_scheduler_task',
                    ['serialized_executions' => $value],
                    ['uid' => (int)$row['uid']],
                    ['serialized_executions' => Connection::PARAM_LOB]
                );
            }
        }
    }
 
    public function executeTask(AbstractTask $task)
    {
        $task->setRunOnNextCronJob(false);
        // Trigger the saving of the task, as this will calculate its next execution time
        // This should be calculated all the time, even if the execution is skipped
        // (in case it is skipped, this pushes back execution to the next possible date)
        $task->save();
        // Set a scheduler object for the task again,
        // as it was removed during the save operation
        $task->setScheduler();
        $result = true;
        // Task is already running and multiple executions are not allowed
        if (!$task->areMultipleExecutionsAllowed() && $task->isExecutionRunning()) {
            // Log multiple execution error
            $this->logger->info('Task is already running and multiple executions are not allowed, skipping! Class: {class}, UID: {uid}', [
                'class' => get_class($task),
                'uid' => $task->getTaskUid(),
            ]);
            $result = false;
        } else {
            // Log scheduler invocation
            $this->logger->info('Start execution. Class: {class}, UID: {uid}', [
                'class' => get_class($task),
                'uid' => $task->getTaskUid(),
            ]);
            // Register execution
            $executionID = $task->markExecution();
            $failure = null;
            try {
                // Execute task
                $successfullyExecuted = $task->execute();
                if (!$successfullyExecuted) {
                    throw new FailedExecutionException('Task failed to execute successfully. Class: ' . get_class($task) . ', UID: ' . $task->getTaskUid(), 1250596541);
                }
            } catch (\Throwable $e) {
                // Store exception, so that it can be saved to database
                $failure = $e;
            }
            // Un-register execution
            $task->unmarkExecution($executionID, $failure);
            // Log completion of execution
            $this->logger->info('Task executed. Class: {class}, UID: {uid}', [
                'class' => get_class($task),
                'uid' => $task->getTaskUid(),
            ]);
            // Now that the result of the task execution has been handled,
            // throw the exception again, if any
            if ($failure instanceof \Throwable) {
                throw $failure;
            }
        }
        return $result;
    }
 
    public function recordLastRun($type = 'cron')
    {
        // Validate input value
        if ($type !== 'manual' && $type !== 'cli-by-id') {
            $type = 'cron';
        }
        $registry = GeneralUtility::makeInstance(Registry::class);
        $runInformation = ['start' => $GLOBALS['EXEC_TIME'], 'end' => time(), 'type' => $type];
        $registry->set('tx_scheduler', 'lastRun', $runInformation);
    }
 
    public function removeTask(AbstractTask $task)
    {
        $taskUid = $task->getTaskUid();
        if (!empty($taskUid)) {
            $affectedRows = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getConnectionForTable('tx_scheduler_task')
                ->update('tx_scheduler_task', ['deleted' => 1], ['uid' => $taskUid]);
            $result = $affectedRows === 1;
        } else {
            $result = false;
        }
        return $result;
    }
 
    public function saveTask(AbstractTask $task)
    {
        $result = true;
        $taskUid = $task->getTaskUid();
        if (!empty($taskUid)) {
            try {
                if ($task->getRunOnNextCronJob()) {
                    $executionTime = time();
                } else {
                    $executionTime = $task->getNextDueExecution();
                }
                $task->setExecutionTime($executionTime);
            } catch (\Exception $e) {
                $task->setDisabled(true);
                $executionTime = 0;
            }
            $task->unsetScheduler();
            $fields = [
                'nextexecution' => $executionTime,
                'disable' => (int)$task->isDisabled(),
                'description' => $task->getDescription(),
                'task_group' => $task->getTaskGroup(),
                'serialized_task_object' => serialize($task),
            ];
            try {
                GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getConnectionForTable('tx_scheduler_task')
                    ->update(
                        'tx_scheduler_task',
                        $fields,
                        ['uid' => $taskUid],
                        ['serialized_task_object' => Connection::PARAM_LOB]
                    );
            } catch (DBALException $e) {
                $result = false;
            }
        } else {
            $result = false;
        }
        return $result;
    }
 
    public function fetchTask($uid = 0): ?AbstractTask
    {
        $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
        $queryBuilder = $connectionPool->getQueryBuilderForTable('tx_scheduler_task');
 
        $queryBuilder->select('t.uid', 't.serialized_task_object')
            ->from('tx_scheduler_task', 't')
            ->setMaxResults(1);
        // Define where clause
        // If no uid is given, take any non-disabled task which has a next execution time in the past
        if (empty($uid)) {
            $queryBuilder->getRestrictions()->removeAll();
            $queryBuilder->leftJoin(
                't',
                'tx_scheduler_task_group',
                'g',
                $queryBuilder->expr()->eq('t.task_group', $queryBuilder->quoteIdentifier('g.uid'))
            );
            $queryBuilder->where(
                $queryBuilder->expr()->eq('t.disable', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT)),
                $queryBuilder->expr()->neq('t.nextexecution', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT)),
                $queryBuilder->expr()->lte(
                    't.nextexecution',
                    $queryBuilder->createNamedParameter($GLOBALS['EXEC_TIME'], Connection::PARAM_INT)
                ),
                $queryBuilder->expr()->orX(
                    $queryBuilder->expr()->eq('g.hidden', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT)),
                    $queryBuilder->expr()->isNull('g.hidden')
                ),
                $queryBuilder->expr()->eq('t.deleted', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT))
            );
            $queryBuilder->orderBy('t.nextexecution', 'ASC');
        } else {
            $queryBuilder->where(
                $queryBuilder->expr()->eq('t.uid', $queryBuilder->createNamedParameter($uid, Connection::PARAM_INT)),
                $queryBuilder->expr()->eq('t.deleted', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT))
            );
        }
 
        $row = $queryBuilder->executeQuery()->fetchAssociative();
        if (empty($row)) {
            if (empty($uid)) {
                // No uid was passed and no overdue task was found
                return null;
            }
            // Although a uid was passed, no task with given was found
            throw new \OutOfBoundsException('No task with id ' . $uid . ' found', 1422044826);
        }
        $task = unserialize($row['serialized_task_object']);
        if ($this->isValidTaskObject($task)) {
            // The task is valid, return it
            $task->setScheduler();
            if ($task->getTaskGroup() === null) {
                // Fix invalid task_group=NULL settings in order to avoid exceptions when saving on PostgreSQL
                $task->setTaskGroup(0);
            }
        } else {
            // Forcibly set the disable flag to 1 in the database,
            // so that the task does not come up again and again for execution
            $connectionPool->getConnectionForTable('tx_scheduler_task')->update(
                'tx_scheduler_task',
                ['disable' => 1],
                ['uid' => (int)$row['uid']]
            );
            // Throw an exception to raise the problem
            throw new \UnexpectedValueException('Could not unserialize task', 1255083671);
        }
 
        return $task;
    }
 
    public function fetchTaskRecord($uid)
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_scheduler_task');
        $row = $queryBuilder->select('*')
            ->from('tx_scheduler_task')
            ->where(
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter((int)$uid, Connection::PARAM_INT)),
                $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT))
            )
            ->executeQuery()
            ->fetchAssociative();
 
        // If the task is not found, throw an exception
        if (empty($row)) {
            throw new \OutOfBoundsException('No task', 1247827245);
        }
 
        return $row;
    }
 
    public function fetchTasksWithCondition($where, $includeDisabledTasks = false)
    {
        $tasks = [];
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_scheduler_task');
 
        $queryBuilder
            ->select('serialized_task_object')
            ->from('tx_scheduler_task')
            ->where(
                $queryBuilder->expr()->eq('deleted', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT))
            );
 
        if (!$includeDisabledTasks) {
            $queryBuilder->andWhere(
                $queryBuilder->expr()->eq('disable', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT))
            );
        }
 
        if (!empty($where)) {
            $queryBuilder->andWhere(QueryHelper::stripLogicalOperatorPrefix($where));
        }
 
        $result = $queryBuilder->executeQuery();
        while ($row = $result->fetchAssociative()) {
            $task = unserialize($row['serialized_task_object']);
            // Add the task to the list only if it is valid
            if ($this->isValidTaskObject($task)) {
                $task->setScheduler();
                $tasks[] = $task;
            }
        }
 
        return $tasks;
    }
 
    public function isValidTaskObject($task)
    {
        return $task instanceof AbstractTask && get_class($task->getExecution()) !== \__PHP_Incomplete_Class::class;
    }
 
    public function log($message, $status = 0, $code = '')
    {
        $messageTemplate = '[scheduler]: {code} - {original_message}';
        // @todo Replace these magic numbers with constants or enums.
        switch ((int)$status) {
            // error (user problem)
            case 1:
                $this->logger->alert($messageTemplate, ['code' => $code, 'original_message' => $message]);
                break;
                // System Error (which should not happen)
            case 2:
                $this->logger->error($messageTemplate, ['code' => $code, 'original_message' => $message]);
                break;
                // security notice (admin)
            case 3:
                $this->logger->emergency($messageTemplate, ['code' => $code, 'original_message' => $message]);
                break;
                // regular message (= 0)
            default:
                $this->logger->info($messageTemplate, ['code' => $code, 'original_message' => $message]);
        }
    }
}