AbstractTask.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Scheduler\Task;

abstract class AbstractTask {

    protected $scheduler;

    protected $taskUid;

    protected $disabled = FALSE;

    protected $execution;

    protected $executionTime = 0;

    protected $description = '';

    protected $taskGroup;

    public function __construct() {
        $this->setScheduler();
        $this->execution = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Scheduler\\Execution');
    }

    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'][get_class($this)]['title']);
    }

    public function getTaskDescription() {
        return $GLOBALS['LANG']->sL($GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']['scheduler']['tasks'][get_class($this)]['description']);
    }

    public function getTaskClassName() {
        return get_class($this);
    }

    public function isDisabled() {
        return $this->disabled;
    }

    public function setDisabled($flag) {
        if ($flag) {
            $this->disabled = TRUE;
        } else {
            $this->disabled = FALSE;
        }
    }

    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 = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Scheduler\\Scheduler');
    }

    public function unsetScheduler() {
        unset($this->scheduler);
    }

    public function registerSingleExecution($timestamp) {
        $execution = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Scheduler\\Execution');
        $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 = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Scheduler\\Execution');
        // 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(\TYPO3\CMS\Scheduler\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;
        $queryArr = array(
            'SELECT' => 'serialized_executions',
            'FROM' => 'tx_scheduler_task',
            'WHERE' => 'uid = ' . $this->taskUid,
            'LIMIT' => 1
        );
        $res = $GLOBALS['TYPO3_DB']->exec_SELECT_queryArray($queryArr);
        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
            if (strlen($row['serialized_executions']) > 0) {
                $isRunning = TRUE;
            }
        }
        $GLOBALS['TYPO3_DB']->sql_free_result($res);
        return $isRunning;
    }

    public function markExecution() {
        $queryArr = array(
            'SELECT' => 'serialized_executions',
            'FROM' => 'tx_scheduler_task',
            'WHERE' => 'uid = ' . $this->taskUid,
            'LIMIT' => 1
        );
        $res = $GLOBALS['TYPO3_DB']->exec_SELECT_queryArray($queryArr);
        $runningExecutions = array();
        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
            if (strlen($row['serialized_executions']) > 0) {
                $runningExecutions = unserialize($row['serialized_executions']);
            }
        }
        $GLOBALS['TYPO3_DB']->sql_free_result($res);
        // 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();
        // Define the context in which the script is running
        $context = 'BE';
        if (TYPO3_REQUESTTYPE & TYPO3_REQUESTTYPE_CLI) {
            $context = 'CLI';
        }
        $GLOBALS['TYPO3_DB']->exec_UPDATEquery('tx_scheduler_task', 'uid = ' . $this->taskUid, array(
            'serialized_executions' => serialize($runningExecutions),
            'lastexecution_time' => time(),
            'lastexecution_context' => $context
        ));
        return $numExecutions;
    }

    public function unmarkExecution($executionID, \Exception $failure = NULL) {
        // Get the executions for the task
        $queryArr = array(
            'SELECT' => 'serialized_executions',
            'FROM' => 'tx_scheduler_task',
            'WHERE' => 'uid = ' . $this->taskUid,
            'LIMIT' => 1
        );
        $res = $GLOBALS['TYPO3_DB']->exec_SELECT_queryArray($queryArr);
        if ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
            if (strlen($row['serialized_executions']) > 0) {
                $runningExecutions = unserialize($row['serialized_executions']);
                // Remove the selected execution
                unset($runningExecutions[$executionID]);
                if (count($runningExecutions) > 0) {
                    // Re-serialize the updated executions list (if necessary)
                    $runningExecutionsSerialized = serialize($runningExecutions);
                } else {
                    $runningExecutionsSerialized = '';
                }
                if ($failure instanceof \Exception) {
                    // Log failed execution
                    $logMessage = 'Task failed to execute successfully. Class: ' . get_class($this) . ', UID: ' . $this->taskUid . '. ' . $failure->getMessage();
                    $this->scheduler->log($logMessage, 1, $failure->getCode());
                    // Do not serialize the complete exception or the trace, this can lead to huge strings > 50MB
                    $failureString = serialize(array(
                        'code' => $failure->getCode(),
                        'message' => $failure->getMessage(),
                        'file' => $failure->getFile(),
                        'line' => $failure->getLine(),
                        'traceString' => $failure->getTraceAsString(),
                    ));
                } else {
                    $failureString = '';
                }
                // Save the updated executions list
                $GLOBALS['TYPO3_DB']->exec_UPDATEquery('tx_scheduler_task', 'uid = ' . $this->taskUid, array(
                    'serialized_executions' => $runningExecutionsSerialized,
                    'lastexecution_failure' => $failureString
                ));
            }
        }
        $GLOBALS['TYPO3_DB']->sql_free_result($res);
    }

    public function unmarkAllExecutions() {
        // Set the serialized executions field to empty
        $result = $GLOBALS['TYPO3_DB']->exec_UPDATEquery('tx_scheduler_task', 'uid = ' . $this->taskUid, array(
            'serialized_executions' => ''
        ));
        return $result;
    }

    public function save() {
        return $this->scheduler->saveTask($this);
    }

    public function stop() {
        $this->execution = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Scheduler\\Execution');
    }

    public function remove() {
        $this->scheduler->removeTask($this);
    }

}