AbstractTask.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\Task;
 
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use ‪TYPO3\CMS\Core\Core\Environment;
use ‪TYPO3\CMS\Core\Database\Connection;
use ‪TYPO3\CMS\Core\Database\ConnectionPool;
use ‪TYPO3\CMS\Core\Localization\LanguageService;
use ‪TYPO3\CMS\Core\Log\LogManager;
use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
use ‪TYPO3\CMS\Scheduler\Execution;
use ‪TYPO3\CMS\Scheduler\Scheduler;
 
abstract class ‪AbstractTask implements LoggerAwareInterface
{
    use LoggerAwareTrait;
 
    public const ‪TYPE_SINGLE = 1;
    public const ‪TYPE_RECURRING = 2;
 
    protected ‪$scheduler;
 
    protected ‪$taskUid;
 
    protected ‪$disabled = false;
 
    protected ‪$runOnNextCronJob = false;
 
    protected ‪$execution;
 
    protected ‪$executionTime = 0;
 
    protected ‪$description = '';
 
    protected ‪$taskGroup = 0;
 
    public function ‪__construct()
    {
        // Using makeInstance instead of setScheduler() here as the logger is injected due to LoggerAwareTrait
        $this->scheduler = GeneralUtility::makeInstance(Scheduler::class);
        $this->execution = GeneralUtility::makeInstance(Execution::class);
    }
 
    abstract public function ‪execute();
 
    public function ‪getAdditionalInformation()
    {
        return '';
    }
 
    public function ‪setTaskUid($id)
    {
        $this->taskUid = (int)$id;
    }
 
    public function ‪getTaskUid()
    {
        return ‪$this->taskUid;
    }
 
    public function ‪getTaskTitle()
    {
        return $this->‪getLanguageService()->‪sL(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['scheduler']['tasks'][static::class]['title']);
    }
 
    public function ‪getTaskDescription()
    {
        return $this->‪getLanguageService()->‪sL(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['scheduler']['tasks'][static::class]['description']);
    }
 
    public function ‪getTaskClassName()
    {
        return static::class;
    }
 
    public function ‪isDisabled()
    {
        return ‪$this->disabled;
    }
 
    public function ‪setDisabled($flag)
    {
        if ($flag) {
            $this->disabled = true;
        } else {
            $this->disabled = false;
        }
    }
 
    public function ‪setRunOnNextCronJob($flag)
    {
        $this->runOnNextCronJob = $flag;
    }
 
    public function ‪getRunOnNextCronJob()
    {
        return ‪$this->runOnNextCronJob;
    }
 
    public function ‪setExecutionTime($timestamp)
    {
        $this->executionTime = (int)$timestamp;
    }
 
    public function ‪getTaskGroup()
    {
        return ‪$this->taskGroup;
    }
 
    public function ‪setTaskGroup(‪$taskGroup)
    {
        $this->taskGroup = (int)‪$taskGroup;
    }
 
    public function ‪getExecutionTime()
    {
        return ‪$this->executionTime;
    }
 
    public function ‪setDescription(‪$description)
    {
        $this->description = ‪$description;
    }
 
    public function ‪getDescription()
    {
        return ‪$this->description;
    }
 
