class Cron in Zircon Profile 8

The Drupal core Cron service.

Hierarchy

• class \Drupal\Core\Cron implements CronInterface

5 string references to 'Cron'

core.services.yml in core/core.services.yml

core/core.services.yml

ShortcutLinksTest::testAccessShortcutsPermission in core/modules/shortcut/src/Tests/ShortcutLinksTest.php

Tests that the 'access shortcuts' permissions works properly.

ShortcutLinksTest::testShortcutQuickLink in core/modules/shortcut/src/Tests/ShortcutLinksTest.php

Tests that the "add to shortcut" and "remove from shortcut" links work.

system.links.menu.yml in core/modules/system/system.links.menu.yml

core/modules/system/system.links.menu.yml

system.routing.yml in core/modules/system/system.routing.yml

core/modules/system/system.routing.yml

1 service uses Cron

cron in core/core.services.yml

Drupal\Core\Cron

File

core/lib/Drupal/Core/Cron.php, line 23

Contains \Drupal\Core\Cron.

Namespace

Drupal\Core

class Cron implements CronInterface {

  /**
   * The module handler service.
   *
   * @var \Drupal\Core\Extension\ModuleHandlerInterface
   */
  protected $moduleHandler;

  /**
   * The lock service.
   *
   * @var \Drupal\Core\Lock\LockBackendInterface
   */
  protected $lock;

  /**
   * The queue service.
   *
   * @var \Drupal\Core\Queue\QueueFactory
   */
  protected $queueFactory;

  /**
   * The state service.
   *
   * @var \Drupal\Core\State\StateInterface
   */
  protected $state;

  /**
   * The account switcher service.
   *
   * @var \Drupal\Core\Session\AccountSwitcherInterface
   */
  protected $accountSwitcher;

  /**
   * A logger instance.
   *
   * @var \Psr\Log\LoggerInterface
   */
  protected $logger;

  /**
   * The queue plugin manager.
   *
   * @var \Drupal\Core\Queue\QueueWorkerManagerInterface
   */
  protected $queueManager;

  /**
   * Constructs a cron object.
   *
   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
   *   The module handler
   * @param \Drupal\Core\Lock\LockBackendInterface $lock
   *   The lock service.
   * @param \Drupal\Core\Queue\QueueFactory $queue_factory
   *   The queue service.
   * @param \Drupal\Core\State\StateInterface $state
   *   The state service.
   * @param \Drupal\Core\Session\AccountSwitcherInterface $account_switcher
   *    The account switching service.
   * @param \Psr\Log\LoggerInterface $logger
   *   A logger instance.
   * @param \Drupal\Core\Queue\QueueWorkerManagerInterface
   *   The queue plugin manager.
   */
  public function __construct(ModuleHandlerInterface $module_handler, LockBackendInterface $lock, QueueFactory $queue_factory, StateInterface $state, AccountSwitcherInterface $account_switcher, LoggerInterface $logger, QueueWorkerManagerInterface $queue_manager) {
    $this->moduleHandler = $module_handler;
    $this->lock = $lock;
    $this->queueFactory = $queue_factory;
    $this->state = $state;
    $this->accountSwitcher = $account_switcher;
    $this->logger = $logger;
    $this->queueManager = $queue_manager;
  }

  /**
   * {@inheritdoc}
   */
  public function run() {

    // Allow execution to continue even if the request gets cancelled.
    @ignore_user_abort(TRUE);

    // Force the current user to anonymous to ensure consistent permissions on
    // cron runs.
    $this->accountSwitcher
      ->switchTo(new AnonymousUserSession());

    // Try to allocate enough time to run all the hook_cron implementations.
    drupal_set_time_limit(240);
    $return = FALSE;

    // Try to acquire cron lock.
    if (!$this->lock
      ->acquire('cron', 900.0)) {

      // Cron is still running normally.
      $this->logger
        ->warning('Attempting to re-run cron while it is already running.');
    }
    else {
      $this
        ->invokeCronHandlers();
      $this
        ->setCronLastTime();

      // Release cron lock.
      $this->lock
        ->release('cron');

      // Return TRUE so other functions can check if it did run successfully
      $return = TRUE;
    }

    // Process cron queues.
    $this
      ->processQueues();

    // Restore the user.
    $this->accountSwitcher
      ->switchBack();
    return $return;
  }

  /**
   * Records and logs the request time for this cron invocation.
   */
  protected function setCronLastTime() {

    // Record cron time.
    $this->state
      ->set('system.cron_last', REQUEST_TIME);
    $this->logger
      ->notice('Cron run completed.');
  }

  /**
   * Processes cron queues.
   */
  protected function processQueues() {

    // Grab the defined cron queues.
    foreach ($this->queueManager
      ->getDefinitions() as $queue_name => $info) {
      if (isset($info['cron'])) {

        // Make sure every queue exists. There is no harm in trying to recreate
        // an existing queue.
        $this->queueFactory
          ->get($queue_name)
          ->createQueue();
        $queue_worker = $this->queueManager
          ->createInstance($queue_name);
        $end = time() + (isset($info['cron']['time']) ? $info['cron']['time'] : 15);
        $queue = $this->queueFactory
          ->get($queue_name);
        while (time() < $end && ($item = $queue
          ->claimItem())) {
          try {
            $queue_worker
              ->processItem($item->data);
            $queue
              ->deleteItem($item);
          } catch (SuspendQueueException $e) {

            // If the worker indicates there is a problem with the whole queue,
            // release the item and skip to the next queue.
            $queue
              ->releaseItem($item);
            watchdog_exception('cron', $e);

            // Skip to the next queue.
            continue 2;
          } catch (\Exception $e) {

            // In case of any other kind of exception, log it and leave the item
            // in the queue to be processed again later.
            watchdog_exception('cron', $e);
          }
        }
      }
    }
  }

  /**
   * Invokes any cron handlers implementing hook_cron.
   */
  protected function invokeCronHandlers() {

    // Iterate through the modules calling their cron handlers (if any):
    foreach ($this->moduleHandler
      ->getImplementations('cron') as $module) {

      // Do not let an exception thrown by one module disturb another.
      try {
        $this->moduleHandler
          ->invoke($module, 'cron');
      } catch (\Exception $e) {
        watchdog_exception('cron', $e);
      }
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Cron::$accountSwitcher	protected	property	The account switcher service.
Cron::$lock	protected	property	The lock service.
Cron::$logger	protected	property	A logger instance.
Cron::$moduleHandler	protected	property	The module handler service.
Cron::$queueFactory	protected	property	The queue service.
Cron::$queueManager	protected	property	The queue plugin manager.
Cron::$state	protected	property	The state service.
Cron::invokeCronHandlers	protected	function	Invokes any cron handlers implementing hook_cron.
Cron::processQueues	protected	function	Processes cron queues.
Cron::run	public	function	Executes a cron run. Overrides CronInterface::run
Cron::setCronLastTime	protected	function	Records and logs the request time for this cron invocation.
Cron::__construct	public	function	Constructs a cron object.