9.5/scheduler_2_classes_2_task_2_abstract_task_8php_source.html

<?php

namespace ‪TYPO3\CMS\Scheduler\Task;


/*

 * 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!

 */


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\Log\LogManager;

use ‪TYPO3\CMS\Core\Utility\GeneralUtility;

use ‪TYPO3\CMS\Scheduler\Execution;


abstract class ‪AbstractTask implements LoggerAwareInterface

{

    use LoggerAwareTrait;


    const ‪TYPE_SINGLE = 1;

    const ‪TYPE_RECURRING = 2;


    protected ‪$scheduler;


    protected ‪$taskUid;


    protected ‪$disabled = false;


    protected ‪$runOnNextCronJob = false;


    protected ‪$execution;


    protected ‪$executionTime = 0;


    protected ‪$description = '';


    protected ‪$taskGroup;


    public function ‪__construct()

    {

        // Using makeInstance instead of setScheduler() here as the logger is injected due to LoggerAwareTrait

        $this->scheduler = GeneralUtility::makeInstance(\‪TYPO3\CMS\‪Scheduler\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 ‪$GLOBALS['LANG']->sL(‪$GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['scheduler']['tasks'][static::class]['title']);

    }


    public function ‪getTaskDescription()

    {

        return ‪$GLOBALS['LANG']->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(\‪TYPO3\CMS\‪Scheduler\Scheduler::class);

        $this->logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(__CLASS__);

    }


    public function ‪unsetScheduler()

    {

        $this->scheduler = null;

        $this->logger = null;

    }


    public function ‪registerSingleExecution($timestamp)

    {

        ‪$execution = GeneralUtility::makeInstance(Execution::class);

        ‪$execution->‪setStart($timestamp);

        ‪$execution->‪setInterval(0);

        ‪$execution->‪setEnd($timestamp);

        ‪$execution->‪setCronCmd('');

        ‪$execution->‪setMultiple(0);

        ‪$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, \PDO::PARAM_INT))

            )

            ->execute()

            ->fetch();


        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, \PDO::PARAM_INT))

            )

            ->execute()

            ->fetch();


        $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 $failure = 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, \PDO::PARAM_INT))

            )

            ->execute()

            ->fetch();


        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 ($failure instanceof \Throwable) {

                // Log failed execution

                $logMessage = 'Task failed to execute successfully. Class: ' . static::class

                    . ', UID: ' . $this->taskUid . ', Code: ' . $failure->getCode() . ', ' . $failure->getMessage();

                $this->logger->error($logMessage, ['exception' => $failure]);

                // Do not serialize the complete exception or the trace, this can lead to huge strings > 50MB

                $failureString = serialize([

                    'code' => $failure->getCode(),

                    'message' => $failure->getMessage(),

                    'file' => $failure->getFile(),

                    'line' => $failure->getLine(),

                    'traceString' => $failure->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: ' . $e->getMessage() . ' (' . $e->getCode() . ')', ['exception' => $e]);

    }

}