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

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\DBAL\Exception\LockWaitTimeoutException;
  20. use Doctrine\ORM\EntityManagerInterface;
  21. use Psr\Log\LoggerInterface;
  23. class Cron
  24. {
  25.     public const SCOPE_WEB = 'web';
  26.     public const SCOPE_CLI = 'cli';
  28.     /**
  29.      * @var \Closure():CronJobRepository
  30.      */
  31.     private \Closure $repository;
  33.     /**
  34.      * @var \Closure():EntityManagerInterface
  35.      */
  36.     private \Closure $entityManager;
  38.     private ?LoggerInterface $logger;
  40.     /**
  41.      * @var array<CronJob>
  42.      */
  43.     private array $cronJobs = [];
  45.     /**
  46.      * @param \Closure():CronJobRepository      $repository
  47.      * @param \Closure():EntityManagerInterface $entityManager
  48.      */
  49.     public function __construct(\Closure $repository, \Closure $entityManager, ?LoggerInterface $logger = null)
  50.     {
  51.         $this->repository = $repository;
  52.         $this->entityManager = $entityManager;
  53.         $this->logger = $logger;
  54.     }
  56.     public function addCronJob(CronJob $cronjob): void
  57.     {
  58.         $this->cronJobs[] = $cronjob;
  59.     }
  61.     /**
  62.      * Run all the registered Contao cron jobs.
  63.      */
  64.     public function run(string $scope): void
  65.     {
  66.         // Validate scope
  67.         if (self::SCOPE_WEB !== $scope && self::SCOPE_CLI !== $scope) {
  68.             throw new \InvalidArgumentException('Invalid scope "'.$scope.'"');
  69.         }
  71.         /** @var CronJobRepository $repository */
  72.         $repository = ($this->repository)();
  74.         /** @var EntityManagerInterface $entityManager */
  75.         $entityManager = ($this->entityManager)();
  77.         /** @var array<CronJob> $cronJobsToBeRun */
  78.         $cronJobsToBeRun = [];
  79.         $now = new \DateTimeImmutable();
  81.         // Return if another cron process is already running
  82.         try {
  83.             $repository->lockTable();
  84.         } catch (LockWaitTimeoutException $e) {
  85.             return;
  86.         }
  88.         try {
  89.             // Go through each cron job
  90.             foreach ($this->cronJobs as $cron) {
  91.                 $interval = $cron->getInterval();
  92.                 $name = $cron->getName();
  94.                 // Determine the last run date
  95.                 $lastRunDate = null;
  96.                 $lastRunEntity = $repository->findOneByName($name);
  98.                 if (null !== $lastRunEntity) {
  99.                     $lastRunDate = $lastRunEntity->getLastRun();
  100.                 } else {
  101.                     $lastRunEntity = new CronJobEntity($name);
  102.                     $entityManager->persist($lastRunEntity);
  103.                 }
  105.                 // Check if the cron should be run
  106.                 $expression = CronExpression::factory($interval);
  108.                 if (null !== $lastRunDate && $now < $expression->getNextRunDate($lastRunDate)) {
  109.                     continue;
  110.                 }
  112.                 // Store the previous run in case the cronjob skips itself
  113.                 $cron->setPreviousRun($lastRunEntity->getLastRun());
  115.                 // Update the cron entry
  116.                 $lastRunEntity->setLastRun($now);
  118.                 // Add job to the cron jobs to be run
  119.                 $cronJobsToBeRun[] = $cron;
  120.             }
  122.             $entityManager->flush();
  123.         } finally {
  124.             $repository->unlockTable();
  125.         }
  127.         $exception = null;
  129.         // Execute all cron jobs to be run
  130.         foreach ($cronJobsToBeRun as $cron) {
  131.             try {
  132.                 if (null !== $this->logger) {
  133.                     $this->logger->debug(sprintf('Executing cron job "%s"', $cron->getName()));
  134.                 }
  136.                 $cron($scope);
  137.             } catch (CronExecutionSkippedException $e) {
  138.                 // Restore previous run date in case cronjob skips itself
  139.                 $lastRunEntity = $repository->findOneByName($cron->getName());
  140.                 $lastRunEntity->setLastRun($cron->getPreviousRun());
  141.                 $entityManager->flush();
  142.             } catch (\Throwable $e) {
  143.                 // Catch any exceptions so that other cronjobs are still executed
  144.                 if (null !== $this->logger) {
  145.                     $this->logger->error((string) $e);
  146.                 }
  148.                 if (null === $exception) {
  149.                     $exception = $e;
  150.                 }
  151.             }
  152.         }
  154.         // Throw the first exception
  155.         if (null !== $exception) {
  156.             throw $exception;
  157.         }
  158.     }
  159. }