WebSVN – Moodle – Diff – /lib/classes/task/manager.php

      * Checks if the task with the same classname, component and customdata is already scheduled
+     *
      * @param adhoc_task $task
      * @return \stdClass|false
      */
-    protected static function get_queued_adhoc_task_record($task) {
+    public static function get_queued_adhoc_task_record($task) {
         global $DB;
         $record = self::record_from_adhoc_task($task);
         $params = [$record->classname, $record->component, $record->customdata];
      * @return boolean - True if the config was saved.
      */
     public static function queue_adhoc_task(adhoc_task $task, $checkforexisting = false) {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
+        // Don't queue tasks for deprecated components.
+        if (self::task_component_is_deprecated($task)) {
+            return false;
+        }
         if ($userid = $task->get_userid()) {
             // User found. Check that they are suitable.
             \core_user::require_active_user(\core_user::get_user($userid, '*', MUST_EXIST), true, true);
+        }
         $record = self::record_from_adhoc_task($task);
         // Schedule it immediately if nextruntime not explicitly set.
         if (!$task->get_next_run_time()) {
-            $record->nextruntime = time() - 1;
+            $record->nextruntime = $clock->time() - 1;
+        }
         // Check if the task is allowed to be retried or not.
         $record->attemptsavailable = $task->retry_until_success() ? $record->attemptsavailable : 1;
         // Set the time the task was created.
-        $record->timecreated = time();
+        $record->timecreated = $clock->time();
     /**
      * This function load the adhoc tasks for a given classname.
+     *
      * @param string $classname
-     * @param bool $failedonly
+     * @param bool $failedonly Return only failed tasks
+     * @param bool $skiprunning Do not return tasks that are in the running state
-     * @param bool $skiprunning do not return tasks that are in the running state
+     * @param bool $dueonly Return only tasks that are due to run (nextruntime < now)
      * @return array
      */
+    public static function get_adhoc_tasks(
+        string $classname,
+        bool $failedonly = false,
+        bool $skiprunning = false,
+        bool $dueonly = false
-    public static function get_adhoc_tasks(string $classname, bool $failedonly = false, bool $skiprunning = false): array {
+    ): array {
         global $DB;
         $conds[] = 'classname = ?';
         $params[] = self::get_canonical_class_name($classname);
+        if ($failedonly) {
             $conds[] = 'faildelay > 0';
-        if ($failedonly) {
+        } else if ($dueonly) {
-            $conds[] = 'faildelay > 0';
+            $conds[] = 'faildelay = 0';
+        }
      * @return array
      */
     public static function get_adhoc_tasks_summary(): array {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
-        $now = time();
+        $now = $clock->time();
         $records = $DB->get_records('task_adhoc');
         $summary = [];
         foreach ($records as $r) {
             if (!isset($summary[$r->component])) {
         $records = $DB->get_records('task_scheduled', null, 'component, classname', '*', IGNORE_MISSING);
         $tasks = array();
         foreach ($records as $record) {
+            $task = self::scheduled_task_from_record($record);
             $task = self::scheduled_task_from_record($record);
             // Safety check in case the task in the DB does not match a real class (maybe something was uninstalled).
-            if ($task) {
+            if (!$task) {
-                $tasks[] = $task;
+                continue;
+            }
+            // Tasks belonging to deprecated plugin types are excluded.
+            if (self::task_component_is_deprecated($task)) {
+                continue;
+            }
             $tasks[] = $task;
+        }
+        }
         return $tasks;
+    }
-    /**
-     * Ensure quality of service for the ad hoc task queue.
-     *
-     * This reshuffles the adhoc tasks queue to balance by type to ensure a
-     * level of quality of service per type, while still maintaining the
-     * relative order of tasks queued by timestamp.
-     *
-     * @param array $records array of task records
-     * @param array $records array of same task records shuffled
+    /**
-     * @deprecated since Moodle 4.1 MDL-67648 - please do not use this method anymore.
-     * @todo MDL-74843 This method will be deleted in Moodle 4.5
-     * @see \core\task\manager::get_next_adhoc_task
+     * @deprecated since Moodle 4.1 MDL-67648
-     */
-    public static function ensure_adhoc_task_qos(array $records): array {
-        debugging('The method \core\task\manager::ensure_adhoc_task_qos is deprecated.
+     */
-             Please use \core\task\manager::get_next_adhoc_task instead.', DEBUG_DEVELOPER);
-        $count = count($records);
-        if ($count == 0) {
-            return $records;
-        }
-        $queues = []; // This holds a queue for each type of adhoc task.
-        $limits = []; // The relative limits of each type of task.
-        $limittotal = 0;
+    #[\core\attribute\deprecated('\core\task\manager::get_next_adhoc_task()', since: '4.1', mdl: 'MDL-67648', final: true)]
-        // Split the single queue up into queues per type.
-        foreach ($records as $record) {
-            $type = $record->classname;
-            if (!array_key_exists($type, $queues)) {
-                $queues[$type] = [];
-            }
-            if (!array_key_exists($type, $limits)) {
-                $limits[$type] = 1;
-                $limittotal += 1;
-            }
-            $queues[$type][] = $record;
-        }
-        $qos = []; // Our new queue with ensured quality of service.
-        $seed = $count % $limittotal; // Which task queue to shuffle from first?
-        $move = 1; // How many tasks to shuffle at a time.
-        do {
-            $shuffled = 0;
-            // Now cycle through task type queues and interleaving the tasks
-            // back into a single queue.
-            foreach ($limits as $type => $limit) {
-                // Just interleaving the queue is not enough, because after
-                // any task is processed the whole queue is rebuilt again. So
-                // we need to deterministically start on different types of
-                // tasks so that *on average* we rotate through each type of task.
-                //
-                // We achieve this by using a $seed to start moving tasks off a
+    public static function ensure_adhoc_task_qos(): void {
-                // different queue each time. The seed is based on the task count
-                // modulo the number of types of tasks on the queue. As we count
-                // down this naturally cycles through each type of record.
-                if ($seed < 1) {
-                    $shuffled = 1;
-                    $seed += 1;
-                    continue;
-                }
-                $tasks = array_splice($queues[$type], 0, $move);
-                $qos = array_merge($qos, $tasks);
-                // Stop if we didn't move any tasks onto the main queue.
-                $shuffled += count($tasks);
-            }
-            // Generally the only tasks that matter are those that are near the start so
-            // after we have shuffled the first few 1 by 1, start shuffling larger groups.
-            if (count($qos) >= (4 * count($limits))) {
-                $move *= 2;
-            }
-        } while ($shuffled > 0);
-        return $qos;
+        \core\deprecation::emit_deprecation([self::class, __FUNCTION__]);
+    }
     /**
         return null;
+    }
+    /**
+     * This function will delete an adhoc task by id. The task will be removed
+     * from the database.
+     *
+     * @param int $taskid
+     */
+    public static function delete_adhoc_task(int $taskid): void {
+        global $DB;
+        $DB->delete_records('task_adhoc', ['id' => $taskid]);
+    }
     /**
      * This function will set locks on the task.
+     *
      * @param adhoc_task    $task
         $task->set_lock($lock);
         $cronlock->release();
+    }
+    /**
+     * Helper to check whether a task's component is deprecated.
+     *
+     * @param task_base $task the task instance
+     * @return bool true if deprecated, false otherwise.
+     */
+    private static function task_component_is_deprecated(task_base $task): bool {
+        // Only supports plugin type deprecation. Info will be null for other, non-plugin components.
+        if ($info = \core_plugin_manager::instance()->get_plugin_info($task->get_component())) {
+            if ($info->is_deprecated() || $info->is_deleted()) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * This function will dispatch the next scheduled task in the queue. The task will be handed out
      * with an open lock - possibly on the entire cron process. Make sure you call either
      * {@link scheduled_task_failed} or {@link scheduled_task_complete} to release the lock and reschedule the task.
+     *
         foreach ($records as $record) {
             $task = self::scheduled_task_from_record($record);
             // Safety check in case the task in the DB does not match a real class (maybe something was uninstalled).
-            // Also check to see if task is disabled or enabled after applying overrides.
+            // Also check to see if task is disabled or enabled after applying overrides, or if the plugintype is deprecated.
-            if (!$task || $task->get_disabled()) {
+            if (!$task || $task->get_disabled() || self::task_component_is_deprecated($task)) {
                 continue;
+            }
     /**
      * This function indicates that an adhoc task was not completed successfully and should be retried.
+     *
+     * @param \core\task\adhoc_task $task
-     * @param \core\task\adhoc_task $task
+     * @param bool $finaliselog finalise the log of the current running task
      */
-    public static function adhoc_task_failed(adhoc_task $task) {
+    public static function adhoc_task_failed(adhoc_task $task, bool $finaliselog = true) {
+        global $DB;
+        $clock = \core\di::get(\core\clock::class);
         global $DB;
+        // Finalise the log output.
-        // Finalise the log output.
+        if ($finaliselog) {
+            logmanager::finalise_log(true);
         logmanager::finalise_log(true);
         $delay = $task->get_fail_delay();
         // Reschedule and then release the locks.
         $task->set_timestarted();
         $task->set_hostname();
         $task->set_pid();
-        $task->set_next_run_time(time() + $delay);
+        $task->set_next_run_time($clock->time() + $delay);
         $task->set_fail_delay($delay);
         if ($task->get_attempts_available() > 0) {
             $task->set_attempts_available($task->get_attempts_available() - 1);
+        }
         global $DB;
         $pid = (int)getmypid();
         $hostname = (string)gethostname();
+        if (empty($time)) {
-        if (empty($time)) {
+            $clock = \core\di::get(\core\clock::class);
-            $time = time();
+            $time = $clock->time();
+        }
         $task->set_timestarted($time);
     /**
      * This function indicates that a scheduled task was not completed successfully and should be retried.
+     *
+     * @param \core\task\scheduled_task $task
-     * @param \core\task\scheduled_task $task
+     * @param bool $finaliselog finalise the log of the current running task
      */
-    public static function scheduled_task_failed(scheduled_task $task) {
+    public static function scheduled_task_failed(scheduled_task $task, bool $finaliselog = true) {
+        global $DB;
+        $clock = \core\di::get(\core\clock::class);
         global $DB;
+        // Finalise the log output.
-        // Finalise the log output.
+        if ($finaliselog) {
+            logmanager::finalise_log(true);
         logmanager::finalise_log(true);
         $delay = $task->get_fail_delay();
         $task->set_pid();
         $classname = self::get_canonical_class_name($task);
         $record = $DB->get_record('task_scheduled', array('classname' => $classname));
-        $record->nextruntime = time() + $delay;
+        $record->nextruntime = $clock->time() + $delay;
         $record->faildelay = $delay;
         $record->timestarted = null;
         $record->hostname = null;
      * @param int $time Start time (0 = current)
      * @throws \dml_exception If the task doesn't exist
      */
     public static function scheduled_task_starting(scheduled_task $task, int $time = 0) {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
         $pid = (int)getmypid();
         $hostname = (string)gethostname();
         if (!$time) {
-            $time = time();
+            $time = $clock->time();
+        }
         $task->set_timestarted($time);
      * @param \core\task\scheduled_task $task
      */
     public static function scheduled_task_complete(scheduled_task $task) {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
         // Finalise the log output.
         logmanager::finalise_log();
         $task->set_timestarted();
         $task->set_hostname();
         $task->set_pid();
         $classname = self::get_canonical_class_name($task);
         $record = $DB->get_record('task_scheduled', array('classname' => $classname));
         if ($record) {
-            $record->lastruntime = time();
+            $record->lastruntime = $clock->time();
             $record->faildelay = 0;
             $record->nextruntime = $task->get_next_scheduled_time();
             $record->timestarted = null;
      * @return array Array of scheduled and adhoc tasks
      * @throws \dml_exception
      */
     public static function get_running_tasks($sort = ''): array {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
         if (empty($sort)) {
             $sort = 'timestarted ASC, classname ASC';
+        }
-        $params = ['now1' => time(), 'now2' => time()];
+        $params = ['now1' => $clock->time(), 'now2' => $clock->time()];
         $sql = "SELECT subquery.*
                   FROM (SELECT " . $DB->sql_concat("'s'", 'ts.id') . " as uniqueid,
                                ts.id,
      * Cleanup stale task metadata.
      */
     public static function cleanup_metadata() {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
         $cronlockfactory = \core\lock\lock_config::get_lock_factory('cron');
         $runningtasks = self::get_running_tasks();
         foreach ($runningtasks as $runningtask) {
-            if ($runningtask->timestarted > time() - HOURSECS) {
+            if ($runningtask->timestarted > $clock->time() - HOURSECS) {
                 continue;
+            }
                         continue;
+                    }
                     $task = self::scheduled_task_from_record($taskrecord);
+                    $task->set_lock($lock);
+                    // We have to skip log finalisation when failing the task as the finalise_log method from
-                    $task->set_lock($lock);
+                    // the log manager is only aware of the current running task (i.e., the cleanup task).
-                    self::scheduled_task_failed($task);
+                    self::scheduled_task_failed($task, false);
                 } else if ($runningtask->type == 'adhoc') {
                     // Ad hoc tasks are removed from the DB if they finish successfully.
                     // If we can't re-get this task, that means it finished and was properly
                     // cleaned up.
                         continue;
+                    }
                     $task = self::adhoc_task_from_record($taskrecord);
+                    $task->set_lock($lock);
+                    // We have to skip log finalisation when failing the task as the finalise_log method from
-                    $task->set_lock($lock);
+                    // the log manager is only aware of the current running task (i.e., the cleanup task).
-                    self::adhoc_task_failed($task);
+                    self::adhoc_task_failed($task, false);
+                }
+            }
+        }
      * next opportunity and restart. This is because something (e.g. DB changes) has changed and
      * the static caches may be stale.
      */
     public static function clear_static_caches() {
         global $DB;
+        $clock = \core\di::get(\core\clock::class);
         // Do not use get/set config here because the caches cannot be relied on.
         $record = $DB->get_record('config', array('name'=>'scheduledtaskreset'));
         if ($record) {
-            $record->value = time();
+            $record->value = $clock->time();
             $DB->update_record('config', $record);
         } else {
             $record = new \stdClass();
             $record->name = 'scheduledtaskreset';
-            $record->value = time();
+            $record->value = $clock->time();
             $DB->insert_record('config', $record);
+        }
+    }
      */
     protected static function find_php_cli_path() {
         global $CFG;
         if (!empty($CFG->pathtophp) && is_executable(trim($CFG->pathtophp))) {
-            return $CFG->pathtophp;
+            return trim($CFG->pathtophp);
+        }
     /**
      * Clean up failed adhoc tasks.
      */
     public static function clean_failed_adhoc_tasks(): void {
         global $CFG, $DB;
+        $clock = \core\di::get(\core\clock::class);
         $difftime = !empty($CFG->task_adhoc_failed_retention) ?
             $CFG->task_adhoc_failed_retention : static::ADHOC_TASK_FAILED_RETENTION;
         $DB->delete_records_select(
             table: 'task_adhoc',
             select: 'attemptsavailable = 0 AND firststartingtime < :time',
-            params: ['time' => time() - $difftime],
+            params: ['time' => $clock->time() - $difftime],
         );
+    }
+}

Proyectos de Subversion Moodle

(root)/lib/classes/task/manager.php – Rev 11 → 1441