Scheduler.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Scheduler;

class Scheduler implements \TYPO3\CMS\Core\SingletonInterface {

    public $extConf = array();

    public function __construct() {
        // Get configuration from the extension manager
        $this->extConf = unserialize($GLOBALS['TYPO3_CONF_VARS']['EXT']['extConf']['scheduler']);
        if (empty($this->extConf['maxLifetime'])) {
            $this->extConf['maxLifetime'] = 1440;
        }
        if (empty($this->extConf['useAtdaemon'])) {
            $this->extConf['useAtdaemon'] = 0;
        }
        // Clean up the serialized execution arrays
        $this->cleanExecutionArrays();
    }

    public function addTask(\TYPO3\CMS\Scheduler\Task\AbstractTask $task) {
        $taskUid = $task->getTaskUid();
        if (empty($taskUid)) {
            $fields = array(
                'crdate' => $GLOBALS['EXEC_TIME'],
                'disable' => $task->isDisabled(),
                'description' => $task->getDescription(),
                'task_group' => $task->getTaskGroup(),
                'serialized_task_object' => 'RESERVED'
            );
            $result = $GLOBALS['TYPO3_DB']->exec_INSERTquery('tx_scheduler_task', $fields);
            if ($result) {
                $task->setTaskUid($GLOBALS['TYPO3_DB']->sql_insert_id());
                $task->save();
                $result = TRUE;
            } else {
                $result = FALSE;
            }
        } else {
            $result = FALSE;
        }
        return $result;
    }

