├── src
    ├── Cron
    │   ├── Action.php
    │   ├── RunOnStartUpAction.php
    │   ├── ActionInterface.php
    │   ├── ActionTrait.php
    │   └── Scheduler.php
    └── Cron.php
├── example.php
├── LICENSE
└── composer.json


/src/Cron/Action.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace WyriHaximus\React\Cron;
 6 | 
 7 | final class Action implements ActionInterface
 8 | {
 9 |     use ActionTrait;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Cron/RunOnStartUpAction.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace WyriHaximus\React\Cron;
 6 | 
 7 | final class RunOnStartUpAction implements ActionInterface
 8 | {
 9 |     use ActionTrait;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/Cron/ActionInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace WyriHaximus\React\Cron;
 6 | 
 7 | interface ActionInterface
 8 | {
 9 |     /**
10 |      * Identifiable name for this action.
11 |      */
12 |     public function key(): string;
13 | 
14 |     /**
15 |      * Ttl for the mutex used to ensure we only have one of each action running at the same time.
16 |      * The action must have been finished within this time frame.
17 |      */
18 |     public function mutexTtl(): float;
19 | 
20 |     /**
21 |      * Returns true when it is time for this action to run, false when it isn't.
22 |      */
23 |     public function isDue(): bool;
24 | 
25 |     /**
26 |      * Run the action, throwing when it is for whatever reason unsuccessful.
27 |      */
28 |     public function perform(): void;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Cron/ActionTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace WyriHaximus\React\Cron;
 6 | 
 7 | use Cron\CronExpression;
 8 | 
 9 | trait ActionTrait
10 | {
11 |     private CronExpression $expression;
12 | 
13 |     /** @var callable */
14 |     private mixed $performer;
15 | 
16 |     public function __construct(private string $key, private float $mutexTtl, string $expression, callable $performer)
17 |     {
18 |         $this->expression = new CronExpression($expression);
19 |         $this->performer  = $performer;
20 |     }
21 | 
22 |     public function key(): string
23 |     {
24 |         return $this->key;
25 |     }
26 | 
27 |     public function mutexTtl(): float
28 |     {
29 |         return $this->mutexTtl;
30 |     }
31 | 
32 |     public function isDue(): bool
33 |     {
34 |         return $this->expression->isDue();
35 |     }
36 | 
37 |     public function perform(): void
38 |     {
39 |         ($this->performer)();
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/example.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use React\EventLoop\Factory;
 4 | use React\EventLoop\Loop;
 5 | use React\Promise\PromiseInterface;
 6 | use function React\Promise\resolve;
 7 | use WyriHaximus\React\Cron;
 8 | 
 9 | require 'vendor/autoload.php';
10 | 
11 | Cron::create(
12 |     new Cron\Action(
13 |         'Hour', // Identifier used for mutex locking locking
14 |         1, // TTL for Mutex Locking (usually a few times the maximum time this cron should take)
15 |         '@hourly', // The cron expression used to schedule this action
16 |         function (): PromiseInterface { // The callable ran when this action is due according to it's schedule
17 |             echo 'Another hour has passed!', PHP_EOL;
18 | 
19 |             return resolve(true); // This callable MUST return a promise, which is used for releasing the mutex lock
20 |         }
21 |     ),
22 |     new Cron\Action(
23 |         'Minute',
24 |         300,
25 |         '* * * * *',
26 |         function (): PromiseInterface {
27 |             echo 'Another minute has passed!', PHP_EOL;
28 | 
29 |             return resolve(true);
30 |         }
31 |     )
32 | );
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 Cees-Jan Kiewiet
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "wyrihaximus/react-cron",
 3 |   "description": "\u23f1\ufe0f Cronlike scheduler running inside the ReactPHP Event Loop",
 4 |   "license": "MIT",
 5 |   "require": {
 6 |     "php": "^8.4",
 7 |     "dragonmantank/cron-expression": "^3.4.0",
 8 |     "evenement/evenement": "^3.0.2",
 9 |     "lcobucci/clock": "^3.2",
10 |     "psr/clock": "^1.0",
11 |     "react/async": "^4.3",
12 |     "react/event-loop": "^1.5",
13 |     "react/promise": "^3.2",
14 |     "wyrihaximus/react-mutex": "^3.2",
15 |     "wyrihaximus/react-mutex-contracts": "^2.3"
16 |   },
17 |   "require-dev": {
18 |     "wyrihaximus/async-test-utilities": "^10.5.0",
19 |     "wyrihaximus/makefiles": "^0.7.15"
20 |   },
21 |   "conflict": {
22 |     "azjezz/psl": "<2"
23 |   },
24 |   "autoload": {
25 |     "psr-4": {
26 |       "WyriHaximus\\React\\": "src/"
27 |     }
28 |   },
29 |   "autoload-dev": {
30 |     "psr-4": {
31 |       "WyriHaximus\\Tests\\React\\Cron\\": "tests/"
32 |     }
33 |   },
34 |   "config": {
35 |     "allow-plugins": {
36 |       "composer/package-versions-deprecated": true,
37 |       "dealerdirect/phpcodesniffer-composer-installer": true,
38 |       "ergebnis/composer-normalize": true,
39 |       "icanhazstring/composer-unused": true,
40 |       "infection/extension-installer": true,
41 |       "phpstan/extension-installer": true,
42 |       "wyrihaximus/makefiles": true,
43 |       "wyrihaximus/test-utilities": true
44 |     },
45 |     "platform": {
46 |       "php": "8.4.13"
47 |     },
48 |     "sort-packages": true
49 |   },
50 |   "scripts": {
51 |     "post-install-cmd": [
52 |       "make on-install-or-update || true"
53 |     ],
54 |     "post-update-cmd": [
55 |       "make on-install-or-update || true"
56 |     ]
57 |   }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/Cron.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace WyriHaximus\React;
  6 | 
  7 | use Evenement\EventEmitterInterface;
  8 | use Evenement\EventEmitterTrait;
  9 | use Lcobucci\Clock\SystemClock;
 10 | use Psr\Clock\ClockInterface;
 11 | use React\EventLoop\Loop;
 12 | use Throwable;
 13 | use WyriHaximus\React\Cron\ActionInterface;
 14 | use WyriHaximus\React\Cron\RunOnStartUpAction;
 15 | use WyriHaximus\React\Cron\Scheduler;
 16 | use WyriHaximus\React\Mutex\Contracts\LockInterface;
 17 | use WyriHaximus\React\Mutex\Contracts\MutexInterface;
 18 | use WyriHaximus\React\Mutex\Memory;
 19 | 
 20 | use function React\Async\async;
 21 | use function React\Async\await;
 22 | 
 23 | /** @event error On caught Throws from action handling */
 24 | final class Cron implements EventEmitterInterface
 25 | {
 26 |     use EventEmitterTrait;
 27 | 
 28 |     /** @var array<ActionInterface> */
 29 |     private array $actions;
 30 | 
 31 |     private Scheduler $scheduler;
 32 | 
 33 |     private function __construct(private MutexInterface $mutex, ClockInterface $clock, ActionInterface ...$actions)
 34 |     {
 35 |         $this->scheduler = new Scheduler($clock);
 36 |         $this->actions   = $actions;
 37 | 
 38 |         foreach ($this->actions as $action) {
 39 |             if (! ($action instanceof RunOnStartUpAction)) {
 40 |                 continue;
 41 |             }
 42 | 
 43 |             Loop::futureTick(async(fn () => $this->perform($action)));
 44 |         }
 45 | 
 46 |         $this->scheduler->schedule(function (): void {
 47 |             $this->tick();
 48 |         });
 49 |     }
 50 | 
 51 |     public static function create(ActionInterface ...$actions): self
 52 |     {
 53 |         return self::createWithClockAndMutex(new Memory(), SystemClock::fromUTC(), ...$actions);
 54 |     }
 55 | 
 56 |     public static function createWithClock(ClockInterface $clock, ActionInterface ...$actions): self
 57 |     {
 58 |         return new self(new Memory(), $clock, ...$actions);
 59 |     }
 60 | 
 61 |     public static function createWithMutex(MutexInterface $mutex, ActionInterface ...$actions): self
 62 |     {
 63 |         return self::createWithClockAndMutex($mutex, SystemClock::fromUTC(), ...$actions);
 64 |     }
 65 | 
 66 |     public static function createWithClockAndMutex(MutexInterface $mutex, ClockInterface $clock, ActionInterface ...$actions): self
 67 |     {
 68 |         return new self($mutex, $clock, ...$actions);
 69 |     }
 70 | 
 71 |     public function stop(): void
 72 |     {
 73 |         $this->scheduler->stop();
 74 |     }
 75 | 
 76 |     private function tick(): void
 77 |     {
 78 |         foreach ($this->actions as $action) {
 79 |             if (! $action->isDue()) {
 80 |                 continue;
 81 |             }
 82 | 
 83 |             Loop::futureTick(async(fn () => $this->perform($action)));
 84 |         }
 85 |     }
 86 | 
 87 |     private function perform(ActionInterface $action): void
 88 |     {
 89 |         try {
 90 |             /** @var ?LockInterface $lock */
 91 |             $lock = await($this->mutex->acquire($action->key(), $action->mutexTtl()));
 92 |             if ($lock === null) {
 93 |                 return;
 94 |             }
 95 | 
 96 |             $action->perform();
 97 | 
 98 |             $this->mutex->release($lock);
 99 |         } catch (Throwable $throwable) {
100 |             $this->emit('error', [$throwable, $action]);
101 |         }
102 |     }
103 | }
104 | 


--------------------------------------------------------------------------------
/src/Cron/Scheduler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace WyriHaximus\React\Cron;
  6 | 
  7 | use DateTimeImmutable;
  8 | use Psr\Clock\ClockInterface;
  9 | use React\EventLoop\Loop;
 10 | use React\EventLoop\TimerInterface;
 11 | 
 12 | final class Scheduler
 13 | {
 14 |     private const int TIER_SLOW                          = 55;
 15 |     private const int TIER_MEDIUM                        = 58;
 16 |     private const int TIER_FAST                          = 59;
 17 |     private const float INTERVAL_SLOW_TO_MEDIUM          = 1.3;
 18 |     private const float INTERVAL_MEDIUM_TO_FAST          = 0.13;
 19 |     private const float INTERVAL_FAST                    = 0.001;
 20 |     private const int MINUTE_SECONDS                     = 60;
 21 |     private const bool ACTIVE                            = true;
 22 |     private const bool INACTIVE                          = false;
 23 |     private const int FIRST_SECOND_AFTER_OUR_TICK_WINDOW = 1;
 24 | 
 25 |     /** @var array<callable> */
 26 |     private array $ticks = [];
 27 | 
 28 |     private TimerInterface|null $timer = null;
 29 |     private bool $active               = self::ACTIVE;
 30 | 
 31 |     public function __construct(
 32 |         private readonly ClockInterface $clock,
 33 |     ) {
 34 |         $this->align();
 35 |     }
 36 | 
 37 |     public function schedule(callable $tick): void
 38 |     {
 39 |         // Push this new tick on the stack with the rest, running it in the next minute
 40 |         $this->ticks[] = $tick;
 41 |     }
 42 | 
 43 |     private function hasDrifted(DateTimeImmutable $time): bool
 44 |     {
 45 |         return (int) $time->format('s') > 0;
 46 |     }
 47 | 
 48 |     private function tick(): void
 49 |     {
 50 |         if ($this->active === self::INACTIVE) {
 51 |             return;
 52 |         }
 53 | 
 54 |         $startOfTick = $this->clock->now();
 55 | 
 56 |         foreach ($this->ticks as $tick) {
 57 |             $tick();
 58 |         }
 59 | 
 60 |         if (! $this->hasDrifted($startOfTick)) {
 61 |             return;
 62 |         }
 63 | 
 64 |         $this->align();
 65 |     }
 66 | 
 67 |     private function align(): void
 68 |     {
 69 |         if ($this->timer instanceof TimerInterface) {
 70 |             Loop::cancelTimer($this->timer);
 71 |             $this->timer = null;
 72 |         }
 73 | 
 74 |         $currentSecond = (int) $this->clock->now()->format('s');
 75 | 
 76 |         if ($currentSecond >= self::FIRST_SECOND_AFTER_OUR_TICK_WINDOW && $currentSecond <= self::TIER_SLOW) {
 77 |             $this->timer = Loop::addTimer(self::INTERVAL_SLOW_TO_MEDIUM, function (): void {
 78 |                 $this->timer = null;
 79 |                 $this->align();
 80 |             });
 81 | 
 82 |             return;
 83 |         }
 84 | 
 85 |         if ($currentSecond > self::TIER_SLOW && $currentSecond <= self::TIER_MEDIUM) {
 86 |             $this->timer = Loop::addTimer(self::INTERVAL_MEDIUM_TO_FAST, function (): void {
 87 |                 $this->timer = null;
 88 |                 $this->align();
 89 |             });
 90 | 
 91 |             return;
 92 |         }
 93 | 
 94 |         if ($currentSecond === self::TIER_FAST) {
 95 |             $this->timer = Loop::addTimer(self::INTERVAL_FAST, function (): void {
 96 |                 $this->timer = null;
 97 |                 $this->align();
 98 |             });
 99 | 
100 |             return;
101 |         }
102 | 
103 |         $this->tick();
104 | 
105 |         $this->timer = Loop::addPeriodicTimer(self::MINUTE_SECONDS, function (): void {
106 |             $this->tick();
107 |         });
108 |     }
109 | 
110 |     public function stop(): void
111 |     {
112 |         $this->active = self::INACTIVE;
113 | 
114 |         if (! ($this->timer instanceof TimerInterface)) {
115 |             return;
116 |         }
117 | 
118 |         Loop::cancelTimer($this->timer);
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------