    public function ‪setScheduler()
    {
        $this->scheduler = GeneralUtility::makeInstance(Scheduler::class);
        $this->logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);
    }
 
    public function ‪unsetScheduler()
    {
        $this->scheduler = null;
        unset($this->logger);
    }
 
    public function ‪registerSingleExecution($timestamp)
    {
        ‪$execution = GeneralUtility::makeInstance(Execution::class);
        ‪$execution->‪setStart($timestamp);
        ‪$execution->‪setInterval(0);
        ‪$execution->‪setEnd($timestamp);
        ‪$execution->‪setCronCmd('');
        ‪$execution->‪setMultiple(false);
        ‪$execution->‪setIsNewSingleExecution(true);
        // Replace existing execution object
        $this->execution = ‪$execution;
    }
 
    public function ‪registerRecurringExecution($start, $interval, $end = 0, $multiple = false, $cron_cmd = '')
    {
        ‪$execution = GeneralUtility::makeInstance(Execution::class);
        // Set general values
        ‪$execution->‪setStart($start);
        ‪$execution->‪setEnd($end);
        ‪$execution->‪setMultiple($multiple);
        if (empty($cron_cmd)) {
            // Use interval
            ‪$execution->‪setInterval($interval);
            ‪$execution->‪setCronCmd('');
        } else {
            // Use cron syntax
            ‪$execution->‪setInterval(0);
            ‪$execution->‪setCronCmd($cron_cmd);
        }
        // Replace existing execution object
        $this->execution = ‪$execution;
    }
 
    public function ‪setExecution(‪Execution ‪$execution)
    {
        $this->execution = ‪$execution;
    }
 
    public function ‪getExecution()
    {
        return ‪$this->execution;
    }
 
    public function ‪getNextDueExecution()
    {
        // NOTE: this call may throw an exception, but we let it bubble up
        return $this->execution->getNextExecution();
    }
 
    public function ‪areMultipleExecutionsAllowed()
    {
        return $this->execution->getMultiple();
    }
 
    public function ‪isExecutionRunning()
    {
        $isRunning = false;
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_scheduler_task');
        $row = $queryBuilder
            ->select('serialized_executions')
            ->from('tx_scheduler_task')
            ->where(
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($this->taskUid, ‪Connection::PARAM_INT))
            )
            ->executeQuery()
            ->fetchAssociative();
 
        if ($row && !empty($row['serialized_executions'])) {
            $isRunning = true;
        }
        return $isRunning;
    }
 
    public function ‪markExecution()
    {
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_scheduler_task');
 
        $row = $queryBuilder
            ->select('serialized_executions')
            ->from('tx_scheduler_task')
            ->where(
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($this->taskUid, ‪Connection::PARAM_INT))
            )
            ->executeQuery()
            ->fetchAssociative();
 
        $runningExecutions = [];
        if ($row && !empty($row['serialized_executions'])) {
            $runningExecutions = unserialize($row['serialized_executions']);
        }
        // Count the number of existing executions and use that number as a key
        // (we need to know that number, because it is returned at the end of the method)
        $numExecutions = count($runningExecutions);
        $runningExecutions[$numExecutions] = time();
        GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable('tx_scheduler_task')
            ->update(
                'tx_scheduler_task',
                [
                    'serialized_executions' => serialize($runningExecutions),
                    'lastexecution_time' => time(),
                    // Define the context in which the script is running
                    'lastexecution_context' => ‪Environment::isCli() ? 'CLI' : 'BE',
                ],
                [
                    'uid' => $this->taskUid,
                ],
                [
                    'serialized_executions' => ‪Connection::PARAM_LOB,
                ]
            );
        return $numExecutions;
    }
 
    public function ‪unmarkExecution($executionID, \Throwable $e = null)
    {
        // Get the executions for the task
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_scheduler_task');
 
        $row = $queryBuilder
            ->select('serialized_executions')
            ->from('tx_scheduler_task')
            ->where(
                $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($this->taskUid, ‪Connection::PARAM_INT))
            )
            ->executeQuery()
            ->fetchAssociative();
 
        if ($row && $row['serialized_executions'] !== '') {
            $runningExecutions = unserialize($row['serialized_executions']);
            // Remove the selected execution
            unset($runningExecutions[$executionID]);
            if (!empty($runningExecutions)) {
                // Re-serialize the updated executions list (if necessary)
                $runningExecutionsSerialized = serialize($runningExecutions);
            } else {
                $runningExecutionsSerialized = '';
            }
            if ($e instanceof \Throwable) {
                // Log failed execution
                $this->logger->error('Task failed to execute successfully. Class: {class}, UID: {uid}', [
                    'class' => __CLASS__,
                    'uid' => $this->taskUid,
                    'exception' => $e,
                ]);
                // Do not serialize the complete exception or the trace, this can lead to huge strings > 50MB
                $failureString = serialize([
                    'code' => $e->getCode(),
                    'message' => $e->getMessage(),
                    'file' => $e->getFile(),
                    'line' => $e->getLine(),
                    'traceString' => $e->getTraceAsString(),
                ]);
            } else {
                $failureString = '';
            }
            // Save the updated executions list
            GeneralUtility::makeInstance(ConnectionPool::class)
                ->getConnectionForTable('tx_scheduler_task')
                ->update(
                    'tx_scheduler_task',
                    [
                        'serialized_executions' => $runningExecutionsSerialized,
                        'lastexecution_failure' => $failureString,
                    ],
                    [
                        'uid' => $this->taskUid,
                    ],
                    [
                        'serialized_executions' => ‪Connection::PARAM_LOB,
                    ]
                );
        }
    }
 
    public function ‪unmarkAllExecutions()
    {
        // Set the serialized executions field to empty
        $result = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable('tx_scheduler_task')
            ->update(
                'tx_scheduler_task',
                [
                    'serialized_executions' => '',
                ],
                [
                    'uid' => $this->taskUid,
                ],
                [
                    'serialized_executions' => ‪Connection::PARAM_LOB,
                ]
            );
        return (bool)$result;
    }
 
    public function ‪save()
    {
        return $this->scheduler->saveTask($this);
    }
 
    public function ‪stop()
    {
        $this->execution = GeneralUtility::makeInstance(Execution::class);
    }
 
    public function remove()
    {
        $this->scheduler->removeTask($this);
    }
 
    public function ‪getType()
    {
        if (!empty($this->‪getExecution()->getInterval()) || !empty($this->‪getExecution()->getCronCmd())) {
            return ‪self::TYPE_RECURRING;
        }
        return ‪self::TYPE_SINGLE;
    }
 
    protected function ‪logException(\Exception $e)
    {
        $this->logger->error('A Task Exception was captured.', ['exception' => $e]);
    }
 
    protected function ‪getLanguageService(): ?‪LanguageService
    {
        return ‪$GLOBALS['LANG'] ?? null;
    }
}