wip: Adds basic scheduler

app/Console/ScheduledCommand.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Console;
+
+use Tempest\Console\ConsoleCommand;
+use Tempest\Console\ConsoleOutput;
+use Tempest\Console\Scheduler\Every;
+use Tempest\Console\Scheduler\Schedule;
+
+final class ScheduledCommand
+{
+    public function __construct(
+        protected ConsoleOutput $output,
+    ) {
+
+    }
+
+    #[Schedule(Every::Second)]
+    #[ConsoleCommand('scheduled')]
+    public function command(): void
+    {
+        $this->output->writeln('A command got scheduled');
+    }
+
+    #[Schedule(Every::Second)]
+    public function method(): void
+    {
+        $this->output->writeln('A method got scheduled');
+    }
+}

src/Commands/SchedulerRunCommand.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Commands;
+
+use Tempest\Console\ConsoleCommand;
+use Tempest\Console\Scheduler\Scheduler;
+
+final class SchedulerRunCommand
+{
+    public function __construct(
+        private Scheduler $scheduler,
+    ) {
+    }
+
+    #[ConsoleCommand('scheduler:run')]
+    public function __invoke(): void
+    {
+        $this->scheduler->run();
+    }
+}

src/Commands/SchedulerRunInvocationCommand.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Commands;
+
+use ReflectionMethod;
+use Tempest\Console\ConsoleCommand;
+use Tempest\Console\ConsoleOutput;
+use Tempest\Container\Container;
+
+final class SchedulerRunInvocationCommand
+{
+    public const string NAME = 'scheduler:invoke';
+
+    public function __construct(
+        private Container $container,
+        private ConsoleOutput $output,
+    ) {
+    }
+
+    #[ConsoleCommand(self::NAME)]
+    public function __invoke(string $invocation): void
+    {
+        $this->output->info("Invoking $invocation");
+
+        [$class, $method] = explode('::', $invocation);
+
+        $reflectionMethod = new ReflectionMethod($class, $method);
+
+        $reflectionMethod->invoke(
+            $this->container->get($class),
+        );
+    }
+}

src/Config/scheduler.php

@@ -0,0 +1,7 @@
+<?php
+
+declare(strict_types=1);
+
+use Tempest\Console\Scheduler\SchedulerConfig;
+
+return new SchedulerConfig();

src/ConsoleCommand.php

@@ -6,9 +6,10 @@
 
 use Attribute;
 use ReflectionMethod;
+use Tempest\Console\Scheduler\Invocation;
 
 #[Attribute]