    protected function cleanExecutionArrays() {
        $tstamp = $GLOBALS['EXEC_TIME'];
        // Select all tasks with executions
        // NOTE: this cleanup is done for disabled tasks too,
        // to avoid leaving old executions lying around
        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('uid, serialized_executions, serialized_task_object', 'tx_scheduler_task', 'serialized_executions <> \'\'');
        $maxDuration = $this->extConf['maxLifetime'] * 60;
        while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
            $executions = array();
            if ($serialized_executions = unserialize($row['serialized_executions'])) {
                foreach ($serialized_executions as $task) {
                    if ($tstamp - $task < $maxDuration) {
                        $executions[] = $task;
                    } else {
                        $task = unserialize($row['serialized_task_object']);
                        $logMessage = 'Removing logged execution, assuming that the process is dead. Execution of \'' . get_class($task) . '\' (UID: ' . $row['uid'] . ') was started at ' . date('Y-m-d H:i:s', $task->getExecutionTime());
                        $this->log($logMessage);
                    }
                }
            }
            if (count($serialized_executions) != count($executions)) {
                if (count($executions) == 0) {
                    $value = '';
                } else {
                    $value = serialize($executions);
                }
                $GLOBALS['TYPO3_DB']->exec_UPDATEquery('tx_scheduler_task', 'uid = ' . (int)$row['uid'], array('serialized_executions' => $value));
            }
        }
        $GLOBALS['TYPO3_DB']->sql_free_result($res);
    }

    public function executeTask(\TYPO3\CMS\Scheduler\Task\AbstractTask $task) {
        // 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
            $logMessage = 'Task is already running and multiple executions are not allowed, skipping! Class: ' . get_class($task) . ', UID: ' . $task->getTaskUid();
            $this->log($logMessage);
            $result = FALSE;
        } else {
            // Log scheduler invocation
            $logMessage = 'Start execution. Class: ' . get_class($task) . ', UID: ' . $task->getTaskUid();
            $this->log($logMessage);
            // Register execution
            $executionID = $task->markExecution();
            $failure = NULL;
            try {
                // Execute task
                $successfullyExecuted = $task->execute();
                if (!$successfullyExecuted) {
                    throw new \TYPO3\CMS\Scheduler\FailedExecutionException('Task failed to execute successfully. Class: ' . get_class($task) . ', UID: ' . $task->getTaskUid(), 1250596541);
                }
            } catch (\Exception $e) {
                // Store exception, so that it can be saved to database
                $failure = $e;
            }
            // make sure database-connection is fine
            // for long-running tasks the database might meanwhile have disconnected
            $GLOBALS['TYPO3_DB']->isConnected();
            // Un-register execution
            $task->unmarkExecution($executionID, $failure);
            // Log completion of execution
            $logMessage = 'Task executed. Class: ' . get_class($task) . ', UID: ' . $task->getTaskUid();
            $this->log($logMessage);
            // Now that the result of the task execution has been handled,
            // throw the exception again, if any
            if ($failure instanceof \Exception) {
                throw $failure;
            }
        }
        return $result;
    }

    public function recordLastRun($type = 'cron') {
        // Validate input value
        if ($type !== 'manual' && $type !== 'cli-by-id') {
            $type = 'cron';
        }
        $registry = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Registry');
        $runInformation = array('start' => $GLOBALS['EXEC_TIME'], 'end' => time(), 'type' => $type);
        $registry->set('tx_scheduler', 'lastRun', $runInformation);
    }

    public function removeTask(\TYPO3\CMS\Scheduler\Task\AbstractTask $task) {
        $taskUid = $task->getTaskUid();
        if (!empty($taskUid)) {
            $result = $GLOBALS['TYPO3_DB']->exec_DELETEquery('tx_scheduler_task', 'uid = ' . $taskUid);
        } else {
            $result = FALSE;
        }
        if ($result) {
            $this->scheduleNextSchedulerRunUsingAtDaemon();
        }
        return $result;
    }

    public function saveTask(\TYPO3\CMS\Scheduler\Task\AbstractTask $task) {
        $taskUid = $task->getTaskUid();
        if (!empty($taskUid)) {
            try {
                $executionTime = $task->getNextDueExecution();
                $task->setExecutionTime($executionTime);
            } catch (\Exception $e) {
                $task->setDisabled(TRUE);
                $executionTime = 0;
            }
            $task->unsetScheduler();
            $fields = array(
                'nextexecution' => $executionTime,
                'disable' => $task->isDisabled(),
                'description' => $task->getDescription(),
                'task_group' => $task->getTaskGroup(),
                'serialized_task_object' => serialize($task)
            );
            $result = $GLOBALS['TYPO3_DB']->exec_UPDATEquery('tx_scheduler_task', 'uid = ' . $taskUid, $fields);
        } else {
            $result = FALSE;
        }
        if ($result) {
            $this->scheduleNextSchedulerRunUsingAtDaemon();
        }
        return $result;
    }

    public function fetchTask($uid = 0) {
        // 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)) {
            $queryArray = array(
                'SELECT' => 'tx_scheduler_task.uid AS uid, serialized_task_object',
                'FROM' => 'tx_scheduler_task LEFT JOIN tx_scheduler_task_group ON tx_scheduler_task.task_group = tx_scheduler_task_group.uid',
                'WHERE' => 'disable = 0 AND nextexecution != 0 AND nextexecution <= ' . $GLOBALS['EXEC_TIME'] . ' AND (tx_scheduler_task_group.hidden = 0 OR tx_scheduler_task_group.hidden IS NULL)',
                'LIMIT' => 1
            );
        } else {
            $queryArray = array(
                'SELECT' => 'uid, serialized_task_object',
                'FROM' => 'tx_scheduler_task',
                'WHERE' => 'uid = ' . (int)$uid,
                'LIMIT' => 1
            );
        }

        $res = $GLOBALS['TYPO3_DB']->exec_SELECT_queryArray($queryArray);
        if ($res === FALSE) {
            throw new \OutOfBoundsException('Query could not be executed. Possible defect in tables tx_scheduler_task or tx_scheduler_task_group or DB server problems', 1422044826);
        }
        // If there are no available tasks, thrown an exception
        if ($GLOBALS['TYPO3_DB']->sql_num_rows($res) == 0) {
            throw new \OutOfBoundsException('No task', 1247827244);
        } else {
            $row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
            $task = unserialize($row['serialized_task_object']);
            if ($this->isValidTaskObject($task)) {
                // The task is valid, return it
                $task->setScheduler();
            } else {
                // Forcibly set the disable flag to 1 in the database,
                // so that the task does not come up again and again for execution
                $GLOBALS['TYPO3_DB']->exec_UPDATEquery('tx_scheduler_task', 'uid = ' . $row['uid'], array('disable' => 1));
                // Throw an exception to raise the problem
                throw new \UnexpectedValueException('Could not unserialize task', 1255083671);
            }
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
        }
        return $task;
    }

    public function fetchTaskRecord($uid) {
        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('*', 'tx_scheduler_task', 'uid = ' . (int)$uid);
        // If the task is not found, throw an exception
        if ($GLOBALS['TYPO3_DB']->sql_num_rows($res) == 0) {
            throw new \OutOfBoundsException('No task', 1247827245);
        } else {
            $row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res);
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
        }
        return $row;
    }

    public function fetchTasksWithCondition($where, $includeDisabledTasks = FALSE) {
        $whereClause = '';
        $tasks = array();
        if (!empty($where)) {
            $whereClause = $where;
        }
        if (!$includeDisabledTasks) {
            if (!empty($whereClause)) {
                $whereClause .= ' AND ';
            }
            $whereClause .= 'disable = 0';
        }
        $res = $GLOBALS['TYPO3_DB']->exec_SELECTquery('serialized_task_object', 'tx_scheduler_task', $whereClause);
        if ($res) {
            while ($row = $GLOBALS['TYPO3_DB']->sql_fetch_assoc($res)) {
                $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;
                }
            }
            $GLOBALS['TYPO3_DB']->sql_free_result($res);
        }
        return $tasks;
    }

    public function isValidTaskObject($task) {
        return $task instanceof \TYPO3\CMS\Scheduler\Task\AbstractTask;
    }

    public function log($message, $status = 0, $code = 'scheduler') {
        // Log only if enabled
        if (!empty($this->extConf['enableBELog'])) {
            $GLOBALS['BE_USER']->writelog(4, 0, $status, $code, '[scheduler]: ' . $message, array());
        }
    }

    public function scheduleNextSchedulerRunUsingAtDaemon() {
        if ((int)$this->extConf['useAtdaemon'] !== 1) {
            return FALSE;
        }
        $registry = \TYPO3\CMS\Core\Utility\GeneralUtility::makeInstance('TYPO3\\CMS\\Core\\Registry');
        // Get at job id from registry and remove at job
        $atJobId = $registry->get('tx_scheduler', 'atJobId');
        if (\TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($atJobId)) {
            shell_exec('atrm ' . (int)$atJobId . ' 2>&1');
        }
        // Can not use fetchTask() here because if tasks have just executed
        // they are not in the list of next executions
        $tasks = $this->fetchTasksWithCondition('');
        $nextExecution = FALSE;
        foreach ($tasks as $task) {
            try {
                $tempNextExecution = $task->getNextDueExecution();
                if ($nextExecution === FALSE || $tempNextExecution < $nextExecution) {
                    $nextExecution = $tempNextExecution;
                }
            } catch (\OutOfBoundsException $e) {
                // The event will not be executed again or has already ended - we don't have to consider it for
                // scheduling the next "at" run
            }
        }
        if ($nextExecution !== FALSE) {
            if ($nextExecution > $GLOBALS['EXEC_TIME']) {
                $startTime = strftime('%H:%M %F', $nextExecution);
            } else {
                $startTime = 'now+1minute';
            }
            $cliDispatchPath = PATH_site . 'typo3/cli_dispatch.phpsh';
            $currentLocale = setlocale(LC_CTYPE, 0);
            if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['UTF8filesystem']) {
                setlocale(LC_CTYPE, $GLOBALS['TYPO3_CONF_VARS']['SYS']['systemLocale']);
            }
            $cmd = 'echo ' . escapeshellarg($cliDispatchPath) . ' scheduler | at ' . escapeshellarg($startTime) . ' 2>&1';
            if ($GLOBALS['TYPO3_CONF_VARS']['SYS']['UTF8filesystem']) {
                setlocale(LC_CTYPE, $currentLocale);
            }
            $output = shell_exec($cmd);
            $outputParts = '';
            foreach (explode(LF, $output) as $outputLine) {
                if (\TYPO3\CMS\Core\Utility\GeneralUtility::isFirstPartOfStr($outputLine, 'job')) {
                    $outputParts = explode(' ', $outputLine, 3);
                    break;
                }
            }
            if ($outputParts[0] === 'job' && \TYPO3\CMS\Core\Utility\MathUtility::canBeInterpretedAsInteger($outputParts[1])) {
                $atJobId = (int)$outputParts[1];
                $registry->set('tx_scheduler', 'atJobId', $atJobId);
            }
        }
        return TRUE;
    }

}