vendor/contao/core-bundle/src/Cron/Cron.php line 131

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of Contao.
  7.  *
  8.  * (c) Leo Feyer
  9.  *
  10.  * @license LGPL-3.0-or-later
  11.  */
  13. namespace Contao\CoreBundle\Cron;
  15. use Contao\CoreBundle\Entity\CronJob as CronJobEntity;
  16. use Contao\CoreBundle\Exception\CronExecutionSkippedException;
  17. use Contao\CoreBundle\Repository\CronJobRepository;
  18. use Cron\CronExpression;
  19. use Doctrine\ORM\EntityManagerInterface;
  20. use Psr\Log\LoggerInterface;
  22. class Cron
  23. {
  24.     public const SCOPE_WEB = 'web';
  25.     public const SCOPE_CLI = 'cli';
  27.     /**
  28.      * @var \Closure():CronJobRepository
  29.      */
  30.     private \Closure $repository;
  32.     /**
  33.      * @var \Closure():EntityManagerInterface
  34.      */
  35.     private \Closure $entityManager;
  37.     private ?LoggerInterface $logger;
  39.     /**
  40.      * @var array<CronJob>
  41.      */
  42.     private array $cronJobs = [];
  44.     /**
  45.      * @param \Closure():CronJobRepository      $repository
  46.      * @param \Closure():EntityManagerInterface $entityManager
  47.      */
  48.     public function __construct(\Closure $repository, \Closure $entityManager, LoggerInterface $logger = null)
  49.     {
  50.         $this->repository = $repository;
  51.         $this->entityManager = $entityManager;
  52.         $this->logger = $logger;
  53.     }
  55.     public function addCronJob(CronJob $cronjob): void
  56.     {
  57.         $this->cronJobs[] = $cronjob;
  58.     }
  60.     /**
  61.      * Run all the registered Contao cron jobs.
  62.      */
  63.     public function run(string $scope): void
  64.     {
  65.         // Validate scope
  66.         if (self::SCOPE_WEB !== $scope && self::SCOPE_CLI !== $scope) {
  67.             throw new \InvalidArgumentException('Invalid scope "'.$scope.'"');
  68.         }
  70.         /** @var CronJobRepository $repository */
  71.         $repository = ($this->repository)();
  73.         /** @var EntityManagerInterface $entityManager */
  74.         $entityManager = ($this->entityManager)();
  76.         /** @var array<CronJob> $cronJobsToBeRun */
  77.         $cronJobsToBeRun = [];
  78.         $now = new \DateTimeImmutable();
  80.         try {
  81.             // Lock cron table
  82.             $repository->lockTable();
  84.             // Go through each cron job
  85.             foreach ($this->cronJobs as $cron) {
  86.                 $interval = $cron->getInterval();
  87.                 $name = $cron->getName();
  89.                 // Determine the last run date
  90.                 $lastRunDate = null;
  91.                 $lastRunEntity = $repository->findOneByName($name);
  93.                 if (null !== $lastRunEntity) {
  94.                     $lastRunDate = $lastRunEntity->getLastRun();
  95.                 } else {
  96.                     $lastRunEntity = new CronJobEntity($name);
  97.                     $entityManager->persist($lastRunEntity);
  98.                 }
  100.                 // Check if the cron should be run
  101.                 $expression = CronExpression::factory($interval);
  103.                 if (null !== $lastRunDate && $now < $expression->getNextRunDate($lastRunDate)) {
  104.                     continue;
  105.                 }
  107.                 // Store the previous run in case the cronjob skips itself
  108.                 $cron->setPreviousRun($lastRunEntity->getLastRun());
  110.                 // Update the cron entry
  111.                 $lastRunEntity->setLastRun($now);
  113.                 // Add job to the cron jobs to be run
  114.                 $cronJobsToBeRun[] = $cron;
  115.             }
  117.             $entityManager->flush();
  118.         } finally {
  119.             $repository->unlockTable();
  120.         }
  122.         $exception = null;
  124.         // Execute all cron jobs to be run
  125.         foreach ($cronJobsToBeRun as $cron) {
  126.             try {
  127.                 if (null !== $this->logger) {
  128.                     $this->logger->debug(sprintf('Executing cron job "%s"', $cron->getName()));
  129.                 }
  131.                 $cron($scope);
  132.             } catch (CronExecutionSkippedException $e) {
  133.                 // Restore previous run date in case cronjob skips itself
  134.                 $lastRunEntity = $repository->findOneByName($cron->getName());
  135.                 $lastRunEntity->setLastRun($cron->getPreviousRun());
  136.                 $entityManager->flush();
  137.             } catch (\Throwable $e) {
  138.                 // Catch any exceptions so that other cronjobs are still executed
  139.                 if (null !== $this->logger) {
  140.                     $this->logger->error((string) $e);
  141.                 }
  143.                 if (null === $exception) {
  144.                     $exception = $e;
  145.                 }
  146.             }
  147.         }
  149.         // Throw the first exception
  150.         if (null !== $exception) {
  151.             throw $exception;
  152.         }
  153.     }
  154. }