-final class ConsoleCommand
+final class ConsoleCommand implements Invocation
 {
     public ReflectionMethod $handler;
 
@@ -64,7 +65,7 @@ public function __unserialize(array $data): void
     }
 
     /**
-     * @return \Tempest\Console\ConsoleArgumentDefinition[]
+     * @return ConsoleArgumentDefinition[]
      */
     public function getArgumentDefinitions(): array
     {

src/ConsoleConfig.php

@@ -11,7 +11,7 @@ final class ConsoleConfig
     public function __construct(
         public string $name = 'Tempest',
 
-        /** @var \Tempest\Console\ConsoleCommand[] $commands */
+        /** @var ConsoleCommand[] $commands */
         public array $commands = [],
     ) {
     }

src/Discovery/ScheduleDisovery.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Discovery;
+
+use ReflectionClass;
+use ReflectionMethod;
+use Tempest\Console\ConsoleCommand;
+use Tempest\Console\Scheduler\Schedule;
+use Tempest\Console\Scheduler\SchedulerConfig;
+use Tempest\Container\Container;
+use Tempest\Discovery\Discovery;
+use Tempest\Support\Reflection\Attributes;
+
+final class ScheduleDisovery implements Discovery
+{
+    private const CACHE_PATH = __DIR__ . '/schedule-discovery.cache.php';
+
+    public function __construct(private SchedulerConfig $schedulerConfig)
+    {
+    }
+
+    public function discover(ReflectionClass $class): void
+    {
+        foreach ($class->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+            $schedule = Attributes::find(Schedule::class)->in($method)->first();
+
+            if ($schedule === null) {
+                continue;
+            }
+
+            $command = Attributes::find(ConsoleCommand::class)->in($method)->first();
+
+            if ($command) {
+                $this->schedulerConfig->addCommandInvocation($method, $command, $schedule);
+            } else {
+                $this->schedulerConfig->addHandlerInvocation($method, $schedule);
+            }
+        }
+    }
+
+    public function hasCache(): bool
+    {
+        return file_exists(self::CACHE_PATH);
+    }
+
+    public function storeCache(): void
+    {
+        file_put_contents(self::CACHE_PATH, serialize($this->schedulerConfig->scheduledInvocations));
+    }
+
+    public function restoreCache(Container $container): void
+    {
+        $scheduledInvocations = unserialize(file_get_contents(self::CACHE_PATH));
+
+        $this->schedulerConfig->scheduledInvocations = $scheduledInvocations;
+    }
+
+    public function destroyCache(): void
+    {
+        @unlink(self::CACHE_PATH);
+    }
+}

src/Inititalizers/InvocationExecutorInitializer.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Inititalizers;
+
+use Tempest\Application;
+use Tempest\Console\ConsoleApplication;
+use Tempest\Console\Scheduler\GenericInvocationExecutor;
+use Tempest\Console\Scheduler\NullInvocationExecutor;
+use Tempest\Console\Scheduler\ScheduledInvocationExecutor;
+use Tempest\Container\Container;
+use Tempest\Container\Initializer;
+use Tempest\Container\Singleton;
+
+#[Singleton]
+final readonly class InvocationExecutorInitializer implements Initializer
+{
+    public function initialize(Container $container): ScheduledInvocationExecutor
+    {
+        $app = $container->get(Application::class);
+
+        if (! $app instanceof ConsoleApplication) {
+            $executor = new NullInvocationExecutor();
+        } else {
+            $executor = new GenericInvocationExecutor();
+        }
+
+        return $executor;
+    }
+}

src/Inititalizers/SchedulerInitializer.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Inititalizers;
+
+use Tempest\Application;
+use Tempest\Console\ConsoleApplication;
+use Tempest\Console\Scheduler\GenericScheduler;
+use Tempest\Console\Scheduler\NullScheduler;
+use Tempest\Console\Scheduler\ScheduledInvocationExecutor;
+use Tempest\Console\Scheduler\Scheduler;
+use Tempest\Console\Scheduler\SchedulerConfig;
+use Tempest\Container\Container;
+use Tempest\Container\Initializer;
+use Tempest\Container\Singleton;
+
+#[Singleton]
+final readonly class SchedulerInitializer implements Initializer
+{
+    public function initialize(Container $container): Scheduler
+    {
+        $app = $container->get(Application::class);
+
+        if (! $app instanceof ConsoleApplication) {
+            $consoleInput = new NullScheduler();
+        } else {
+            $consoleInput = new GenericScheduler(
+                $container->get(SchedulerConfig::class),
+                $container->get(ScheduledInvocationExecutor::class),
+            );
+        }
+
+        return $consoleInput;
+    }
+}

src/Scheduler/Every.php

@@ -0,0 +1,35 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Scheduler;
+
+enum Every
+{
+    case Second;
+    case Minute;
+    case QuarterHour;
+    case HalfHour;
+    case Hour;
+    case HalfDay;
+    case Day;
+    case Week;
+    case Month;
+    case Year;
+
+    public function toInterval(): Interval
+    {
+        return match ($this) {
+            self::Second => new Interval(seconds: 1),
+            self::Minute => new Interval(minutes: 1),
+            self::QuarterHour => new Interval(minutes: 15),
+            self::HalfHour => new Interval(minutes: 30),
+            self::Hour => new Interval(hours: 1),
+            self::HalfDay => new Interval(hours: 12),
+            self::Day => new Interval(days: 1),
+            self::Week => new Interval(weeks: 1),
+            self::Month => new Interval(months: 1),
+            self::Year => new Interval(years: 1),
+        };
+    }
+}

src/Scheduler/GenericInvocationExecutor.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Console\Scheduler;
+
+final class GenericInvocationExecutor implements ScheduledInvocationExecutor
+{
+    public function execute(string $compiledCommand): void
+    {
+        shell_exec($compiledCommand);
+    }
+}