CronjobScheduler.class.php

<?php
/**
 * CronjobScheduler - Scheduler for the cronjobs.
 *
 * @author      Jan-Hendrik Willms <tleilax+studip@gmail.com>
 * @license     http://www.gnu.org/licenses/gpl-2.0.html GPL version 2
 * @category    Stud.IP
 * @since       2.4
 */

// +---------------------------------------------------------------------------+
// This file is part of Stud.IP
// CronjobScheduler.class.php
//
// Copyright (C) 2013 Jan-Hendrik Willms <tleilax+studip@gmail.com>
// +---------------------------------------------------------------------------+
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or any later version.
// +---------------------------------------------------------------------------+
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
// +---------------------------------------------------------------------------+

class CronjobScheduler
{
    protected static $instance = null;

    /**
     * Returns the scheduler object. Implements the singleton pattern to
     * ensure that only one scheduler exists.
     *
     * @return CronjobScheduler The scheduler object
     */
    public static function getInstance()
    {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    protected $lock;

    /**
     * Private constructor to ensure the singleton pattern is used correctly.
     */
    private function __construct()
    {
        FileLock::setDirectory($GLOBALS['TMP_PATH']);
        $this->lock = new FileLock('studip-cronjob');
    }

    /**
     * Registers a new executable task.
     *
     * @param mixed $task Either path of the task class filename (relative
     *                    to Stud.IP root) or an instance of CronJob
     * @param bool   $active Indicates whether the task should be set active
     *                       or not
     * @return String Id of the created task
     * @throws InvalidArgumentException when the task class file does not
     *         exist
     * @throws RuntimeException when task has already been registered
     */
    public function registerTask($task, $active = true)
    {
        if (is_object($task)) {
            $reflection = new ReflectionClass($task);
            $class = $reflection->getName();
            $class_filename = studip_relative_path($reflection->getFileName());
        } else {
            $filename = $GLOBALS['STUDIP_BASE_PATH'] . '/' . $task;
            if (!file_exists($filename)) {
                $message = sprintf('Task class file "%s" does not exist.', $task);
                throw new InvalidArgumentException($message);
            }
            $class_filename = $task;

            $classes = get_declared_classes();
            require_once $filename;
            $new_classes = array_diff(get_declared_classes(), $classes);
            $new_classes = array_filter($new_classes, function ($class) {
                return is_subclass_of($class, 'CronJob', true);
            });
            $class = end($new_classes);

            if (empty($class)) {
                throw new RuntimeException('No valid class was defined in file.');
            }

            $reflection = new ReflectionClass($class);
        }

        if (!$reflection->isSubclassOf('CronJob')) {
            $message = sprintf('Job class "%s" (defined in %s) does not extend the abstract CronJob class.', $class, $filename);
            throw new RuntimeException($message);
        }

        if ($task = CronjobTask::findOneByClass($class)) {
            return $task->task_id;
        }

        $task = new CronjobTask();
        $task->filename = $class_filename;
        $task->class    = $class;
        $task->active   = (int)$active;
        $task->store();

        return $task->task_id;
    }

    /**
     * Unregisters a previously registered task.
     *
     * @param String $task_id Id of the task to be unregistered
     * @return CronjobScheduler to allow chaining
     * @throws InvalidArgumentException when no task with the given id exists
     */
    public function unregisterTask($task_id)
    {
        $task = CronjobTask::find($task_id);
        if ($task === null) {
            $message = sprintf('A task with the id "%s" does not exist.', $task_id);
            throw new InvalidArgumentException($message);
        }
        $task->delete();

        return $this;
    }

    /**
     * Schedules a task for a single execution at the provided time.
     *
     * @param String $task_id    The id of the task to be executed
     * @param int    $timestamp  When the task should be executed
     * @param String $priority   Priority of the execution (low, normal, high),
     *                           defaults to normal
     * @param Array  $parameters Optional parameters passed to the task
     * @return CronjobSchedule The generated schedule object.
     */
    public function scheduleOnce($task_id, $timestamp, $priority = CronjobSchedule::PRIORITY_NORMAL,
                                 $parameters = [])
    {
        $schedule = new CronjobSchedule();
        $schedule->type           = 'once';
        $schedule->task_id        = $task_id;
        $schedule->parameters     = $parameters;
        $schedule->priority       = $priority;
        $schedule->next_execution = $timestamp;

        $schedule->store();

        $task = $schedule->task;
        $task->assigned_count += 1;
        $task->store();

        return $schedule;
    }

    /**
     * Schedules a task for periodic execution with the provided schedule.
     *
     * @param String $task_id     The id of the task to be executed
     * @param mixed  $minute      Minute part of the schedule:
     *                            - null for "every minute" a.k.a. "don't care"
     *                            - x < 0 for "every x minutes"
     *                            - x >= 0 for "only at minute x"
     * @param mixed  $hour        Hour part of the schedule:
     *                            - null for "every hour" a.k.a. "don't care"
     *                            - x < 0 for "every x hours"
     *                            - x >= 0 for "only at hour x"
     * @param mixed  $day         Day part of the schedule:
     *                            - null for "every day" a.k.a. "don't care"
     *                            - x < 0 for "every x days"
     *                            - x > 0 for "only at day x"
     * @param mixed  $month       Month part of the schedule:
     *                            - null for "every month" a.k.a. "don't care"
     *                            - x < 0 for "every x months"
     *                            - x > 0 for "only at month x"
     * @param mixed  $day_of_week Day of week part of the schedule:
     *                            - null for "every day" a.k.a. "don't care"
     *                            - 1 >= x >= 7 for "exactly at day of week x"
     *                              (x starts with monday at 1 and ends with
     *                               sunday at 7)
     * @param String $priority   Priority of the execution (low, normal, high),
     *                           defaults to normal
     * @param Array  $parameters Optional parameters passed to the task
     * @return CronjobSchedule The generated schedule object.
     */
    public function schedulePeriodic($task_id, $minute = null, $hour = null,
                                     $day = null, $month = null, $day_of_week = null,
                                     $priority = CronjobSchedule::PRIORITY_NORMAL,
                                     $parameters = [])
    {
        $schedule = new CronjobSchedule();
        $schedule->type       = 'periodic';
        $schedule->task_id    = $task_id;
        $schedule->parameters = $parameters;
        $schedule->priority   = $priority;

        $schedule->minute = $minute;
        $schedule->hour = $hour;
        $schedule->day = $day;
        $schedule->month = $month;
        $schedule->day_of_week = $day_of_week;

        $schedule->store();

        $task = $schedule->task;
        $task->assigned_count += 1;
        $task->store();

        return $schedule;
    }

    /**
     * Cancels the provided schedule.
     *
     * @param String $schedule_id Id of the schedule to be canceled
     */
    public function cancel($schedule_id)
    {
        CronjobSchedule::find($schedule_id)->delete();
    }

    /**
     * Cancels all schedules of the provided task.
     *
     * @param String $task_id Id of the task which schedules shall be canceled
     */
    public function cancelByTask($task_id)
    {
        $schedules = CronjobSchedule::findByTask_id($task_id);
        foreach ($schedules as $schedule) {
            $schedule->delete();
        }
    }

    /**
     * Executes the available schedules if they are to be executed.
     * This method can only be run once - even if one execution takes more
     * than planned. This is ensured by a locking mechanism.
     */
    public function run()
    {
        if (!Config::get()->CRONJOBS_ENABLE) {
            return;
        }

        $escalation_time = Config::get()->CRONJOBS_ESCALATION;

        // Check whether a previous cronjob worker is still running.
        if ($this->lock->isLocked($data)) {
            // Running but not yet escalated -> let it run
            if ($data['timestamp'] + $escalation_time > time()) {
                return;
            }

            // Load locked schedule
            $schedule = CronjobSchedule::find($data['schedule_id']);

            // If we discovered a deadlock release it
            if ($schedule) {
                // Deactivate schedule
                $schedule->deactivate();

                // Adjust log
                $log = CronjobLog::find($data['log_id']);
                if ($log) {
                    $log->duration  = time() - $data['timestamp'];
                    $log->exception = new Exception('Cronjob has escalated');
                    $log->store();
                }

                // Inform roots about the escalated cronjob
                $subject = sprintf('[Cronjobs] %s: %s',
                                   _('Eskalierte Ausführung'),
                                   $schedule->title);

                $message = sprintf(_('Der Cronjob "%s" wurde deaktiviert, da '
                                    .'seine Ausführungsdauer die maximale '
                                    .'Ausführungszeit von %u Sekunden '
                                    .'überschritten hat.') . "\n",
                                   $schedule->title,
                                   $escalation_time);

                $this->sendMailToRoots($subject, $message);
            }

            // Release lock
            $this->lock->release();
        }

        // Find all schedules that are due to execute and which task is active
        $temp = CronjobSchedule::findBySQL('active = 1 AND next_execution <= UNIX_TIMESTAMP() '
                                          .'ORDER BY priority DESC, next_execution ASC');
#        $temp = SimpleORMapCollection::createFromArray($temp);
        $schedules = array_filter($temp, function ($schedule) { return $schedule->task->active; });

        if (count($schedules) === 0) {
            return;
        }

        foreach ($schedules as $schedule) {
            try {
                // Skip schedules with missing task classes
                if (!$schedule->task->valid) {
                    throw new Exception(_('Die Klase für den Cronjob-Task konnte nicht gefunden werden'));
                }

                $log = new CronjobLog();
                $log->schedule_id = $schedule->schedule_id;
                $log->scheduled   = $schedule->next_execution;
                $log->executed    = time();
                $log->exception   = null;
                $log->duration    = -1;
                $log->store();

                set_time_limit($escalation_time);

                // Activate the file lock and store the current timestamp,
                // schedule id and according log id in it
                $this->lock->lock([
                    'schedule_id' => $schedule->schedule_id,
                    'log_id'      => $log->log_id,
                ]);

                // Start capturing output and measuring duration
                ob_start();
                $start_time = microtime(true);

                $schedule->execute();

                // Actually capture output and duration
                $end_time = microtime(true);
                $output = ob_get_clean();

                // Complete log
                $log->output    = $output;
                $log->duration  = $end_time - $start_time;
                $log->store();
            } catch (Exception $e) {
                $log->exception = $e;

                // Deactivate schedule
                $schedule->deactivate();

                // Send mail to root accounts
                $subject = sprintf('[Cronjobs] %s: %s',
                                   _('Fehlerhafte Ausführung'),
                                   $schedule->title);

                $message = sprintf(_('Der Cronjob "%s" wurde deaktiviert, da bei der Ausführung ein Fehler aufgetreten ist.'), $schedule->title) . "\n";
                $message .= "\n";
                $message .= display_exception($e) . "\n";

                $message .= _('Für weiterführende Informationen klicken Sie bitten den folgenden Link:') . "\n";

                $old = URLHelper::setBaseURL($GLOBALS['ABSOLUTE_URI_STUDIP']);
                $message .= URLHelper::getURL('dispatch.php/admin/cronjobs/logs/schedule/' . $schedule->schedule_id);
                URLHelper::setBaseURL($old);

                $this->sendMailToRoots($subject, $message);
            }
        }

        // Release lock
        $this->lock->release();
    }

    /**
     * Sends an internal mail with the provided subject and message to all
     * users with a global permission of "root".
     *
     * @param String $subject The subject of the message
     * @param String $message The message itself
     */
    private function sendMailToRoots($subject, $message)
    {
        $temp  = User::findByPerms('root');
        $roots = SimpleORMapCollection::createFromArray($temp)
            ->filter(function($r) { return $r->locked == 0; })
            ->pluck('username');

        $msging = new messaging;
        $msging->insert_message($message, $roots, '____%system%____', null, null, null, null, $subject, false, 'high');
    }
}