├── src
    ├── GRPC
    │   ├── Exception
    │   │   ├── CompileException.php
    │   │   └── ServiceRegistrationException.php
    │   ├── ProtoRepository
    │   │   ├── ProtoFilesRepositoryInterface.php
    │   │   ├── FileRepository.php
    │   │   └── CompositeRepository.php
    │   ├── Generator
    │   │   ├── GeneratorRegistryInterface.php
    │   │   ├── GeneratorInterface.php
    │   │   └── GeneratorRegistry.php
    │   ├── LocatorInterface.php
    │   ├── UnaryCallInterface.php
    │   └── Internal
    │   │   ├── CommandExecutor.php
    │   │   ├── UnaryCall.php
    │   │   ├── ProtocCommandBuilder.php
    │   │   ├── ServiceLocator.php
    │   │   ├── ProtoCompiler.php
    │   │   ├── Dispatcher.php
    │   │   └── Invoker.php
    ├── Centrifugo
    │   ├── Exception
    │   │   ├── CentrifugoException.php
    │   │   └── ConfigurationException.php
    │   ├── ServiceInterface.php
    │   ├── ErrorHandlerInterface.php
    │   ├── Internal
    │   │   ├── LogErrorHandler.php
    │   │   ├── Broadcast.php
    │   │   ├── Dispatcher.php
    │   │   ├── ServiceRegistry.php
    │   │   ├── InterceptorRegistry.php
    │   │   └── Server.php
    │   ├── RegistryInterface.php
    │   └── Interceptor
    │   │   └── RegistryInterface.php
    ├── Exception
    │   └── DispatcherNotFoundException.php
    ├── Tcp
    │   ├── Response
    │   │   ├── ResponseInterface.php
    │   │   ├── ContinueRead.php
    │   │   ├── CloseConnection.php
    │   │   └── RespondMessage.php
    │   ├── Service
    │   │   ├── Exception
    │   │   │   └── NotFoundException.php
    │   │   ├── ServiceInterface.php
    │   │   └── RegistryInterface.php
    │   ├── Internal
    │   │   ├── Dispatcher.php
    │   │   ├── InterceptorRegistry.php
    │   │   ├── ServiceRegistry.php
    │   │   └── Server.php
    │   └── Interceptor
    │   │   └── RegistryInterface.php
    ├── Queue
    │   ├── PayloadDeserializerInterface.php
    │   ├── PipelineRegistryInterface.php
    │   └── Internal
    │   │   ├── OptionsFactory.php
    │   │   ├── Queue.php
    │   │   ├── PayloadDeserializer.php
    │   │   ├── Dispatcher.php
    │   │   └── RPCPipelineRegistry.php
    ├── Bootloader
    │   ├── LockBootloader.php
    │   ├── MetricsBootloader.php
    │   ├── LoggerBootloader.php
    │   ├── CommandBootloader.php
    │   ├── HttpBootloader.php
    │   ├── CacheBootloader.php
    │   ├── RoadRunnerBootloader.php
    │   ├── QueueBootloader.php
    │   ├── ScaffolderBootloader.php
    │   ├── TcpBootloader.php
    │   ├── CentrifugoBootloader.php
    │   └── GRPCBootloader.php
    ├── RoadRunnerMode.php
    ├── Config
    │   ├── QueueConfig.php
    │   ├── CentrifugoConfig.php
    │   ├── TcpConfig.php
    │   └── GRPCConfig.php
    ├── Logger
    │   ├── RoadRunnerLogsMode.php
    │   ├── Handler.php
    │   └── Internal
    │   │   └── RoadRunnerJsonFormatter.php
    ├── Console
    │   └── Command
    │   │   ├── GRPC
    │   │       ├── ListCommand.php
    │   │       └── GenerateCommand.php
    │   │   ├── Queue
    │   │       ├── PauseCommand.php
    │   │       ├── ResumeCommand.php
    │   │       └── ListCommand.php
    │   │   └── Scaffolder
    │   │       ├── TcpServiceCommand.php
    │   │       └── CentrifugoHandlerCommand.php
    ├── Scaffolder
    │   └── Declaration
    │   │   ├── TcpServiceDeclaration.php
    │   │   └── CentrifugoHandlerDeclaration.php
    ├── FallbackDispatcher.php
    └── Http
    │   └── Internal
    │       └── Dispatcher.php
├── LICENSE
├── composer.json
└── README.md


/src/GRPC/Exception/CompileException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | namespace Spiral\RoadRunnerBridge\GRPC\Exception;
6 | 
7 | class CompileException extends \RuntimeException {}
8 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Exception/CentrifugoException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Exception;
6 | 
7 | class CentrifugoException extends \RuntimeException {}
8 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Exception/ConfigurationException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | declare(strict_types=1);
4 | 
5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Exception;
6 | 
7 | final class ConfigurationException extends CentrifugoException {}
8 | 


--------------------------------------------------------------------------------
/src/Exception/DispatcherNotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Exception;
 6 | 
 7 | use Spiral\Boot\Exception\BootException;
 8 | 
 9 | class DispatcherNotFoundException extends BootException {}
10 | 


--------------------------------------------------------------------------------
/src/GRPC/Exception/ServiceRegistrationException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Exception;
 6 | 
 7 | use Spiral\Boot\Exception\BootException;
 8 | 
 9 | class ServiceRegistrationException extends BootException {}
10 | 


--------------------------------------------------------------------------------
/src/Centrifugo/ServiceInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo;
 6 | 
 7 | use RoadRunner\Centrifugo\Request\RequestInterface;
 8 | 
 9 | interface ServiceInterface
10 | {
11 |     public function handle(RequestInterface $request): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Centrifugo/ErrorHandlerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo;
 6 | 
 7 | use RoadRunner\Centrifugo\Request\RequestInterface;
 8 | 
 9 | interface ErrorHandlerInterface
10 | {
11 |     public function handle(RequestInterface $request, \Throwable $e): void;
12 | }
13 | 


--------------------------------------------------------------------------------
/src/Tcp/Response/ResponseInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Response;
 6 | 
 7 | use Spiral\RoadRunner\Tcp\TcpResponse;
 8 | 
 9 | interface ResponseInterface
10 | {
11 |     public function getBody(): string;
12 | 
13 |     public function getAction(): TcpResponse;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/GRPC/ProtoRepository/ProtoFilesRepositoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\ProtoRepository;
 6 | 
 7 | interface ProtoFilesRepositoryInterface
 8 | {
 9 |     /**
10 |      * Get proto files paths
11 |      *
12 |      * @return iterable<non-empty-string>
13 |      */
14 |     public function getProtos(): iterable;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/GRPC/Generator/GeneratorRegistryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Generator;
 6 | 
 7 | interface GeneratorRegistryInterface
 8 | {
 9 |     public function addGenerator(GeneratorInterface $generator): void;
10 | 
11 |     /**
12 |      * @return GeneratorInterface[]
13 |      */
14 |     public function getGenerators(): array;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Queue/PayloadDeserializerInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Queue;
 6 | 
 7 | use Spiral\RoadRunner\Jobs\Task\ReceivedTaskInterface;
 8 | 
 9 | interface PayloadDeserializerInterface
10 | {
11 |     /**
12 |      * Deserializes the payload of the given task.
13 |      */
14 |     public function deserialize(ReceivedTaskInterface $task): mixed;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/GRPC/Generator/GeneratorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Generator;
 6 | 
 7 | interface GeneratorInterface
 8 | {
 9 |     /**
10 |      * @param non-empty-string[] $files
11 |      * @param non-empty-string $targetPath
12 |      * @param non-empty-string $namespace
13 |      */
14 |     public function run(array $files, string $targetPath, string $namespace): void;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Tcp/Response/ContinueRead.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Response;
 6 | 
 7 | use Spiral\RoadRunner\Tcp\TcpResponse;
 8 | 
 9 | final class ContinueRead implements ResponseInterface
10 | {
11 |     public function getAction(): TcpResponse
12 |     {
13 |         return TcpResponse::Read;
14 |     }
15 | 
16 |     public function getBody(): string
17 |     {
18 |         return '';
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Tcp/Response/CloseConnection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Response;
 6 | 
 7 | use Spiral\RoadRunner\Tcp\TcpResponse;
 8 | 
 9 | final class CloseConnection implements ResponseInterface
10 | {
11 |     public function getAction(): TcpResponse
12 |     {
13 |         return TcpResponse::Close;
14 |     }
15 | 
16 |     public function getBody(): string
17 |     {
18 |         return '';
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Tcp/Service/Exception/NotFoundException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Service\Exception;
 6 | 
 7 | final class NotFoundException extends \RuntimeException
 8 | {
 9 |     /**
10 |      * @param non-empty-string $server
11 |      */
12 |     public function __construct(string $server)
13 |     {
14 |         parent::__construct(\sprintf('Service for server [%s] not found.', $server));
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/GRPC/ProtoRepository/FileRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\ProtoRepository;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class FileRepository implements ProtoFilesRepositoryInterface
11 | {
12 |     public function __construct(
13 |         private readonly array $protoFiles,
14 |     ) {}
15 | 
16 |     public function getProtos(): iterable
17 |     {
18 |         yield from $this->protoFiles;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Tcp/Service/ServiceInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Service;
 6 | 
 7 | use Spiral\RoadRunner\Tcp\Request;
 8 | use Spiral\RoadRunner\Tcp\RequestInterface;
 9 | use Spiral\RoadRunnerBridge\Tcp\Response\ResponseInterface;
10 | 
11 | interface ServiceInterface
12 | {
13 |     /**
14 |      * @param Request $request Will be changed to {@see RequestInterface} in the v4.0.
15 |      */
16 |     public function handle(Request $request): ResponseInterface;
17 | }
18 | 


--------------------------------------------------------------------------------
/src/GRPC/LocatorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC;
 6 | 
 7 | use Spiral\RoadRunner\GRPC\ServiceInterface;
 8 | 
 9 | /**
10 |  * The gRPC service locator.
11 |  */
12 | interface LocatorInterface
13 | {
14 |     /**
15 |      * Return list of available gRPC services in the form of [interface => object].
16 |      *
17 |      * @return array<class-string<ServiceInterface>, \ReflectionClass<ServiceInterface>>
18 |      */
19 |     public function getServices(): array;
20 | }
21 | 


--------------------------------------------------------------------------------
/src/GRPC/UnaryCallInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC;
 6 | 
 7 | use Google\Protobuf\Internal\Message;
 8 | use Spiral\RoadRunner\GRPC\ContextInterface;
 9 | use Spiral\RoadRunner\GRPC\Method;
10 | 
11 | /**
12 |  * The currently processing gRPC request with its context.
13 |  */
14 | interface UnaryCallInterface
15 | {
16 |     public function getContext(): ContextInterface;
17 | 
18 |     public function getMethod(): Method;
19 | 
20 |     public function getMessage(): Message;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Bootloader/LockBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use RoadRunner\Lock\Lock;
 8 | use RoadRunner\Lock\LockInterface;
 9 | use Spiral\Boot\Bootloader\Bootloader;
10 | 
11 | final class LockBootloader extends Bootloader
12 | {
13 |     public function defineDependencies(): array
14 |     {
15 |         return [
16 |             RoadRunnerBootloader::class,
17 |         ];
18 |     }
19 | 
20 |     public function defineSingletons(): array
21 |     {
22 |         return [
23 |             LockInterface::class => Lock::class,
24 |         ];
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/CommandExecutor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Spiral\RoadRunnerBridge\GRPC\Exception\CompileException;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | final class CommandExecutor
13 | {
14 |     public function execute(string $command): string
15 |     {
16 |         \exec(
17 |             $command,
18 |             $output,
19 |             $exitCode,
20 |         );
21 | 
22 |         if ($exitCode !== 0) {
23 |             throw new CompileException(\implode("\n", $output), $exitCode);
24 |         }
25 | 
26 |         return \trim(\implode("\n", $output), "\n ,");
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/GRPC/ProtoRepository/CompositeRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\ProtoRepository;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class CompositeRepository implements ProtoFilesRepositoryInterface
11 | {
12 |     private readonly array $repositories;
13 | 
14 |     public function __construct(ProtoFilesRepositoryInterface ...$repositories)
15 |     {
16 |         $this->repositories = $repositories;
17 |     }
18 | 
19 |     public function getProtos(): iterable
20 |     {
21 |         foreach ($this->repositories as $repository) {
22 |             yield from $repository->getProtos();
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Internal/LogErrorHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Internal;
 6 | 
 7 | use RoadRunner\Centrifugo\Request\RequestInterface;
 8 | use Spiral\Exceptions\ExceptionReporterInterface;
 9 | use Spiral\RoadRunnerBridge\Centrifugo\ErrorHandlerInterface;
10 | 
11 | /**
12 |  * @internal
13 |  */
14 | final class LogErrorHandler implements ErrorHandlerInterface
15 | {
16 |     public function __construct(
17 |         private readonly ExceptionReporterInterface $reporter,
18 |     ) {}
19 | 
20 |     public function handle(RequestInterface $request, \Throwable $e): void
21 |     {
22 |         $this->reporter->report($e);
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Queue/PipelineRegistryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Queue;
 6 | 
 7 | use Spiral\RoadRunner\Jobs\QueueInterface;
 8 | 
 9 | /**
10 |  * @internal
11 |  */
12 | interface PipelineRegistryInterface
13 | {
14 |     /**
15 |      * Declare all pipelines from the config that should be consumed by the application.
16 |      */
17 |     public function declareConsumerPipelines(): void;
18 | 
19 |     /**
20 |      * Get pipeline with given name
21 |      *
22 |      * If pipeline not exists in the RoadRunner, it will be created
23 |      *
24 |      * @param non-empty-string $name
25 |      */
26 |     public function getPipeline(string $name): QueueInterface;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Tcp/Response/RespondMessage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Response;
 6 | 
 7 | use Spiral\RoadRunner\Tcp\TcpResponse;
 8 | 
 9 | final class RespondMessage implements ResponseInterface
10 | {
11 |     public function __construct(
12 |         private readonly string $body,
13 |         private readonly bool $close = false,
14 |     ) {}
15 | 
16 |     public function getAction(): TcpResponse
17 |     {
18 |         if ($this->close) {
19 |             return TcpResponse::RespondClose;
20 |         }
21 | 
22 |         return TcpResponse::Respond;
23 |     }
24 | 
25 |     public function getBody(): string
26 |     {
27 |         return $this->body;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Bootloader/MetricsBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Spiral\Boot\Bootloader\Bootloader;
 8 | use Spiral\Goridge\RPC\RPCInterface;
 9 | use Spiral\RoadRunner\Metrics\Metrics;
10 | use Spiral\RoadRunner\Metrics\MetricsInterface;
11 | 
12 | final class MetricsBootloader extends Bootloader
13 | {
14 |     public function defineDependencies(): array
15 |     {
16 |         return [
17 |             RoadRunnerBootloader::class,
18 |         ];
19 |     }
20 | 
21 |     public function defineSingletons(): array
22 |     {
23 |         return [
24 |             MetricsInterface::class => static fn(RPCInterface $rpc): MetricsInterface => new Metrics($rpc),
25 |         ];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Tcp/Service/RegistryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Service;
 6 | 
 7 | use Spiral\Core\Container\Autowire;
 8 | 
 9 | /**
10 |  * @psalm-type TService = Autowire|ServiceInterface|class-string<ServiceInterface>
11 |  */
12 | interface RegistryInterface
13 | {
14 |     /**
15 |      * @param non-empty-string $server
16 |      */
17 |     public function getService(string $server): ServiceInterface;
18 | 
19 |     /**
20 |      * @param non-empty-string $server
21 |      * @param TService $service
22 |      */
23 |     public function register(string $server, Autowire|ServiceInterface|string $service): void;
24 | 
25 |     /**
26 |      * @param non-empty-string $server
27 |      */
28 |     public function hasService(string $server): bool;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/RoadRunnerMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge;
 6 | 
 7 | use Spiral\Boot\Injector\InjectableEnumInterface;
 8 | use Spiral\Boot\Injector\ProvideFrom;
 9 | use Spiral\RoadRunner\EnvironmentInterface;
10 | 
11 | #[ProvideFrom(method: 'detect')]
12 | enum RoadRunnerMode: string implements InjectableEnumInterface
13 | {
14 |     case Unknown = 'unknown';
15 |     case Http = 'http';
16 |     case Temporal = 'temporal';
17 |     case Jobs = 'jobs';
18 |     case Grpc = 'grpc';
19 |     case Tcp = 'tcp';
20 |     case Centrifuge = 'centrifuge';
21 | 
22 |     public static function detect(EnvironmentInterface $environment): self
23 |     {
24 |         $value = $environment->getMode();
25 | 
26 |         return self::tryFrom($value) ?? self::Unknown;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Config/QueueConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Config;
 6 | 
 7 | use Spiral\Queue\OptionsInterface;
 8 | use Spiral\RoadRunner\Jobs\OptionsInterface as JobsOptionsInterface;
 9 | use Spiral\RoadRunner\Jobs\Queue\CreateInfoInterface;
10 | 
11 | /**
12 |  * @psalm-type TPipeline = array{
13 |  *     connector: CreateInfoInterface,
14 |  *     consume: bool,
15 |  *     options: OptionsInterface|JobsOptionsInterface|null
16 |  * }
17 |  */
18 | final class QueueConfig
19 | {
20 |     public function __construct(
21 |         private readonly array $pipelines,
22 |     ) {}
23 | 
24 |     /**
25 |      * @return array<non-empty-string, TPipeline> $pipelines
26 |      */
27 |     public function getPipelines(): array
28 |     {
29 |         return $this->pipelines;
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Logger/RoadRunnerLogsMode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Logger;
 6 | 
 7 | use Spiral\Boot\EnvironmentInterface;
 8 | use Spiral\Boot\Injector\InjectableEnumInterface;
 9 | use Spiral\Boot\Injector\ProvideFrom;
10 | 
11 | /**
12 |  * @see https://docs.roadrunner.dev/docs/logging-and-observability/logger#modes
13 |  */
14 | #[ProvideFrom(method: 'detect')]
15 | enum RoadRunnerLogsMode: string implements InjectableEnumInterface
16 | {
17 |     case Production = 'production';
18 |     case Development = 'development';
19 | 
20 |     public static function detect(EnvironmentInterface $environment): self
21 |     {
22 |         $value = $environment->get('RR_LOGGER_MODE', '');
23 | 
24 |         return RoadRunnerLogsMode::tryFrom($value) ?? RoadRunnerLogsMode::Production;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Internal/Broadcast.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Internal;
 6 | 
 7 | use RoadRunner\Centrifugo\CentrifugoApiInterface;
 8 | use Spiral\Broadcasting\Driver\AbstractBroadcast;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class Broadcast extends AbstractBroadcast
14 | {
15 |     public function __construct(
16 |         private readonly CentrifugoApiInterface $api,
17 |     ) {}
18 | 
19 |     public function publish(iterable|\Stringable|string $topics, iterable|\Stringable|string $messages): void
20 |     {
21 |         /** @var non-empty-string[] $topics */
22 |         $topics = $this->formatTopics($this->toArray($topics));
23 | 
24 |         /** @var string $message */
25 |         foreach ($this->toArray($messages) as $message) {
26 |             $this->api->broadcast($topics, $message);
27 |         }
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Centrifugo/RegistryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo;
 6 | 
 7 | use RoadRunner\Centrifugo\Request\RequestType;
 8 | use Spiral\Core\Container\Autowire;
 9 | 
10 | /**
11 |  * @psalm-type TService = Autowire|ServiceInterface|class-string<ServiceInterface>
12 |  */
13 | interface RegistryInterface
14 | {
15 |     /**
16 |      * Get service by request type.
17 |      */
18 |     public function getService(RequestType $requestType): ?ServiceInterface;
19 | 
20 |     /**
21 |      * Register a service for a given request type.
22 |      *
23 |      * @param TService $service
24 |      */
25 |     public function register(RequestType $requestType, Autowire|ServiceInterface|string $service): void;
26 | 
27 |     /**
28 |      * Check if service is registered for a given request type.
29 |      */
30 |     public function hasService(RequestType $requestType): bool;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/UnaryCall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Google\Protobuf\Internal\Message;
 8 | use Spiral\RoadRunner\GRPC\ContextInterface;
 9 | use Spiral\RoadRunner\GRPC\Method;
10 | use Spiral\RoadRunnerBridge\GRPC\UnaryCallInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | final class UnaryCall implements UnaryCallInterface
16 | {
17 |     public function __construct(
18 |         private readonly ContextInterface $context,
19 |         private readonly Method $method,
20 |         private readonly Message $message,
21 |     ) {}
22 | 
23 |     public function getContext(): ContextInterface
24 |     {
25 |         return $this->context;
26 |     }
27 | 
28 |     public function getMethod(): Method
29 |     {
30 |         return $this->method;
31 |     }
32 | 
33 |     public function getMessage(): Message
34 |     {
35 |         return $this->message;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Interceptor/RegistryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Interceptor;
 6 | 
 7 | use Spiral\Core\Container\Autowire;
 8 | use Spiral\Core\CoreInterceptorInterface;
 9 | use Spiral\Interceptors\InterceptorInterface;
10 | 
11 | /**
12 |  * @psalm-type TLegacyInterceptor = Autowire|CoreInterceptorInterface|class-string<CoreInterceptorInterface>
13 |  * @psalm-type TInterceptor = Autowire|InterceptorInterface|class-string<InterceptorInterface>
14 |  */
15 | interface RegistryInterface
16 | {
17 |     /**
18 |      * @param non-empty-string $type
19 |      *
20 |      * @return list<TInterceptor|TLegacyInterceptor>
21 |      */
22 |     public function getInterceptors(string $type): array;
23 | 
24 |     /**
25 |      * @param non-empty-string $type
26 |      * @param TInterceptor|TLegacyInterceptor $interceptor
27 |      */
28 |     public function register(string $type, Autowire|CoreInterceptorInterface|InterceptorInterface|string $interceptor): void;
29 | }
30 | 


--------------------------------------------------------------------------------
/src/GRPC/Generator/GeneratorRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Generator;
 6 | 
 7 | /**
 8 |  * @internal
 9 |  */
10 | final class GeneratorRegistry implements GeneratorRegistryInterface
11 | {
12 |     /**
13 |      * @var GeneratorInterface[]
14 |      */
15 |     private array $generators = [];
16 | 
17 |     public function addGenerator(GeneratorInterface $generator): void
18 |     {
19 |         if (!$this->hasGenerator($generator::class)) {
20 |             $this->generators[] = $generator;
21 |         }
22 |     }
23 | 
24 |     /**
25 |      * @return GeneratorInterface[]
26 |      */
27 |     public function getGenerators(): array
28 |     {
29 |         return $this->generators;
30 |     }
31 | 
32 |     public function hasGenerator(string $name): bool
33 |     {
34 |         foreach ($this->generators as $generator) {
35 |             if ($generator::class === $name) {
36 |                 return true;
37 |             }
38 |         }
39 | 
40 |         return false;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Tcp/Internal/Dispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use Spiral\Attribute\DispatcherScope;
 9 | use Spiral\Boot\DispatcherInterface;
10 | use Spiral\RoadRunner\WorkerInterface;
11 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
12 | 
13 | #[DispatcherScope(scope: 'tcp')]
14 | final class Dispatcher implements DispatcherInterface
15 | {
16 |     public function __construct(
17 |         private readonly ContainerInterface $container,
18 |     ) {}
19 | 
20 |     public static function canServe(RoadRunnerMode $mode): bool
21 |     {
22 |         return \PHP_SAPI === 'cli' && $mode === RoadRunnerMode::Tcp;
23 |     }
24 | 
25 |     public function serve(): void
26 |     {
27 |         /** @var Server $server */
28 |         $server = $this->container->get(Server::class);
29 |         /** @var WorkerInterface $worker */
30 |         $worker = $this->container->get(WorkerInterface::class);
31 | 
32 |         $server->serve($worker);
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/Tcp/Interceptor/RegistryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Interceptor;
 6 | 
 7 | use Spiral\Core\Container\Autowire;
 8 | use Spiral\Core\CoreInterceptorInterface;
 9 | use Spiral\Interceptors\InterceptorInterface;
10 | 
11 | /**
12 |  * @psalm-type TLegacyInterceptor = Autowire|CoreInterceptorInterface|class-string<CoreInterceptorInterface>
13 |  * @psalm-type TInterceptor = Autowire|InterceptorInterface|class-string<InterceptorInterface>
14 |  */
15 | interface RegistryInterface
16 | {
17 |     /**
18 |      * @param non-empty-string $server
19 |      *
20 |      * @return array<CoreInterceptorInterface|InterceptorInterface>
21 |      */
22 |     public function getInterceptors(string $server): array;
23 | 
24 |     /**
25 |      * @param non-empty-string $server
26 |      * @param TInterceptor|TLegacyInterceptor $interceptor
27 |      */
28 |     public function register(
29 |         string $server,
30 |         Autowire|CoreInterceptorInterface|InterceptorInterface|string $interceptor,
31 |     ): void;
32 | }
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Spiral Scout
 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 | 


--------------------------------------------------------------------------------
/src/Config/CentrifugoConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Config;
 6 | 
 7 | use Spiral\Core\InjectableConfig;
 8 | use Spiral\RoadRunnerBridge\Centrifugo\RegistryInterface;
 9 | use Spiral\RoadRunnerBridge\Centrifugo\Interceptor;
10 | 
11 | /**
12 |  * @psalm-import-type TService from RegistryInterface
13 |  * @psalm-import-type TInterceptor from Interceptor\RegistryInterface
14 |  * @psalm-import-type TLegacyInterceptor from Interceptor\RegistryInterface
15 |  */
16 | final class CentrifugoConfig extends InjectableConfig
17 | {
18 |     public const CONFIG = 'centrifugo';
19 | 
20 |     protected array $config = [
21 |         'services' => [],
22 |         'interceptors' => [],
23 |     ];
24 | 
25 |     /**
26 |      * @return array<non-empty-string, TService>
27 |      */
28 |     public function getServices(): array
29 |     {
30 |         return $this->config['services'] ?? [];
31 |     }
32 | 
33 |     /**
34 |      * @return array<non-empty-string, list<TInterceptor|TLegacyInterceptor>>
35 |      */
36 |     public function getInterceptors(): array
37 |     {
38 |         return $this->config['interceptors'] ?? [];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Internal/Dispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use RoadRunner\Centrifugo\CentrifugoWorker;
 9 | use RoadRunner\Centrifugo\CentrifugoWorkerInterface;
10 | use Spiral\Attribute\DispatcherScope;
11 | use Spiral\Boot\DispatcherInterface;
12 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
13 | 
14 | /**
15 |  * @internal
16 |  */
17 | #[DispatcherScope(scope: 'centrifugo')]
18 | final class Dispatcher implements DispatcherInterface
19 | {
20 |     public function __construct(
21 |         private readonly ContainerInterface $container,
22 |     ) {}
23 | 
24 |     public static function canServe(RoadRunnerMode $mode): bool
25 |     {
26 |         return \PHP_SAPI === 'cli' && $mode === RoadRunnerMode::Centrifuge;
27 |     }
28 | 
29 |     public function serve(): void
30 |     {
31 |         /** @var Server $server */
32 |         $server = $this->container->get(Server::class);
33 |         /** @var CentrifugoWorker $worker */
34 |         $worker = $this->container->get(CentrifugoWorkerInterface::class);
35 | 
36 |         $server->serve($worker);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Console/Command/GRPC/ListCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Console\Command\GRPC;
 6 | 
 7 | use Spiral\Console\Command;
 8 | use Spiral\RoadRunnerBridge\GRPC\LocatorInterface;
 9 | 
10 | final class ListCommand extends Command
11 | {
12 |     protected const SIGNATURE = 'grpc:services';
13 |     protected const DESCRIPTION = 'List available GRPC services';
14 | 
15 |     public function perform(LocatorInterface $locator): int
16 |     {
17 |         $services = $locator->getServices();
18 | 
19 |         if ($services === []) {
20 |             $this->writeln('<comment>No GRPC services were found.</comment>');
21 | 
22 |             return self::SUCCESS;
23 |         }
24 | 
25 |         $table = $this->table([
26 |             'Service:',
27 |             'Implementation:',
28 |             'File:',
29 |         ]);
30 | 
31 |         foreach ($services as $interface => $reflection) {
32 |             $table->addRow([
33 |                 $interface::NAME,
34 |                 $reflection->getName(),
35 |                 $reflection->getFileName(),
36 |             ]);
37 |         }
38 | 
39 |         $table->render();
40 | 
41 |         return self::SUCCESS;
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/src/Console/Command/Queue/PauseCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Console\Command\Queue;
 6 | 
 7 | use Spiral\Console\Attribute\Argument;
 8 | use Spiral\Console\Attribute\AsCommand;
 9 | use Spiral\Console\Attribute\Question;
10 | use Spiral\Console\Command;
11 | use Spiral\RoadRunner\Jobs\Exception\JobsException;
12 | use Spiral\RoadRunner\Jobs\JobsInterface;
13 | 
14 | #[AsCommand(
15 |     name: 'rr:jobs:pause',
16 |     description: 'Pauses the consumption of jobs for the specified pipeline in the RoadRunner.',
17 | )]
18 | final class PauseCommand extends Command
19 | {
20 |     #[Argument(description: 'Pipeline name')]
21 |     #[Question('Provide pipeline name to resume')]
22 |     public string $pipeline;
23 | 
24 |     /**
25 |      * @throws JobsException
26 |      */
27 |     public function perform(JobsInterface $jobs): int
28 |     {
29 |         \assert($this->pipeline !== '');
30 | 
31 |         if ($this->isVerbose()) {
32 |             $this->info(\sprintf('Pausing pipeline [%s]...', $this->pipeline));
33 |         }
34 | 
35 |         $jobs->pause($this->pipeline);
36 | 
37 |         $this->info(\sprintf('Pipeline [%s] has been paused.', $this->pipeline));
38 | 
39 |         return self::SUCCESS;
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Console/Command/Scaffolder/TcpServiceCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Console\Command\Scaffolder;
 6 | 
 7 | use Spiral\Console\Attribute\Argument;
 8 | use Spiral\Console\Attribute\AsCommand;
 9 | use Spiral\Console\Attribute\Option;
10 | use Spiral\Console\Attribute\Question;
11 | use Spiral\RoadRunnerBridge\Scaffolder\Declaration\TcpServiceDeclaration;
12 | use Spiral\Scaffolder\Command\AbstractCommand;
13 | 
14 | #[AsCommand(name: 'create:tcp-service', description: 'Create TCP service declaration')]
15 | final class TcpServiceCommand extends AbstractCommand
16 | {
17 |     #[Argument(description: 'TCP service name')]
18 |     #[Question(question: 'What would you like to name the TCP service?')]
19 |     private string $name;
20 | 
21 |     #[Option(shortcut: 'c', description: 'Optional comment to add as class header')]
22 |     private ?string $comment = null;
23 | 
24 |     #[Option(description: 'Optional, specify a custom namespace')]
25 |     private ?string $namespace = null;
26 | 
27 |     public function perform(): int
28 |     {
29 |         $declaration = $this->createDeclaration(TcpServiceDeclaration::class);
30 | 
31 |         $this->writeDeclaration($declaration);
32 | 
33 |         return self::SUCCESS;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Scaffolder/Declaration/TcpServiceDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Scaffolder\Declaration;
 6 | 
 7 | use Spiral\RoadRunner\Tcp\Request;
 8 | use Spiral\RoadRunnerBridge\Tcp\Response\RespondMessage;
 9 | use Spiral\RoadRunnerBridge\Tcp\Response\ResponseInterface;
10 | use Spiral\RoadRunnerBridge\Tcp\Service\ServiceInterface;
11 | use Spiral\Scaffolder\Declaration\AbstractDeclaration;
12 | 
13 | class TcpServiceDeclaration extends AbstractDeclaration
14 | {
15 |     public const TYPE = 'tcp-service';
16 | 
17 |     public function declare(): void
18 |     {
19 |         $this->namespace->addUse(ServiceInterface::class);
20 |         $this->namespace->addUse(Request::class);
21 |         $this->namespace->addUse(RespondMessage::class);
22 |         $this->namespace->addUse(ResponseInterface::class);
23 | 
24 |         $this->class->addImplement(ServiceInterface::class);
25 |         $this->class->setFinal();
26 | 
27 |         $this->class->addMethod('handle')
28 |             ->setPublic()
29 |             ->addBody("return new RespondMessage('some message', true);")
30 |             ->setReturnType(ResponseInterface::class)
31 |             ->addParameter('request')
32 |             ->setType(Request::class)
33 |         ;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Config/TcpConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Config;
 6 | 
 7 | use Spiral\Core\Container\Autowire;
 8 | use Spiral\Core\InjectableConfig;
 9 | use Spiral\RoadRunnerBridge\Tcp\Service\ServiceInterface;
10 | use Spiral\RoadRunnerBridge\Tcp\Interceptor;
11 | 
12 | /**
13 |  * @psalm-import-type TInterceptor from Interceptor\RegistryInterface
14 |  * @psalm-import-type TLegacyInterceptor from Interceptor\RegistryInterface
15 |  */
16 | final class TcpConfig extends InjectableConfig
17 | {
18 |     public const CONFIG = 'tcp';
19 | 
20 |     protected array $config = [
21 |         'services' => [],
22 |         'interceptors' => [],
23 |     ];
24 | 
25 |     /**
26 |      * @return array<non-empty-string, Autowire|class-string<ServiceInterface>|ServiceInterface>
27 |      */
28 |     public function getServices(): array
29 |     {
30 |         return $this->config['services'] ?? [];
31 |     }
32 | 
33 |     /**
34 |      * @return array<non-empty-string, list<TInterceptor|TLegacyInterceptor>>
35 |      */
36 |     public function getInterceptors(): array
37 |     {
38 |         return $this->config['interceptors'] ?? [];
39 |     }
40 | 
41 |     public function isDebugMode(): bool
42 |     {
43 |         return (bool) $this->config['debug'];
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Logger/Handler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Logger;
 6 | 
 7 | use Monolog\Handler\AbstractProcessingHandler;
 8 | use Monolog\Level;
 9 | use Monolog\Logger;
10 | use Monolog\LogRecord;
11 | use RoadRunner\Logger\Logger as RoadRunnerLogger;
12 | use Spiral\RoadRunnerBridge\Logger\Internal\RoadRunnerJsonFormatter;
13 | 
14 | final class Handler extends AbstractProcessingHandler
15 | {
16 |     /**
17 |      * @psalm-suppress ArgumentTypeCoercion
18 |      */
19 |     public function __construct(
20 |         private readonly RoadRunnerLogger $logger,
21 |         string $loggerPrefix = '',
22 |         RoadRunnerLogsMode $loggerMode = RoadRunnerLogsMode::Production,
23 |         int|string|Level $level = Level::Debug,
24 |         bool $bubble = true,
25 |     ) {
26 |         parent::__construct(Logger::toMonologLevel($level), $bubble);
27 | 
28 |         $this->setFormatter(new RoadRunnerJsonFormatter($loggerPrefix, $loggerMode));
29 |     }
30 | 
31 |     protected function write(array|LogRecord $record): void
32 |     {
33 |         $log = \is_array($record['formatted'])
34 |             ? \json_encode($record['formatted'], \JSON_THROW_ON_ERROR)
35 |             : $record['formatted'];
36 | 
37 |         $this->logger
38 |             ->log($log . PHP_EOL);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Bootloader/LoggerBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Monolog\Handler\ErrorLogHandler;
 8 | use Monolog\Logger as Monologger;
 9 | use Spiral\Boot\Bootloader\Bootloader;
10 | use Spiral\Boot\EnvironmentInterface;
11 | use RoadRunner\Logger\Logger;
12 | use Spiral\Monolog\Bootloader\MonologBootloader;
13 | use Spiral\RoadRunnerBridge\Logger\Handler;
14 | use Spiral\RoadRunnerBridge\Logger\RoadRunnerLogsMode;
15 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
16 | 
17 | final class LoggerBootloader extends Bootloader
18 | {
19 |     public function defineDependencies(): array
20 |     {
21 |         return [
22 |             RoadRunnerBootloader::class,
23 |         ];
24 |     }
25 | 
26 |     public function init(
27 |         MonologBootloader $bootloader,
28 |         Logger $logger,
29 |         RoadRunnerMode $mode,
30 |         EnvironmentInterface $env,
31 |         RoadRunnerLogsMode $loggerMode,
32 |     ): void {
33 |         $bootloader->addHandler('roadrunner', $mode === RoadRunnerMode::Unknown
34 |             ? new ErrorLogHandler()
35 |             : new Handler(
36 |                 logger: $logger,
37 |                 loggerPrefix: (string) $env->get('RR_LOGGER_PREFIX'),
38 |                 loggerMode: $loggerMode,
39 |                 level: Monologger::toMonologLevel($env->get('MONOLOG_DEFAULT_LEVEL', 'INFO')),
40 |             ));
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Bootloader/CommandBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Spiral\Boot\Bootloader\Bootloader;
 8 | use Spiral\Console\Bootloader\ConsoleBootloader;
 9 | use Spiral\Core\Container;
10 | use Spiral\RoadRunner\Jobs\JobsInterface;
11 | use Spiral\RoadRunnerBridge\Console\Command\GRPC;
12 | use Spiral\RoadRunnerBridge\Console\Command\Queue;
13 | use Spiral\RoadRunnerBridge\GRPC\LocatorInterface;
14 | 
15 | final class CommandBootloader extends Bootloader
16 | {
17 |     public function init(ConsoleBootloader $console, Container $container): void
18 |     {
19 |         $this->configureExtensions($console, $container);
20 |     }
21 | 
22 |     private function configureExtensions(ConsoleBootloader $console, Container $container): void
23 |     {
24 |         if ($container->has(JobsInterface::class)) {
25 |             $this->configureJobs($console);
26 |         }
27 | 
28 |         if ($container->has(LocatorInterface::class)) {
29 |             $this->configureGrpc($console);
30 |         }
31 |     }
32 | 
33 |     private function configureJobs(ConsoleBootloader $console): void
34 |     {
35 |         $console->addCommand(Queue\PauseCommand::class);
36 |         $console->addCommand(Queue\ResumeCommand::class);
37 |         $console->addCommand(Queue\ListCommand::class);
38 |     }
39 | 
40 |     private function configureGrpc(ConsoleBootloader $console): void
41 |     {
42 |         $console->addCommand(GRPC\GenerateCommand::class);
43 |         $console->addCommand(GRPC\ListCommand::class);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Console/Command/Queue/ResumeCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Console\Command\Queue;
 6 | 
 7 | use Spiral\Console\Attribute\Argument;
 8 | use Spiral\Console\Attribute\AsCommand;
 9 | use Spiral\Console\Attribute\Question;
10 | use Spiral\Console\Command;
11 | use Spiral\RoadRunner\Jobs\Exception\JobsException;
12 | use Spiral\RoadRunnerBridge\Queue\PipelineRegistryInterface;
13 | 
14 | #[AsCommand(
15 |     name: 'rr:jobs:consume',
16 |     description: 'Resumes the consumption of jobs for the specified pipeline in the RoadRunner.',
17 | )]
18 | final class ResumeCommand extends Command
19 | {
20 |     #[Argument(description: 'Pipeline name')]
21 |     #[Question('Provide pipeline name to resume')]
22 |     public string $pipeline;
23 | 
24 |     /**
25 |      * @throws JobsException
26 |      */
27 |     public function perform(PipelineRegistryInterface $registry): int
28 |     {
29 |         \assert($this->pipeline !== '');
30 | 
31 |         if ($this->isVerbose()) {
32 |             $this->info(\sprintf('Trying to start consuming pipeline [%s]...', $this->pipeline));
33 |         }
34 | 
35 |         $queue = $registry->getPipeline($this->pipeline);
36 | 
37 |         if ($queue->isPaused()) {
38 |             $this->info(\sprintf('Pipeline [%s] has been started consuming tasks.', $this->pipeline));
39 |             $queue->resume();
40 |         } else {
41 |             $this->warning(\sprintf('Pipeline [%s] is not paused.', $this->pipeline));
42 |             return self::FAILURE;
43 |         }
44 | 
45 |         return self::SUCCESS;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Bootloader/HttpBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Psr\Http\Message\ServerRequestFactoryInterface;
 8 | use Psr\Http\Message\StreamFactoryInterface;
 9 | use Psr\Http\Message\UploadedFileFactoryInterface;
10 | use Spiral\Boot\Bootloader\Bootloader;
11 | use Spiral\Boot\KernelInterface;
12 | use Spiral\Bootloader\Http\HttpBootloader as BaseHttpBootloader;
13 | use Spiral\RoadRunner\Http\PSR7Worker;
14 | use Spiral\RoadRunner\Http\PSR7WorkerInterface;
15 | use Spiral\RoadRunner\WorkerInterface;
16 | use Spiral\RoadRunnerBridge\Http\Internal\Dispatcher;
17 | 
18 | final class HttpBootloader extends Bootloader
19 | {
20 |     public function defineDependencies(): array
21 |     {
22 |         return [
23 |             RoadRunnerBootloader::class,
24 |             BaseHttpBootloader::class,
25 |         ];
26 |     }
27 | 
28 |     public function defineSingletons(): array
29 |     {
30 |         return [
31 |             PSR7Worker::class => PSR7WorkerInterface::class,
32 | 
33 |             PSR7WorkerInterface::class => static fn(
34 |                 WorkerInterface $worker,
35 |                 ServerRequestFactoryInterface $requests,
36 |                 StreamFactoryInterface $streams,
37 |                 UploadedFileFactoryInterface $uploads,
38 |             ): PSR7WorkerInterface => new PSR7Worker($worker, $requests, $streams, $uploads),
39 |         ];
40 |     }
41 | 
42 |     public function boot(KernelInterface $kernel): void
43 |     {
44 |         /** @psalm-suppress InvalidArgument */
45 |         $kernel->addDispatcher(Dispatcher::class);
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/Bootloader/CacheBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Spiral\Boot\Bootloader\Bootloader;
 8 | use Spiral\Cache\Bootloader\CacheBootloader as BaseCacheBootloader;
 9 | use Spiral\Goridge\RPC\RPCInterface;
10 | use Spiral\RoadRunner\KeyValue\Factory;
11 | use Spiral\RoadRunner\KeyValue\FactoryInterface;
12 | use Spiral\RoadRunner\KeyValue\Serializer\DefaultSerializer;
13 | use Spiral\RoadRunner\KeyValue\Serializer\SerializerInterface;
14 | use Spiral\RoadRunner\KeyValue\StorageInterface;
15 | 
16 | final class CacheBootloader extends Bootloader
17 | {
18 |     public function defineDependencies(): array
19 |     {
20 |         return [
21 |             RoadRunnerBootloader::class,
22 |         ];
23 |     }
24 | 
25 |     public function defineSingletons(): array
26 |     {
27 |         return [
28 |             FactoryInterface::class => static fn(
29 |                 RPCInterface $rpc,
30 |                 SerializerInterface $serializer,
31 |             ): FactoryInterface => new Factory($rpc, $serializer),
32 | 
33 |             SerializerInterface::class => DefaultSerializer::class,
34 |         ];
35 |     }
36 | 
37 |     public function defineBindings(): array
38 |     {
39 |         return [
40 |             StorageInterface::class =>
41 |             /** @param non-empty-string $driver */
42 |             static fn(
43 |                 FactoryInterface $factory,
44 |                 string $driver,
45 |             ): StorageInterface => $factory->select($driver),
46 |         ];
47 |     }
48 | 
49 |     public function init(BaseCacheBootloader $cacheBootloader): void
50 |     {
51 |         $cacheBootloader->registerTypeAlias(StorageInterface::class, 'roadrunner');
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Queue/Internal/OptionsFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Queue\Internal;
 6 | 
 7 | use Spiral\Queue\ExtendedOptionsInterface;
 8 | use Spiral\Queue\OptionsInterface;
 9 | use Spiral\RoadRunner\Jobs\KafkaOptions;
10 | use Spiral\RoadRunner\Jobs\Options;
11 | use Spiral\RoadRunner\Jobs\OptionsInterface as JobsOptionsInterface;
12 | use Spiral\RoadRunner\Jobs\Queue\CreateInfoInterface;
13 | use Spiral\RoadRunner\Jobs\Queue\Driver;
14 | 
15 | /**
16 |  * @internal
17 |  */
18 | final class OptionsFactory
19 | {
20 |     public static function create(OptionsInterface|JobsOptionsInterface|null $options = null): ?JobsOptionsInterface
21 |     {
22 |         return match (true) {
23 |             $options instanceof OptionsInterface => self::fromQueueOptions($options),
24 |             default => $options,
25 |         };
26 |     }
27 | 
28 |     public static function fromQueueOptions(OptionsInterface $from): JobsOptionsInterface
29 |     {
30 |         $options = new Options($from->getDelay() ?? JobsOptionsInterface::DEFAULT_DELAY);
31 |         if ($from instanceof ExtendedOptionsInterface) {
32 |             /** @var array<non-empty-string>|non-empty-string $values */
33 |             foreach ($from->getHeaders() as $header => $values) {
34 |                 $options = $options->withHeader($header, $values);
35 |             }
36 |         }
37 | 
38 |         return $options;
39 |     }
40 | 
41 |     /**
42 |      * Creates specified options for the concrete driver, if needed.
43 |      */
44 |     public static function fromCreateInfo(CreateInfoInterface $connector): ?JobsOptionsInterface
45 |     {
46 |         $config = $connector->toArray();
47 | 
48 |         return match ($connector->getDriver()) {
49 |             Driver::Kafka => new KafkaOptions($config['topic'] ?? 'default'),
50 |             default => null,
51 |         };
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/Bootloader/RoadRunnerBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Spiral\Boot\AbstractKernel;
 8 | use Spiral\Boot\Bootloader\Bootloader;
 9 | use Spiral\Boot\EnvironmentInterface as GlobalEnvironmentInterface;
10 | use Spiral\Boot\KernelInterface;
11 | use Spiral\Goridge\Relay;
12 | use Spiral\Goridge\RPC\RPC;
13 | use Spiral\Goridge\RPC\RPCInterface;
14 | use Spiral\RoadRunner\Environment;
15 | use Spiral\RoadRunner\EnvironmentInterface;
16 | use Spiral\RoadRunner\Worker;
17 | use Spiral\RoadRunner\WorkerInterface;
18 | use Spiral\RoadRunnerBridge\FallbackDispatcher;
19 | 
20 | final class RoadRunnerBootloader extends Bootloader
21 | {
22 |     public function defineSingletons(): array
23 |     {
24 |         return [
25 |             EnvironmentInterface::class => static fn(
26 |                 GlobalEnvironmentInterface $env,
27 |             ): EnvironmentInterface => new Environment($env->getAll()),
28 | 
29 |             Environment::class => EnvironmentInterface::class,
30 | 
31 |             RPC::class => RPCInterface::class,
32 |             RPCInterface::class =>
33 |             /** @psalm-suppress ArgumentTypeCoercion */
34 |                 static fn(
35 |                     EnvironmentInterface $env,
36 |                 ): RPCInterface => new RPC(Relay::create($env->getRPCAddress())),
37 | 
38 |             WorkerInterface::class => static fn(
39 |                 EnvironmentInterface $env,
40 |             ): WorkerInterface => Worker::createFromEnvironment($env),
41 | 
42 |             Worker::class => WorkerInterface::class,
43 |         ];
44 |     }
45 | 
46 |     public function init(AbstractKernel $kernel): void
47 |     {
48 |         // Register Fallback Dispatcher after all dispatchers
49 |         // It will be called if no other dispatcher can handle RoadRunner request
50 |         $kernel->bootstrapped(static function (KernelInterface $kernel): void {
51 |             /** @psalm-suppress InvalidArgument */
52 |             $kernel->addDispatcher(FallbackDispatcher::class);
53 |         });
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/ProtocCommandBuilder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Spiral\Files\FilesInterface;
 8 | use Spiral\RoadRunnerBridge\Config\GRPCConfig;
 9 | 
10 | /**
11 |  * @internal
12 |  */
13 | final class ProtocCommandBuilder
14 | {
15 |     public function __construct(
16 |         private readonly FilesInterface $files,
17 |         private readonly GRPCConfig $config,
18 |         private readonly string $protocBinaryPath,
19 |     ) {}
20 | 
21 |     public function build(string $protoDir, string $tmpDir): string
22 |     {
23 |         return \sprintf(
24 |             'protoc %s --php_out=%s --php-grpc_out=%s%s %s 2>&1',
25 |             $this->protocBinaryPath ? '--plugin=' . $this->protocBinaryPath : '',
26 |             \escapeshellarg($tmpDir),
27 |             \escapeshellarg($tmpDir),
28 |             $this->buildDirs($protoDir),
29 |             \implode(' ', \array_map('escapeshellarg', $this->getProtoFiles($protoDir))),
30 |         );
31 |     }
32 | 
33 |     /**
34 |      * Include all proto files from the directory.
35 |      */
36 |     private function getProtoFiles(string $protoDir): array
37 |     {
38 |         $filtered = \array_filter(
39 |             $this->files->getFiles($protoDir),
40 |             static fn(string $file) => \str_ends_with($file, '.proto'),
41 |         );
42 |         return \array_map(static fn(string $path): string => \realpath($path) ?: $path, $filtered);
43 |     }
44 | 
45 |     private function buildDirs(string $protoDir): string
46 |     {
47 |         $dirs = \array_filter([
48 |             // The current directory must be first in the import path list to avoid proto-file name conflicts.
49 |             $protoDir,
50 |             $this->config->getServicesBasePath(),
51 |         ]);
52 | 
53 |         if ($dirs === []) {
54 |             return '';
55 |         }
56 | 
57 |         return ' -I=' . \implode(' -I=', \array_map(
58 |             static fn(string$dir): string => \escapeshellarg(\realpath($dir) ?: $dir),
59 |             $dirs,
60 |         ));
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/FallbackDispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge;
 6 | 
 7 | use Spiral\Boot\DispatcherInterface;
 8 | use Spiral\RoadRunnerBridge\Centrifugo\Internal\Dispatcher as Centrifugo;
 9 | use Spiral\RoadRunnerBridge\Exception\DispatcherNotFoundException;
10 | use Spiral\RoadRunnerBridge\GRPC\Internal\Dispatcher as GRPC;
11 | use Spiral\RoadRunnerBridge\Http\Internal\Dispatcher as Http;
12 | use Spiral\RoadRunnerBridge\Queue\Internal\Dispatcher as Queue;
13 | use Spiral\RoadRunnerBridge\Tcp\Internal\Dispatcher as Tcp;
14 | 
15 | final class FallbackDispatcher implements DispatcherInterface
16 | {
17 |     private const PLUGIN_ERROR = 'To use RoadRunner in `%s` mode, please register dispatcher `%s`.';
18 |     private const TEMPORAL_ERROR = 'To use Temporal with RoadRunner, please install `spiral/temporal-bridge` package.';
19 | 
20 |     public function __construct(
21 |         private readonly RoadRunnerMode $mode,
22 |     ) {}
23 | 
24 |     public static function canServe(RoadRunnerMode $mode): bool
25 |     {
26 |         return \PHP_SAPI === 'cli' && $mode !== RoadRunnerMode::Unknown;
27 |     }
28 | 
29 |     public function serve(): void
30 |     {
31 |         match ($this->mode) {
32 |             RoadRunnerMode::Http => $this->throwException(Http::class),
33 |             RoadRunnerMode::Jobs => $this->throwException(Queue::class),
34 |             RoadRunnerMode::Grpc => $this->throwException(GRPC::class),
35 |             RoadRunnerMode::Tcp => $this->throwException(Tcp::class),
36 |             RoadRunnerMode::Centrifuge => $this->throwException(Centrifugo::class),
37 |             RoadRunnerMode::Temporal => throw new DispatcherNotFoundException(self::TEMPORAL_ERROR),
38 |             RoadRunnerMode::Unknown => null,
39 |         };
40 |     }
41 | 
42 |     /**
43 |      * @param class-string<DispatcherInterface> $class
44 |      *
45 |      * @throws DispatcherNotFoundException
46 |      */
47 |     private function throwException(string $class): never
48 |     {
49 |         throw new DispatcherNotFoundException(\sprintf(self::PLUGIN_ERROR, $this->mode->name, $class));
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/Tcp/Internal/InterceptorRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use Spiral\Core\Container\Autowire;
 9 | use Spiral\Core\CoreInterceptorInterface;
10 | use Spiral\Core\FactoryInterface;
11 | use Spiral\Interceptors\InterceptorInterface;
12 | use Spiral\RoadRunnerBridge\Tcp\Interceptor\RegistryInterface;
13 | 
14 | /**
15 |  * @psalm-import-type TInterceptor from RegistryInterface
16 |  * @psalm-import-type TLegacyInterceptor from RegistryInterface
17 |  */
18 | final class InterceptorRegistry implements RegistryInterface
19 | {
20 |     /** @var array<non-empty-string, list<TInterceptor|TLegacyInterceptor>> */
21 |     private array $interceptors = [];
22 | 
23 |     public function __construct(
24 |         array $interceptors,
25 |         private readonly ContainerInterface $container,
26 |     ) {
27 |         foreach ($interceptors as $server => $values) {
28 |             if (!\is_array($values)) {
29 |                 $values = [$values];
30 |             }
31 | 
32 |             foreach ($values as $interceptor) {
33 |                 $this->register($server, $interceptor);
34 |             }
35 |         }
36 |     }
37 | 
38 |     public function register(
39 |         string $server,
40 |         Autowire|CoreInterceptorInterface|InterceptorInterface|string $interceptor,
41 |     ): void {
42 |         $this->interceptors[$server][] = $interceptor;
43 |     }
44 | 
45 |     public function getInterceptors(string $server): array
46 |     {
47 |         $interceptors = [];
48 |         foreach ($this->interceptors[$server] ?? [] as $value) {
49 |             $interceptor = match (true) {
50 |                 $value instanceof CoreInterceptorInterface, $value instanceof InterceptorInterface => $value,
51 |                 $value instanceof Autowire => $value->resolve($this->container->get(FactoryInterface::class)),
52 |                 default => $this->container->get($value),
53 |             };
54 | 
55 |             \assert($interceptor instanceof CoreInterceptorInterface);
56 | 
57 |             $interceptors[] = $interceptor;
58 |         }
59 | 
60 |         return $interceptors;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/Tcp/Internal/ServiceRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Tcp\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use Spiral\Core\Container\Autowire;
 9 | use Spiral\Core\FactoryInterface;
10 | use Spiral\RoadRunnerBridge\Tcp\Service\Exception\NotFoundException;
11 | use Spiral\RoadRunnerBridge\Tcp\Service\RegistryInterface;
12 | use Spiral\RoadRunnerBridge\Tcp\Service\ServiceInterface;
13 | 
14 | /**
15 |  * @psalm-import-type TService from RegistryInterface
16 |  */
17 | final class ServiceRegistry implements RegistryInterface
18 | {
19 |     /**
20 |      * @var array<non-empty-string, TService>
21 |      */
22 |     private array $services = [];
23 | 
24 |     public function __construct(
25 |         array $services,
26 |         private readonly ContainerInterface $container,
27 |     ) {
28 |         foreach ($services as $server => $service) {
29 |             $this->register($server, $service);
30 |         }
31 |     }
32 | 
33 |     /**
34 |      * @param non-empty-string $server
35 |      * @param TService $service
36 |      */
37 |     public function register(string $server, Autowire|ServiceInterface|string $service): void
38 |     {
39 |         $this->services[$server] = $service;
40 |     }
41 | 
42 |     /**
43 |      * @param non-empty-string $server
44 |      */
45 |     public function getService(string $server): ServiceInterface
46 |     {
47 |         if (!$this->hasService($server)) {
48 |             throw new NotFoundException($server);
49 |         }
50 | 
51 |         $service = match (true) {
52 |             $this->services[$server] instanceof ServiceInterface => $this->services[$server],
53 |             $this->services[$server] instanceof Autowire => $this->services[$server]->resolve(
54 |                 $this->container->get(FactoryInterface::class),
55 |             ),
56 |             default => $this->container->get($this->services[$server]),
57 |         };
58 | 
59 |         \assert($service instanceof ServiceInterface);
60 | 
61 |         return $service;
62 |     }
63 | 
64 |     /**
65 |      * @param non-empty-string $server
66 |      */
67 |     public function hasService(string $server): bool
68 |     {
69 |         return isset($this->services[$server]);
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/Bootloader/QueueBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Spiral\Boot\Bootloader\Bootloader;
 8 | use Spiral\Boot\KernelInterface;
 9 | use Spiral\Core\ConfigsInterface;
10 | use Spiral\Queue\Bootloader\QueueBootloader as BaseQueueBootloader;
11 | use Spiral\RoadRunner\Jobs\Consumer;
12 | use Spiral\RoadRunner\Jobs\ConsumerInterface;
13 | use Spiral\RoadRunner\Jobs\Jobs;
14 | use Spiral\RoadRunner\Jobs\JobsInterface;
15 | use Spiral\RoadRunnerBridge\Config\QueueConfig;
16 | use Spiral\RoadRunnerBridge\Queue\Internal\Dispatcher;
17 | use Spiral\RoadRunnerBridge\Queue\Internal\PayloadDeserializer;
18 | use Spiral\RoadRunnerBridge\Queue\Internal\Queue;
19 | use Spiral\RoadRunnerBridge\Queue\Internal\RPCPipelineRegistry;
20 | use Spiral\RoadRunnerBridge\Queue\PayloadDeserializerInterface;
21 | use Spiral\RoadRunnerBridge\Queue\PipelineRegistryInterface;
22 | use Spiral\Serializer\Bootloader\SerializerBootloader;
23 | 
24 | final class QueueBootloader extends Bootloader
25 | {
26 |     public function defineDependencies(): array
27 |     {
28 |         return [
29 |             RoadRunnerBootloader::class,
30 |             SerializerBootloader::class,
31 |         ];
32 |     }
33 | 
34 |     public function defineSingletons(): array
35 |     {
36 |         return [
37 |             ConsumerInterface::class => Consumer::class,
38 |             JobsInterface::class => Jobs::class,
39 |             PipelineRegistryInterface::class => RPCPipelineRegistry::class,
40 |             PayloadDeserializerInterface::class => PayloadDeserializer::class,
41 | 
42 |             QueueConfig::class => static function (ConfigsInterface $configs): QueueConfig {
43 |                 $config = $configs->getConfig('queue');
44 | 
45 |                 return new QueueConfig(
46 |                     $config['pipelines'] ?? [],
47 |                 );
48 |             },
49 |         ];
50 |     }
51 | 
52 |     public function init(BaseQueueBootloader $bootloader, KernelInterface $kernel): void
53 |     {
54 |         $bootloader->registerDriverAlias(Queue::class, 'roadrunner');
55 |         /** @psalm-suppress InvalidArgument */
56 |         $kernel->addDispatcher(Dispatcher::class);
57 |     }
58 | 
59 |     public function boot(PipelineRegistryInterface $registry): void
60 |     {
61 |         $registry->declareConsumerPipelines();
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Bootloader/ScaffolderBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use RoadRunner\Centrifugo\CentrifugoApiInterface;
 9 | use Spiral\Boot\Bootloader\Bootloader;
10 | use Spiral\Console\Bootloader\ConsoleBootloader;
11 | use Spiral\RoadRunnerBridge\Console\Command\Scaffolder\CentrifugoHandlerCommand;
12 | use Spiral\RoadRunnerBridge\Console\Command\Scaffolder\TcpServiceCommand;
13 | use Spiral\RoadRunnerBridge\Scaffolder\Declaration\CentrifugoHandlerDeclaration;
14 | use Spiral\RoadRunnerBridge\Scaffolder\Declaration\TcpServiceDeclaration;
15 | use Spiral\RoadRunnerBridge\Tcp\Internal\Server;
16 | use Spiral\Scaffolder\Bootloader\ScaffolderBootloader as BaseScaffolderBootloader;
17 | 
18 | final class ScaffolderBootloader extends Bootloader
19 | {
20 |     public function __construct(
21 |         private readonly ContainerInterface $container,
22 |     ) {}
23 | 
24 |     public function defineDependencies(): array
25 |     {
26 |         return [
27 |             ConsoleBootloader::class,
28 |             BaseScaffolderBootloader::class,
29 |         ];
30 |     }
31 | 
32 |     public function init(BaseScaffolderBootloader $scaffolder, ConsoleBootloader $console): void
33 |     {
34 |         $this->configureCommands($console);
35 |         $this->configureDeclarations($scaffolder);
36 |     }
37 | 
38 |     private function configureCommands(ConsoleBootloader $console): void
39 |     {
40 |         if ($this->container->has(CentrifugoApiInterface::class)) {
41 |             $console->addCommand(CentrifugoHandlerCommand::class);
42 |         }
43 | 
44 |         if ($this->container->has(Server::class)) {
45 |             $console->addCommand(TcpServiceCommand::class);
46 |         }
47 |     }
48 | 
49 |     private function configureDeclarations(BaseScaffolderBootloader $scaffolder): void
50 |     {
51 |         $scaffolder->addDeclaration(CentrifugoHandlerDeclaration::TYPE, [
52 |             'namespace' => 'Endpoint\\Centrifugo\\Handler',
53 |             'postfix' => 'Handler',
54 |             'class' => CentrifugoHandlerDeclaration::class,
55 |         ]);
56 | 
57 |         $scaffolder->addDeclaration(TcpServiceDeclaration::TYPE, [
58 |             'namespace' => 'Endpoint\\Tcp\\Service',
59 |             'postfix' => 'Service',
60 |             'class' => TcpServiceDeclaration::class,
61 |         ]);
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Internal/ServiceRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use RoadRunner\Centrifugo\Request\RequestType;
 9 | use Spiral\Core\Container\Autowire;
10 | use Spiral\Core\FactoryInterface;
11 | use Spiral\RoadRunnerBridge\Centrifugo\RegistryInterface;
12 | use Spiral\RoadRunnerBridge\Centrifugo\ServiceInterface;
13 | 
14 | /**
15 |  * @psalm-import-type TService from RegistryInterface
16 |  * @internal
17 |  */
18 | final class ServiceRegistry implements RegistryInterface
19 | {
20 |     /** @var array<non-empty-string, TService> */
21 |     private array $services = [];
22 | 
23 |     /**
24 |      * @param array<non-empty-string, TService> $services
25 |      */
26 |     public function __construct(
27 |         array $services,
28 |         private readonly ContainerInterface $container,
29 |         private readonly FactoryInterface $factory,
30 |     ) {
31 |         foreach ($services as $type => $service) {
32 |             $this->register(RequestType::from($type), $service);
33 |         }
34 |     }
35 | 
36 |     public function register(RequestType $requestType, Autowire|ServiceInterface|string $service): void
37 |     {
38 |         $this->services[$requestType->value] = $service;
39 |     }
40 | 
41 |     public function getService(RequestType $requestType): ?ServiceInterface
42 |     {
43 |         if (!$this->hasService($requestType)) {
44 |             return null;
45 |         }
46 | 
47 |         if (!$this->services[$requestType->value] instanceof ServiceInterface) {
48 |             $this->services[$requestType->value] = $this->createService($this->services[$requestType->value]);
49 |         }
50 | 
51 |         return $this->services[$requestType->value];
52 |     }
53 | 
54 |     public function hasService(RequestType $requestType): bool
55 |     {
56 |         return isset($this->services[$requestType->value]);
57 |     }
58 | 
59 |     /**
60 |      * @psalm-suppress LessSpecificReturnStatement
61 |      */
62 |     private function createService(Autowire|ServiceInterface|string $service): ServiceInterface
63 |     {
64 |         return match (true) {
65 |             $service instanceof ServiceInterface => $service,
66 |             $service instanceof Autowire => $service->resolve($this->factory),
67 |             default => $this->container->get($service),
68 |         };
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/ServiceLocator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Spiral\RoadRunner\GRPC\ServiceInterface;
 8 | use Spiral\RoadRunnerBridge\GRPC\LocatorInterface;
 9 | use Spiral\Tokenizer\Attribute\TargetClass;
10 | use Spiral\Tokenizer\TokenizationListenerInterface;
11 | 
12 | /**
13 |  * @internal
14 |  */
15 | #[TargetClass(ServiceInterface::class, scope: 'grpc-services')]
16 | final class ServiceLocator implements LocatorInterface, TokenizationListenerInterface
17 | {
18 |     /**
19 |      * Service Interface => Service Implementation
20 |      *
21 |      * @var array<class-string<ServiceInterface>, \ReflectionClass<ServiceInterface>>
22 |      */
23 |     private array $registry = [];
24 | 
25 |     public function getServices(): array
26 |     {
27 |         return $this->registry;
28 |     }
29 | 
30 |     /**
31 |      * @param \ReflectionClass<ServiceInterface> $class
32 |      */
33 |     public function listen(\ReflectionClass $class): void
34 |     {
35 |         if (!$class->isInstantiable()) {
36 |             return;
37 |         }
38 | 
39 |         // Find ServiceInterface interfaces
40 |         /** @var array<class-string<ServiceInterface>, \ReflectionClass<ServiceInterface>> $interfaces */
41 |         $interfaces = [];
42 |         foreach ($class->getInterfaces() as $interface) {
43 |             if (!$interface->isSubclassOf(ServiceInterface::class)) {
44 |                 continue;
45 |             }
46 | 
47 |             // Deduplicate parents
48 |             foreach ($interfaces as $className => $reflection) {
49 |                 if ($interface->isSubclassOf($className)) {
50 |                     continue 2;
51 |                 }
52 | 
53 |                 if ($reflection->isSubclassOf($interface->getName())) {
54 |                     unset($interfaces[$className]);
55 |                 }
56 |             }
57 | 
58 |             $interfaces[$interface->getName()] = $interface;
59 |         }
60 | 
61 |         foreach ($interfaces as $className => $reflection) {
62 |             \array_key_exists($className, $this->registry) and throw new \LogicException(
63 |                 \sprintf(
64 |                     'Can not register service %s for interface %s because it is already registered for %s.',
65 |                     $class->getName(),
66 |                     $className,
67 |                     $this->registry[$className]->getName(),
68 |                 ),
69 |             );
70 | 
71 |             $this->registry[$className] = $class;
72 |         }
73 |     }
74 | 
75 |     public function finalize(): void {}
76 | }
77 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/ProtoCompiler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Spiral\Files\FilesInterface;
 8 | use Spiral\RoadRunnerBridge\GRPC\Exception\CompileException;
 9 | 
10 | /**
11 |  * Compiles GRPC protobuf declaration and moves files into proper location.
12 |  *
13 |  * @internal
14 |  */
15 | final class ProtoCompiler
16 | {
17 |     private readonly string $baseNamespace;
18 | 
19 |     public function __construct(
20 |         private readonly string $basePath,
21 |         string $baseNamespace,
22 |         private readonly FilesInterface $files,
23 |         private readonly ProtocCommandBuilder $commandBuilder,
24 |         private readonly CommandExecutor $executor,
25 |     ) {
26 |         $this->baseNamespace = \str_replace('\\', '/', \rtrim($baseNamespace, '\\'));
27 |     }
28 | 
29 |     /**
30 |      * @throws CompileException
31 |      */
32 |     public function compile(string $protoFile): array
33 |     {
34 |         $protoFile = \realpath($protoFile) ?: $protoFile;
35 |         $tmpDir = \realpath($this->tmpDir()) ?: $this->tmpDir();
36 | 
37 |         $output = $this->executor->execute(
38 |             $this->commandBuilder->build(\dirname($protoFile), $tmpDir),
39 |         );
40 | 
41 |         if ($output !== '') {
42 |             $this->files->deleteDirectory($tmpDir);
43 |             throw new CompileException($output);
44 |         }
45 | 
46 |         // copying files (using relative path and namespace)
47 |         $result = [];
48 |         foreach ($this->files->getFiles($tmpDir) as $file) {
49 |             $result[] = $this->copy($tmpDir, $file);
50 |         }
51 | 
52 |         $this->files->deleteDirectory($tmpDir);
53 | 
54 |         return $result;
55 |     }
56 | 
57 |     private function copy(string $tmpDir, string $file): string
58 |     {
59 |         $source = \ltrim($this->files->relativePath($file, $tmpDir), '\\/');
60 |         if (\str_starts_with($source, $this->baseNamespace)) {
61 |             $source = \ltrim(\substr($source, \strlen($this->baseNamespace)), '\\/');
62 |         }
63 | 
64 |         $target = $this->files->normalizePath($this->basePath . '/' . $source);
65 | 
66 |         $this->files->ensureDirectory(\dirname($target));
67 |         $this->files->copy($file, $target);
68 | 
69 |         return $target;
70 |     }
71 | 
72 |     private function tmpDir(): string
73 |     {
74 |         $directory = \sys_get_temp_dir() . '/' . \spl_object_hash($this);
75 |         $this->files->ensureDirectory($directory);
76 | 
77 |         return $this->files->normalizePath($directory, true);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/src/Bootloader/TcpBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use Spiral\Boot\Bootloader\Bootloader;
 9 | use Spiral\Boot\EnvironmentInterface;
10 | use Spiral\Boot\KernelInterface;
11 | use Spiral\Config\ConfiguratorInterface;
12 | use Spiral\Core\Attribute\Proxy;
13 | use Spiral\RoadRunnerBridge\Config\TcpConfig;
14 | use Spiral\RoadRunnerBridge\Tcp\Interceptor;
15 | use Spiral\RoadRunnerBridge\Tcp\Internal\Dispatcher;
16 | use Spiral\RoadRunnerBridge\Tcp\Internal\InterceptorRegistry;
17 | use Spiral\RoadRunnerBridge\Tcp\Internal\Server;
18 | use Spiral\RoadRunnerBridge\Tcp\Service;
19 | 
20 | final class TcpBootloader extends Bootloader
21 | {
22 |     public function __construct(
23 |         private readonly ConfiguratorInterface $config,
24 |     ) {}
25 | 
26 |     public function defineDependencies(): array
27 |     {
28 |         return [
29 |             RoadRunnerBootloader::class,
30 |         ];
31 |     }
32 | 
33 |     public function defineSingletons(): array
34 |     {
35 |         return [
36 |             Service\RegistryInterface::class => [self::class, 'initServiceRegistry'],
37 |             Interceptor\RegistryInterface::class => [self::class, 'initInterceptorRegistry'],
38 |             Server::class => Server::class,
39 |         ];
40 |     }
41 | 
42 |     public function init(EnvironmentInterface $environment): void
43 |     {
44 |         $this->initTcpConfig($environment);
45 |     }
46 | 
47 |     public function boot(KernelInterface $kernel): void
48 |     {
49 |         /** @psalm-suppress InvalidArgument */
50 |         $kernel->addDispatcher(Dispatcher::class);
51 |     }
52 | 
53 |     private function initTcpConfig(EnvironmentInterface $environment): void
54 |     {
55 |         $this->config->setDefaults(
56 |             TcpConfig::CONFIG,
57 |             [
58 |                 'services' => [],
59 |                 'interceptors' => [],
60 |                 'debug' => $environment->get('TCP_DEBUG', false),
61 |             ],
62 |         );
63 |     }
64 | 
65 |     private function initInterceptorRegistry(
66 |         TcpConfig $config,
67 |         ContainerInterface $container,
68 |     ): InterceptorRegistry {
69 |         return new InterceptorRegistry($config->getInterceptors(), $container);
70 |     }
71 | 
72 |     private function initServiceRegistry(
73 |         TcpConfig $config,
74 |         #[Proxy] ContainerInterface $container,
75 |     ): Service\RegistryInterface {
76 |         return new \Spiral\RoadRunnerBridge\Tcp\Internal\ServiceRegistry($config->getServices(), $container);
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/Dispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use Spiral\Attribute\DispatcherScope;
 9 | use Spiral\Boot\DispatcherInterface;
10 | use Spiral\Boot\FinalizerInterface;
11 | use Spiral\Core\Attribute\Proxy;
12 | use Spiral\Exceptions\ExceptionReporterInterface;
13 | use Spiral\RoadRunner\GRPC\Server;
14 | use Spiral\RoadRunner\WorkerInterface;
15 | use Spiral\RoadRunnerBridge\GRPC\Exception\ServiceRegistrationException;
16 | use Spiral\RoadRunnerBridge\GRPC\LocatorInterface;
17 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
18 | 
19 | /**
20 |  * @internal
21 |  */
22 | #[DispatcherScope(scope: 'grpc')]
23 | final class Dispatcher implements DispatcherInterface
24 | {
25 |     public function __construct(
26 |         #[Proxy] private readonly ContainerInterface $container,
27 |         private readonly FinalizerInterface $finalizer,
28 |     ) {}
29 | 
30 |     public static function canServe(RoadRunnerMode $mode): bool
31 |     {
32 |         return \PHP_SAPI === 'cli' && $mode === RoadRunnerMode::Grpc;
33 |     }
34 | 
35 |     public function serve(): void
36 |     {
37 |         $container = $this->container->get(ContainerInterface::class);
38 | 
39 |         /** @var Server $server */
40 |         $server = $container->get(Server::class);
41 |         /** @var WorkerInterface $worker */
42 |         $worker = $container->get(WorkerInterface::class);
43 |         /** @var LocatorInterface $locator */
44 |         $locator = $container->get(LocatorInterface::class);
45 | 
46 |         foreach ($locator->getServices() as $interface => $service) {
47 |             try {
48 |                 $server->registerService($interface, $container->get($service->getName()));
49 |             } catch (\Throwable $e) {
50 |                 $this->handleException(new ServiceRegistrationException(
51 |                     "Cannot register service `{$service->getName()}`: {$e->getMessage()}",
52 |                     previous: $e,
53 |                 ));
54 |             }
55 |         }
56 | 
57 |         $server->serve(
58 |             $worker,
59 |             function (?\Throwable $e = null): void {
60 |                 if ($e !== null) {
61 |                     $this->handleException($e);
62 |                 }
63 | 
64 |                 $this->finalizer->finalize(false);
65 |             },
66 |         );
67 |     }
68 | 
69 |     private function handleException(\Throwable $e): void
70 |     {
71 |         try {
72 |             $this->container->get(ExceptionReporterInterface::class)->report($e);
73 |         } catch (\Throwable) {
74 |             // no need to notify when unable to register an exception
75 |         }
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Scaffolder/Declaration/CentrifugoHandlerDeclaration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Scaffolder\Declaration;
 6 | 
 7 | use RoadRunner\Centrifugo\CentrifugoApiInterface;
 8 | use RoadRunner\Centrifugo\Request\RequestInterface;
 9 | use Spiral\RoadRunnerBridge\Centrifugo\ServiceInterface;
10 | use Spiral\Scaffolder\Config\ScaffolderConfig;
11 | use Spiral\Scaffolder\Declaration\AbstractDeclaration;
12 | use Spiral\Scaffolder\Declaration\HasInstructions;
13 | 
14 | class CentrifugoHandlerDeclaration extends AbstractDeclaration implements HasInstructions
15 | {
16 |     public const TYPE = 'centrifugo-handler';
17 | 
18 |     public function __construct(
19 |         ScaffolderConfig $config,
20 |         string $name,
21 |         ?string $comment = null,
22 |         ?string $namespace = null,
23 |         private bool $withApi = false,
24 |     ) {
25 |         parent::__construct($config, $name, $comment, $namespace);
26 |     }
27 | 
28 |     public function declare(): void
29 |     {
30 |         $this->class->setFinal();
31 | 
32 |         if ($this->withApi) {
33 |             $this->namespace->addUse(CentrifugoApiInterface::class);
34 | 
35 |             $this->class->addMethod('__construct')
36 |                 ->setPublic()
37 |                 ->addPromotedParameter('api')
38 |                 ->setPrivate()
39 |                 ->setReadOnly()
40 |                 ->setType(CentrifugoApiInterface::class);
41 |         }
42 |     }
43 | 
44 |     public function setType(array $data): void
45 |     {
46 |         $this->namespace->addUse($data['request']);
47 |         $this->namespace->addUse(RequestInterface::class);
48 |         $this->namespace->addUse(ServiceInterface::class);
49 | 
50 |         foreach ($data['use'] as $use) {
51 |             $this->namespace->addUse($use);
52 |         }
53 | 
54 |         $className = (new \ReflectionClass($data['request']))->getShortName();
55 | 
56 |         $this->class
57 |             ->addImplement(ServiceInterface::class)
58 |             ->addMethod('handle')
59 |             ->setPublic()
60 |             ->setBody($data['body'] ?? '// Put your code here')
61 |             ->setReturnType('void')
62 |             ->setComment("\n@param {$className} \$request")
63 |             ->addParameter('request')
64 |             ->setType(RequestInterface::class);
65 |     }
66 | 
67 |     public function getInstructions(): array
68 |     {
69 |         return [
70 |             'Register your handler in `app/config/centrifugo.php` file. Read more in the documentation: https://spiral.dev/docs/websockets-services#service-registration',
71 |             'Read more about Centrifugo handlers: https://spiral.dev/docs/websockets-services',
72 |         ];
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/GRPC/Internal/Invoker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\GRPC\Internal;
 6 | 
 7 | use Google\Protobuf\Internal\Message;
 8 | use Spiral\Core\Attribute\Proxy;
 9 | use Spiral\Core\Scope;
10 | use Spiral\Core\ScopeInterface;
11 | use Spiral\Interceptors\Context\CallContext;
12 | use Spiral\Interceptors\Context\Target;
13 | use Spiral\Interceptors\HandlerInterface;
14 | use Spiral\RoadRunner\GRPC\ContextInterface;
15 | use Spiral\RoadRunner\GRPC\Exception\InvokeException;
16 | use Spiral\RoadRunner\GRPC\InvokerInterface;
17 | use Spiral\RoadRunner\GRPC\Method;
18 | use Spiral\RoadRunner\GRPC\ServiceInterface;
19 | use Spiral\RoadRunner\GRPC\StatusCode;
20 | use Spiral\RoadRunnerBridge\GRPC\UnaryCallInterface;
21 | 
22 | /**
23 |  * @internal
24 |  */
25 | final class Invoker implements InvokerInterface
26 | {
27 |     public function __construct(
28 |         private readonly HandlerInterface $handler,
29 |         #[Proxy] private readonly ScopeInterface $scope,
30 |     ) {}
31 | 
32 |     public function invoke(ServiceInterface $service, Method $method, ContextInterface $ctx, ?string $input): string
33 |     {
34 |         $message = $this->makeInput($method, $input);
35 |         $handler = $this->handler;
36 | 
37 |         /** @psalm-suppress InvalidArgument */
38 |         return $this->scope->runScope(
39 |             new Scope('grpc-request', [UnaryCallInterface::class => new UnaryCall($ctx, $method, $message)]),
40 |             static fn(): string => self::resultToString($handler->handle(
41 |                 new CallContext(Target::fromPair($service, $method->name), [
42 |                     $ctx,
43 |                     $message,
44 |                 ]),
45 |             )),
46 |         );
47 |     }
48 | 
49 |     /**
50 |      * Converts the result from the GRPC service method to the string.
51 |      *
52 |      * @throws InvokeException
53 |      */
54 |     private static function resultToString(Message $result): string
55 |     {
56 |         try {
57 |             return $result->serializeToString();
58 |         } catch (\Throwable $e) {
59 |             throw InvokeException::create($e->getMessage(), StatusCode::INTERNAL, $e);
60 |         }
61 |     }
62 | 
63 |     /**
64 |      * Converts the input from the GRPC service method to the Message object.
65 |      *
66 |      * @throws InvokeException
67 |      */
68 |     private function makeInput(Method $method, ?string $body): Message
69 |     {
70 |         try {
71 |             $class = $method->inputType;
72 | 
73 |             /** @psalm-suppress UnsafeInstantiation */
74 |             $in = new $class();
75 | 
76 |             if ($body !== null) {
77 |                 $in->mergeFromString($body);
78 |             }
79 | 
80 |             return $in;
81 |         } catch (\Throwable $e) {
82 |             throw InvokeException::create($e->getMessage(), StatusCode::INTERNAL, $e);
83 |         }
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Internal/InterceptorRegistry.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use RoadRunner\Centrifugo\Request\RequestType;
 9 | use Spiral\Core\Container\Autowire;
10 | use Spiral\Core\CoreInterceptorInterface;
11 | use Spiral\Core\FactoryInterface;
12 | use Spiral\Interceptors\InterceptorInterface;
13 | use Spiral\RoadRunnerBridge\Centrifugo\Exception\ConfigurationException;
14 | use Spiral\RoadRunnerBridge\Centrifugo\Interceptor\RegistryInterface;
15 | 
16 | /**
17 |  * @psalm-import-type TInterceptor from RegistryInterface
18 |  * @psalm-import-type TLegacyInterceptor from RegistryInterface
19 |  * @internal
20 |  */
21 | final class InterceptorRegistry implements RegistryInterface
22 | {
23 |     private const INTERCEPTORS_FOR_ALL_SERVICES = '*';
24 | 
25 |     /** @var array<non-empty-string, array<TInterceptor|TLegacyInterceptor>> */
26 |     private array $interceptors = [];
27 | 
28 |     /**
29 |      * @param array<non-empty-string, TInterceptor|TInterceptor[]|TLegacyInterceptor|TLegacyInterceptor[]> $interceptors
30 |      */
31 |     public function __construct(
32 |         array $interceptors,
33 |         private readonly ContainerInterface $container,
34 |         private readonly FactoryInterface $factory,
35 |     ) {
36 |         foreach ($interceptors as $type => $values) {
37 |             if (!\is_array($values)) {
38 |                 $values = [$values];
39 |             }
40 | 
41 |             foreach ($values as $interceptor) {
42 |                 $this->register($type, $interceptor);
43 |             }
44 |         }
45 |     }
46 | 
47 |     public function register(
48 |         string $type,
49 |         Autowire|CoreInterceptorInterface|InterceptorInterface|string $interceptor,
50 |     ): void {
51 |         if ($type !== '*' && RequestType::tryFrom($type) === null) {
52 |             throw new ConfigurationException(\sprintf(
53 |                 'The $type value must be one of the `%s`, `%s` values.',
54 |                 self::INTERCEPTORS_FOR_ALL_SERVICES,
55 |                 \implode('`, `', \array_map(static fn(\UnitEnum $case) => $case->value, RequestType::cases())),
56 |             ));
57 |         }
58 | 
59 |         /** @var CoreInterceptorInterface $object */
60 |         $object = match (true) {
61 |             $interceptor instanceof CoreInterceptorInterface,
62 |             $interceptor instanceof InterceptorInterface => $interceptor,
63 |             $interceptor instanceof Autowire => $interceptor->resolve($this->factory),
64 |             default => $this->container->get($interceptor),
65 |         };
66 | 
67 |         $this->interceptors[$type][] = $object;
68 |     }
69 | 
70 |     public function getInterceptors(string $type): array
71 |     {
72 |         return \array_merge(
73 |             $this->interceptors[self::INTERCEPTORS_FOR_ALL_SERVICES] ?? [],
74 |             $this->interceptors[$type] ?? [],
75 |         );
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/src/Config/GRPCConfig.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Config;
 6 | 
 7 | use Spiral\Core\Container\Autowire;
 8 | use Spiral\Core\CoreInterceptorInterface;
 9 | use Spiral\Core\InjectableConfig;
10 | use Spiral\Grpc\Client\Config\GrpcClientConfig;
11 | use Spiral\Interceptors\InterceptorInterface;
12 | use Spiral\RoadRunner\GRPC\ServiceInterface;
13 | use Spiral\RoadRunnerBridge\GRPC\Generator\GeneratorInterface;
14 | 
15 | final class GRPCConfig extends InjectableConfig
16 | {
17 |     public const CONFIG = 'grpc';
18 | 
19 |     protected array $config = [
20 |         'binaryPath' => null,
21 |         'generatedPath' => null,
22 |         'namespace' => null,
23 |         'servicesBasePath' => null,
24 |         'services' => [],
25 |         'interceptors' => [],
26 |         'generators' => [],
27 |         'client' => [],
28 |     ];
29 | 
30 |     public function getClientConfig(): GrpcClientConfig
31 |     {
32 |         // Map Client options
33 |         return match (true) {
34 |             !isset($this->config['client']) => new GrpcClientConfig(),
35 |             \is_array($this->config['client']) => new GrpcClientConfig(
36 |                 interceptors: $this->config['client']['interceptors'] ?? [],
37 |                 services: $this->config['client']['services'] ?? [],
38 |             ),
39 |             default => $this->config['client'],
40 |         };
41 |     }
42 | 
43 |     public function getBinaryPath(): ?string
44 |     {
45 |         return $this->config['binaryPath'] ?? null;
46 |     }
47 | 
48 |     /**
49 |      * Path, where generated DTO files should be stored.
50 |      *
51 |      * @return non-empty-string|null
52 |      */
53 |     public function getGeneratedPath(): ?string
54 |     {
55 |         return $this->config['generatedPath'] ?? null;
56 |     }
57 | 
58 |     /**
59 |      * Base namespace for generated proto files.
60 |      */
61 |     public function getNamespace(): ?string
62 |     {
63 |         return $this->config['namespace'] ?? null;
64 |     }
65 | 
66 |     /**
67 |      * Root path for all proto files in which imports will be searched.
68 |      */
69 |     public function getServicesBasePath(): ?string
70 |     {
71 |         return $this->config['servicesBasePath'] ?? null;
72 |     }
73 | 
74 |     /**
75 |      * @return array<class-string<ServiceInterface>>
76 |      */
77 |     public function getServices(): array
78 |     {
79 |         return (array) ($this->config['services'] ?? []);
80 |     }
81 | 
82 |     /**
83 |      * @return array<Autowire|class-string<InterceptorInterface>|class-string<CoreInterceptorInterface>>
84 |      */
85 |     public function getInterceptors(): array
86 |     {
87 |         return (array) ($this->config['interceptors'] ?? []);
88 |     }
89 | 
90 |     /**
91 |      * @return array<Autowire|class-string<GeneratorInterface>|GeneratorInterface>
92 |      */
93 |     public function getGenerators(): array
94 |     {
95 |         return (array) ($this->config['generators'] ?? []);
96 |     }
97 | }
98 | 


--------------------------------------------------------------------------------
/src/Bootloader/CentrifugoBootloader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Bootloader;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use RoadRunner\Centrifugo\CentrifugoApiInterface;
 9 | use RoadRunner\Centrifugo\CentrifugoWorker;
10 | use RoadRunner\Centrifugo\CentrifugoWorkerInterface;
11 | use RoadRunner\Centrifugo\RPCCentrifugoApi;
12 | use Spiral\Boot\AbstractKernel;
13 | use Spiral\Boot\Bootloader\Bootloader;
14 | use Spiral\Broadcasting\Bootloader\BroadcastingBootloader;
15 | use Spiral\Config\ConfiguratorInterface;
16 | use Spiral\Core\Attribute\Proxy;
17 | use Spiral\Core\FactoryInterface;
18 | use Spiral\RoadRunnerBridge\Centrifugo\ErrorHandlerInterface;
19 | use Spiral\RoadRunnerBridge\Centrifugo\Interceptor;
20 | use Spiral\RoadRunnerBridge\Centrifugo\Internal\Broadcast;
21 | use Spiral\RoadRunnerBridge\Centrifugo\Internal\Dispatcher;
22 | use Spiral\RoadRunnerBridge\Centrifugo\Internal\LogErrorHandler;
23 | use Spiral\RoadRunnerBridge\Centrifugo\Internal\ServiceRegistry;
24 | use Spiral\RoadRunnerBridge\Centrifugo\RegistryInterface;
25 | use Spiral\RoadRunnerBridge\Config\CentrifugoConfig;
26 | 
27 | final class CentrifugoBootloader extends Bootloader
28 | {
29 |     public function __construct(
30 |         private readonly ConfiguratorInterface $config,
31 |     ) {}
32 | 
33 |     public function defineSingletons(): array
34 |     {
35 |         return [
36 |             RegistryInterface::class => [self::class, 'initServiceRegistry'],
37 |             Interceptor\RegistryInterface::class => [self::class, 'initInterceptorRegistry'],
38 |             CentrifugoWorkerInterface::class => CentrifugoWorker::class,
39 |             ErrorHandlerInterface::class => LogErrorHandler::class,
40 |             CentrifugoApiInterface::class => RPCCentrifugoApi::class,
41 |         ];
42 |     }
43 | 
44 |     public function init(BroadcastingBootloader $broadcasting): void
45 |     {
46 |         $this->initConfig();
47 |         $broadcasting->registerDriverAlias(Broadcast::class, 'centrifugo');
48 |     }
49 | 
50 |     public function boot(AbstractKernel $kernel): void
51 |     {
52 |         $kernel->addDispatcher(Dispatcher::class);
53 |     }
54 | 
55 |     private function initConfig(): void
56 |     {
57 |         $this->config->setDefaults(
58 |             CentrifugoConfig::CONFIG,
59 |             [
60 |                 'services' => [],
61 |                 'interceptors' => [],
62 |             ],
63 |         );
64 |     }
65 | 
66 |     private function initInterceptorRegistry(
67 |         CentrifugoConfig $config,
68 |         ContainerInterface $container,
69 |         FactoryInterface $factory,
70 |     ): Interceptor\RegistryInterface {
71 |         return new \Spiral\RoadRunnerBridge\Centrifugo\Internal\InterceptorRegistry($config->getInterceptors(), $container, $factory);
72 |     }
73 | 
74 |     private function initServiceRegistry(
75 |         CentrifugoConfig $config,
76 |         #[Proxy] ContainerInterface $container,
77 |         #[Proxy] FactoryInterface $factory,
78 |     ): RegistryInterface {
79 |         return new ServiceRegistry($config->getServices(), $container, $factory);
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/Http/Internal/Dispatcher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Http\Internal;
 6 | 
 7 | use Psr\Http\Message\ResponseFactoryInterface;
 8 | use Psr\Http\Message\ResponseInterface;
 9 | use Spiral\Attribute\DispatcherScope;
10 | use Spiral\Boot\DispatcherInterface;
11 | use Spiral\Boot\Environment\AppEnvironment;
12 | use Spiral\Boot\FinalizerInterface;
13 | use Spiral\Exceptions\ExceptionHandlerInterface;
14 | use Spiral\Exceptions\Verbosity;
15 | use Spiral\Http\Http;
16 | use Spiral\RoadRunner\Http\PSR7WorkerInterface;
17 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
18 | 
19 | /**
20 |  * @internal
21 |  */
22 | #[DispatcherScope(scope: 'http')]
23 | final class Dispatcher implements DispatcherInterface
24 | {
25 |     public function __construct(
26 |         private readonly PSR7WorkerInterface $worker,
27 |         private readonly Http $http,
28 |         private readonly ExceptionHandlerInterface $errorHandler,
29 |         private readonly ResponseFactoryInterface $responseFactory,
30 |         private readonly FinalizerInterface $finalizer,
31 |         private readonly AppEnvironment $environment,
32 |     ) {}
33 | 
34 |     public static function canServe(RoadRunnerMode $mode): bool
35 |     {
36 |         return \PHP_SAPI === 'cli' && $mode === RoadRunnerMode::Http;
37 |     }
38 | 
39 |     public function serve(): void
40 |     {
41 |         do {
42 |             try {
43 |                 // Wrapped in do/while and try/catch to prevent Worker restart if request parsing is failed
44 |                 //
45 |                 do {
46 |                     $request = $this->worker->waitRequest();
47 |                     if ($request === null) {
48 |                         // Worker got Close signal, stop serving
49 |                         return;
50 |                     }
51 | 
52 |                     try {
53 |                         $response = $this->http->handle($request);
54 |                         $this->worker->respond($response);
55 |                     } catch (\Throwable $failure) {
56 |                         $this->worker->respond($this->errorToResponse($failure));
57 |                         unset($failure);
58 |                     } finally {
59 |                         $this->finalizer->finalize(false);
60 |                     }
61 |                 } while (true);
62 |             } catch (\Throwable $e) {
63 |                 // Don't continue if the respond() call was failed
64 |                 if (isset($failure)) {
65 |                     break;
66 |                 }
67 | 
68 |                 $this->worker->respond($this->errorToResponse($e));
69 |             }
70 |         } while (true);
71 |     }
72 | 
73 |     protected function errorToResponse(\Throwable $e): ResponseInterface
74 |     {
75 |         $this->errorHandler->report($e);
76 | 
77 |         // Reporting system (non handled) exception directly to the client
78 |         $response = $this->responseFactory->createResponse(500);
79 | 
80 |         // Add details to the response body in non-production environment
81 |         $this->environment->isProduction() or $response
82 |             ->getBody()
83 |             ->write($this->errorHandler->render($e, Verbosity::VERBOSE));
84 | 
85 |         return $response;
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/Centrifugo/Internal/Server.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Centrifugo\Internal;
 6 | 
 7 | use Psr\Container\ContainerInterface;
 8 | use RoadRunner\Centrifugo\CentrifugoWorkerInterface;
 9 | use RoadRunner\Centrifugo\Request\RequestInterface;
10 | use RoadRunner\Centrifugo\Request\RequestType;
11 | use Spiral\Boot\FinalizerInterface;
12 | use Spiral\Core\Attribute\Proxy;
13 | use Spiral\Core\CompatiblePipelineBuilder;
14 | use Spiral\Core\Scope;
15 | use Spiral\Core\ScopeInterface;
16 | use Spiral\Interceptors\Context\CallContext;
17 | use Spiral\Interceptors\Context\Target;
18 | use Spiral\Interceptors\Handler\AutowireHandler;
19 | use Spiral\Interceptors\HandlerInterface;
20 | use Spiral\Interceptors\PipelineBuilderInterface;
21 | use Spiral\RoadRunnerBridge\Centrifugo\ErrorHandlerInterface;
22 | use Spiral\RoadRunnerBridge\Centrifugo\Interceptor\RegistryInterface as InterceptorRegistry;
23 | use Spiral\RoadRunnerBridge\Centrifugo\RegistryInterface;
24 | 
25 | /**
26 |  * @internal
27 |  */
28 | final class Server
29 | {
30 |     private readonly PipelineBuilderInterface $pipelineBuilder;
31 |     private readonly HandlerInterface $handler;
32 | 
33 |     /** @var array<non-empty-string, HandlerInterface> */
34 |     private array $pipelines = [];
35 | 
36 |     public function __construct(
37 |         private readonly InterceptorRegistry $interceptors,
38 |         private readonly RegistryInterface $services,
39 |         #[Proxy] private readonly ContainerInterface $container,
40 |         private readonly FinalizerInterface $finalizer,
41 |         private readonly ErrorHandlerInterface $errorHandler,
42 |         ?PipelineBuilderInterface $pipelineBuilder = null,
43 |     ) {
44 |         $this->pipelineBuilder = $pipelineBuilder ?? $container->get(CompatiblePipelineBuilder::class);
45 |         $this->handler = new AutowireHandler($container);
46 |     }
47 | 
48 |     /**
49 |      * @throws \JsonException
50 |      */
51 |     public function serve(CentrifugoWorkerInterface $worker): void
52 |     {
53 |         $scope = $this->container->get(ScopeInterface::class);
54 | 
55 |         while ($request = $worker->waitRequest()) {
56 |             try {
57 |                 $type = RequestType::createFrom($request);
58 |                 $pipeline = $this->getHandler($type);
59 |                 $services = $this->services;
60 | 
61 |                 $scope->runScope(
62 |                     new Scope('centrifugo-request', [RequestInterface::class => $request]),
63 |                     static fn(): mixed => $pipeline->handle(
64 |                         new CallContext(
65 |                             /** @see ServiceInterface::handle() */
66 |                             Target::fromPair($services->getService($type), 'handle'),
67 |                             [$request],
68 |                             [RequestType::class => $type],
69 |                         ),
70 |                     ),
71 |                 );
72 |             } catch (\Throwable $e) {
73 |                 $this->errorHandler->handle($request, $e);
74 |                 unset($e);
75 |             }
76 | 
77 |             $this->finalizer->finalize();
78 |         }
79 |     }
80 | 
81 |     public function getHandler(RequestType $type): HandlerInterface
82 |     {
83 |         /** @psalm-suppress PossiblyInvalidArgument */
84 |         return $this->pipelines[$type->value] ??= $this->pipelineBuilder
85 |             ->withInterceptors(...$this->interceptors->getInterceptors($type->value))
86 |             ->build($this->handler);
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "name": "spiral/roadrunner-bridge",
  3 |     "type": "library",
  4 |     "description": "RoadRunner integration package",
  5 |     "license": "MIT",
  6 |     "homepage": "https://spiral.dev",
  7 |     "support": {
  8 |         "issues": "https://github.com/spiral/roadrunner-bridge/issues",
  9 |         "source": "https://github.com/spiral/roadrunner-bridge",
 10 |         "docs": "https://spiral.dev/docs",
 11 |         "chat": "https://discord.gg/V6EK4he"
 12 |     },
 13 |     "authors": [
 14 |         {
 15 |             "name": "Anton Titov (wolfy-j)",
 16 |             "email": "wolfy-j@spiralscout.com"
 17 |         },
 18 |         {
 19 |             "name": "Pavel Butchnev (butschster)",
 20 |             "email": "pavel.buchnev@spiralscout.com"
 21 |         },
 22 |         {
 23 |             "name": "Aleksei Gagarin (roxblnfk)",
 24 |             "email": "alexey.gagarin@spiralscout.com"
 25 |         },
 26 |         {
 27 |             "name": "Maksim Smakouz (msmakouz)",
 28 |             "email": "maksim.smakouz@spiralscout.com"
 29 |         }
 30 |     ],
 31 |     "funding": [
 32 |         {
 33 |             "type": "github",
 34 |             "url": "https://github.com/sponsors/spiral"
 35 |         }
 36 |     ],
 37 |     "require": {
 38 |         "php": ">=8.1",
 39 |         "grpc/grpc": "^1.57",
 40 |         "psr/http-factory": "^1.1",
 41 |         "psr/simple-cache": "^3.0",
 42 |         "roadrunner-php/app-logger": "^1.0",
 43 |         "roadrunner-php/centrifugo": "^2.0",
 44 |         "roadrunner-php/lock": "^1.0",
 45 |         "spiral/boot": "^3.14",
 46 |         "spiral/grpc-client": "^1.0",
 47 |         "spiral/hmvc": "^3.14",
 48 |         "spiral/roadrunner-grpc": "^3.3",
 49 |         "spiral/roadrunner-http": "^3.5",
 50 |         "spiral/roadrunner-jobs": "^4.6.3",
 51 |         "spiral/roadrunner-kv": "^4.0",
 52 |         "spiral/roadrunner-metrics": "^3.0",
 53 |         "spiral/roadrunner-tcp": "^3.1 || ^4.0",
 54 |         "spiral/scaffolder": "^3.13",
 55 |         "spiral/serializer": "^3.13"
 56 |     },
 57 |     "require-dev": {
 58 |         "buggregator/trap": "^1.10",
 59 |         "internal/dload": "^1.0.0",
 60 |         "phpunit/phpunit": "^10.5",
 61 |         "spiral/code-style": "^2.2",
 62 |         "spiral/framework": "^3.15.6",
 63 |         "spiral/nyholm-bridge": "^1.3",
 64 |         "spiral/roadrunner-cli": "^2.6",
 65 |         "spiral/testing": "^2.9.0",
 66 |         "vimeo/psalm": "^6.0"
 67 |     },
 68 |     "suggest": {
 69 |         "ext-protobuf": "For better performance, install the protobuf C extension."
 70 |     },
 71 |     "autoload": {
 72 |         "psr-4": {
 73 |             "Spiral\\RoadRunnerBridge\\": "src"
 74 |         }
 75 |     },
 76 |     "autoload-dev": {
 77 |         "psr-4": {
 78 |             "GPBMetadata\\": "tests/generated/GPBMetadata",
 79 |             "Service\\": "tests/generated/Service",
 80 |             "Spiral\\App\\": "tests/app",
 81 |             "Spiral\\Tests\\": "tests/src"
 82 |         }
 83 |     },
 84 |     "scripts": {
 85 |         "post-update-cmd": [
 86 |             "dload get --no-interaction"
 87 |         ],
 88 |         "cs:diff": "php-cs-fixer fix --dry-run -v --diff",
 89 |         "cs:fix": "php-cs-fixer fix -v",
 90 |         "test": "phpunit",
 91 |         "psalm": "psalm",
 92 |         "psalm:baseline": "psalm --set-baseline=psalm-baseline.xml"
 93 |     },
 94 |     "config": {
 95 |         "sort-packages": true,
 96 |         "allow-plugins": {
 97 |             "spiral/composer-publish-plugin": true
 98 |         }
 99 |     },
100 |     "minimum-stability": "dev",
101 |     "prefer-stable": true
102 | }
103 | 


--------------------------------------------------------------------------------
/src/Queue/Internal/Queue.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Queue\Internal;
  6 | 
  7 | use Spiral\Queue\Exception\InvalidArgumentException;
  8 | use Spiral\Queue\OptionsInterface;
  9 | use Spiral\Queue\QueueInterface;
 10 | use Spiral\Queue\QueueTrait;
 11 | use Spiral\Queue\SerializerRegistryInterface;
 12 | use Spiral\RoadRunner\Jobs\Exception\JobsException;
 13 | use Spiral\RoadRunner\Jobs\OptionsInterface as JobsOptionsInterface;
 14 | use Spiral\RoadRunner\Jobs\QueueInterface as RRQueueInterface;
 15 | use Spiral\RoadRunner\Jobs\Task\PreparedTaskInterface;
 16 | use Spiral\RoadRunnerBridge\Queue\PipelineRegistryInterface;
 17 | 
 18 | /**
 19 |  * @psalm-import-type TPipeline from \Spiral\RoadRunnerBridge\Config\QueueConfig
 20 |  */
 21 | final class Queue implements QueueInterface
 22 | {
 23 |     use QueueTrait;
 24 | 
 25 |     public const SERIALIZED_CLASS_HEADER_KEY = 'payload_class';
 26 | 
 27 |     /** @var array<non-empty-string, RRQueueInterface> */
 28 |     private array $queues = [];
 29 | 
 30 |     /**
 31 |      * @param non-empty-string|null $default
 32 |      */
 33 |     public function __construct(
 34 |         private readonly SerializerRegistryInterface $serializer,
 35 |         private readonly PipelineRegistryInterface $registry,
 36 |         private readonly ?string $pipeline = null,
 37 |         private readonly ?string $default = null,
 38 |     ) {}
 39 | 
 40 |     /**
 41 |      * @param non-empty-string $name
 42 |      *
 43 |      * @return non-empty-string
 44 |      * @throws InvalidArgumentException
 45 |      * @throws JobsException
 46 |      *
 47 |      * @psalm-suppress MoreSpecificImplementedParamType
 48 |      */
 49 |     public function push(
 50 |         string $name,
 51 |         mixed $payload = '',
 52 |         OptionsInterface|JobsOptionsInterface|null $options = null,
 53 |     ): string {
 54 |         $defaultPipeline = $this->pipeline ?? $this->default;
 55 | 
 56 |         $queue = $this->initQueue(
 57 |             $options instanceof OptionsInterface
 58 |                 ? $options->getQueue() ?? $defaultPipeline
 59 |                 : $defaultPipeline,
 60 |         );
 61 | 
 62 |         $preparedTask = $this->createTask($queue, $name, $payload, $options);
 63 | 
 64 |         return $queue->dispatch($preparedTask)->getId();
 65 |     }
 66 | 
 67 |     /**
 68 |      * @throws InvalidArgumentException
 69 |      */
 70 |     private function initQueue(?string $pipeline): RRQueueInterface
 71 |     {
 72 |         if ($pipeline === null || $pipeline === '') {
 73 |             throw new InvalidArgumentException('You must define RoadRunner queue pipeline.');
 74 |         }
 75 | 
 76 |         if (isset($this->queues[$pipeline])) {
 77 |             return $this->queues[$pipeline];
 78 |         }
 79 | 
 80 |         return $this->queues[$pipeline] = $this->registry->getPipeline($pipeline);
 81 |     }
 82 | 
 83 |     /**
 84 |      * @param non-empty-string $name
 85 |      */
 86 |     private function createTask(
 87 |         RRQueueInterface $queue,
 88 |         string $name,
 89 |         mixed $payload,
 90 |         OptionsInterface|JobsOptionsInterface|null $options,
 91 |     ): PreparedTaskInterface {
 92 |         $preparedTask = $queue->create(
 93 |             $name,
 94 |             $this->serializer->getSerializer($name)->serialize($payload),
 95 |             OptionsFactory::create($options),
 96 |         );
 97 | 
 98 |         if (\is_object($payload)) {
 99 |             $preparedTask = $preparedTask->withHeader(
100 |                 self::SERIALIZED_CLASS_HEADER_KEY,
101 |                 $payload::class,
102 |             );
103 |         }
104 | 
105 |         return $preparedTask;
106 |     }
107 | }
108 | 


--------------------------------------------------------------------------------
/src/Console/Command/Queue/ListCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace Spiral\RoadRunnerBridge\Console\Command\Queue;
 6 | 
 7 | use Spiral\Console\Attribute\AsCommand;
 8 | use Spiral\Console\Command;
 9 | use Spiral\RoadRunner\Jobs\Exception\JobsException;
10 | use Spiral\RoadRunner\Jobs\JobsInterface;
11 | use Spiral\RoadRunner\Jobs\QueueInterface;
12 | use Symfony\Component\Console\Helper\Table;
13 | use Symfony\Component\Console\Helper\TableCell;
14 | use Symfony\Component\Console\Helper\TableCellStyle;
15 | 
16 | #[AsCommand(
17 |     name: 'rr:jobs:list',
18 |     description: 'Displays a list of available job pipelines for the RoadRunner.',
19 | )]
20 | final class ListCommand extends Command
21 | {
22 |     /**
23 |      * @throws JobsException
24 |      */
25 |     public function perform(JobsInterface $jobs): int
26 |     {
27 |         $queues = \iterator_to_array($jobs->getIterator());
28 | 
29 |         if ($queues === []) {
30 |             $this->info('No job pipelines are currently declared for the RoadRunner.');
31 | 
32 |             return self::SUCCESS;
33 |         }
34 | 
35 |         $queues = \array_map(static function (QueueInterface $queue): array {
36 |             \is_callable([$queue, 'getPipelineStat']) or throw new \RuntimeException(
37 |                 'The queue does not support the pipeline statistics.',
38 |             );
39 |             $stat = $queue->getPipelineStat();
40 |             \assert($stat !== null);
41 | 
42 |             $isReady = $stat->getReady();
43 |             $fontColor = $isReady ? 'green' : 'gray';
44 |             $defaultColor = $isReady ? 'default' : 'gray';
45 |             $activeFont = $isReady ? 'bold' : '';
46 | 
47 |             return [
48 |                 'name' => new TableCell($stat->getPipeline(), [
49 |                     'style' => new TableCellStyle(['fg' => $fontColor, 'options' => $activeFont]),
50 |                 ]),
51 |                 'driver' => new TableCell($stat->getDriver(), [
52 |                     'style' => new TableCellStyle(
53 |                         ['fg' => $defaultColor, 'options' => $activeFont],
54 |                     ),
55 |                 ]),
56 |                 'priority' => new TableCell((string) $stat->getPriority(), [
57 |                     'style' => new TableCellStyle(
58 |                         ['fg' => $defaultColor, 'options' => $activeFont],
59 |                     ),
60 |                 ]),
61 |                 'active_jobs' => new TableCell((string) $stat->getActive(), [
62 |                     'style' => new TableCellStyle(
63 |                         ['fg' => $stat->getActive() > 0 ? 'green' : $defaultColor, 'options' => $activeFont],
64 |                     ),
65 |                 ]),
66 |                 'delayed_jobs' => new TableCell((string) $stat->getDelayed(), [
67 |                     'style' => new TableCellStyle(
68 |                         ['fg' => $stat->getDelayed() > 0 ? 'green' : $defaultColor, 'options' => $activeFont],
69 |                     ),
70 |                 ]),
71 |                 'reserved_jobs' => new TableCell((string) $stat->getReserved(), [
72 |                     'style' => new TableCellStyle(
73 |                         ['fg' => $stat->getReserved() > 0 ? 'green' : $defaultColor, 'options' => $activeFont],
74 |                     ),
75 |                 ]),
76 |                 'is_active' => $stat->getReady() ? '<fg=green> ✓ </>' : '<fg=red> ✖ </>',
77 |             ];
78 |         }, $queues);
79 | 
80 |         \ksort($queues);
81 |         \assert($this->output !== null);
82 |         $table = new Table($this->output);
83 | 
84 |         $table->setHeaders(
85 |             ['Name', 'Driver', 'Priority', 'Active jobs', 'Delayed jobs', 'Reserved jobs', 'Is active',],
86 |         );
87 | 
88 |         foreach ($queues as $data) {
89 |             $table->addRow($data);
90 |         }
91 | 
92 |         $table->render();
93 | 
94 |         return self::SUCCESS;
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/Queue/Internal/PayloadDeserializer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Queue\Internal;
  6 | 
  7 | use Spiral\Queue\HandlerInterface;
  8 | use Spiral\Queue\HandlerRegistryInterface;
  9 | use Spiral\Queue\SerializerRegistryInterface;
 10 | use Spiral\RoadRunner\Jobs\Task\ReceivedTaskInterface;
 11 | use Spiral\RoadRunnerBridge\Queue\PayloadDeserializerInterface;
 12 | 
 13 | /**
 14 |  * @internal
 15 |  */
 16 | final class PayloadDeserializer implements PayloadDeserializerInterface
 17 | {
 18 |     /**
 19 |      * Cache for detected types.
 20 |      *
 21 |      * @var array<class-string, class-string|string|null>
 22 |      */
 23 |     private array $handlerTypes = [];
 24 | 
 25 |     public function __construct(
 26 |         private readonly HandlerRegistryInterface $registry,
 27 |         private readonly SerializerRegistryInterface $serializer,
 28 |     ) {}
 29 | 
 30 |     public function deserialize(ReceivedTaskInterface $task): mixed
 31 |     {
 32 |         $payload = $task->getPayload();
 33 | 
 34 |         $serializer = $this->serializer->getSerializer($name = $task->getName());
 35 | 
 36 |         $class = $this->getClassFromHeader($task);
 37 |         if ($class !== null && \class_exists($class)) {
 38 |             return $serializer->unserialize($payload, $class);
 39 |         }
 40 | 
 41 |         try {
 42 |             $class = $this->detectTypeFromJobHandler($this->registry->getHandler($name));
 43 |         } catch (\Throwable) {
 44 |         }
 45 | 
 46 |         if ($class === 'string') {
 47 |             return $payload;
 48 |         }
 49 | 
 50 |         if ($class !== null && \class_exists($class)) {
 51 |             return $serializer->unserialize($payload, $class);
 52 |         }
 53 | 
 54 |         return $serializer->unserialize($payload);
 55 |     }
 56 | 
 57 |     private function getClassFromHeader(ReceivedTaskInterface $task): ?string
 58 |     {
 59 |         if ($task->hasHeader(Queue::SERIALIZED_CLASS_HEADER_KEY)) {
 60 |             return $task->getHeaderLine(Queue::SERIALIZED_CLASS_HEADER_KEY);
 61 |         }
 62 | 
 63 |         return null;
 64 |     }
 65 | 
 66 |     /**
 67 |      * Detects the type of for payload argument of the given handler's method.
 68 |      *
 69 |      * @return class-string|string|null
 70 |      * @throws \ReflectionException
 71 |      *
 72 |      */
 73 |     private function detectTypeFromJobHandler(HandlerInterface $handler): ?string
 74 |     {
 75 |         $handler = new \ReflectionClass($handler);
 76 | 
 77 |         if (isset($this->handlerTypes[$handler->getName()])) {
 78 |             return $this->handlerTypes[$handler->getName()];
 79 |         }
 80 | 
 81 |         if (!$handler->hasMethod('invoke')) {
 82 |             return $this->handlerTypes[$handler->getName()] = null;
 83 |         }
 84 | 
 85 |         $handlerMethod = $handler->getMethod('invoke');
 86 | 
 87 |         foreach ($handlerMethod->getParameters() as $parameter) {
 88 |             if ($parameter->getName() !== 'payload') {
 89 |                 continue;
 90 |             }
 91 | 
 92 |             $type = $this->detectType($parameter->getType());
 93 |             if ($type !== null) {
 94 |                 return $this->handlerTypes[$handler->getName()] = $type;
 95 |             }
 96 |         }
 97 | 
 98 |         return $this->handlerTypes[$handler->getName()] = null;
 99 |     }
100 | 
101 |     /**
102 |      * Detects the type of the given parameter.
103 |      *
104 |      * @throws \ReflectionException
105 |      */
106 |     private function detectType(\ReflectionType|null $type): ?string
107 |     {
108 |         if ($type instanceof \ReflectionNamedType) {
109 |             if ($type->isBuiltin()) {
110 |                 return $type->getName() === 'string' ? 'string' : null;
111 |             }
112 | 
113 |             return $type->getName();
114 |         }
115 | 
116 |         if ($type instanceof \ReflectionUnionType) {
117 |             foreach ($type->getTypes() as $t) {
118 |                 $class = $this->detectType($t);
119 |                 if ($class !== null) {
120 |                     return $class;
121 |                 }
122 |             }
123 |         }
124 | 
125 |         return null;
126 |     }
127 | }
128 | 


--------------------------------------------------------------------------------
/src/Queue/Internal/Dispatcher.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Queue\Internal;
  6 | 
  7 | use Psr\Container\ContainerExceptionInterface;
  8 | use Psr\Container\NotFoundExceptionInterface;
  9 | use Spiral\Attribute\DispatcherScope;
 10 | use Spiral\Boot\DispatcherInterface;
 11 | use Spiral\Boot\FinalizerInterface;
 12 | use Spiral\Core\Scope;
 13 | use Spiral\Core\ScopeInterface;
 14 | use Spiral\Exceptions\ExceptionReporterInterface;
 15 | use Spiral\Queue\Exception\RetryException;
 16 | use Spiral\Queue\ExtendedOptionsInterface;
 17 | use Spiral\Queue\Interceptor\Consume\Handler;
 18 | use Spiral\Queue\OptionsInterface;
 19 | use Spiral\Queue\Task;
 20 | use Spiral\Queue\TaskInterface;
 21 | use Spiral\RoadRunner\Jobs\ConsumerInterface;
 22 | use Spiral\RoadRunner\Jobs\Exception\JobsException;
 23 | use Spiral\RoadRunner\Jobs\Task\ProvidesHeadersInterface;
 24 | use Spiral\RoadRunner\Jobs\Task\ReceivedTaskInterface;
 25 | use Spiral\RoadRunnerBridge\Queue\PayloadDeserializerInterface;
 26 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
 27 | 
 28 | /**
 29 |  * @internal
 30 |  */
 31 | #[DispatcherScope(scope: 'queue')]
 32 | final class Dispatcher implements DispatcherInterface
 33 | {
 34 |     public function __construct(
 35 |         private readonly FinalizerInterface $finalizer,
 36 |         private readonly ScopeInterface $scope,
 37 |         private readonly ExceptionReporterInterface $reporter,
 38 |         private readonly ConsumerInterface $consumer,
 39 |         private readonly PayloadDeserializerInterface $deserializer,
 40 |         private readonly Handler $handler,
 41 |     ) {}
 42 | 
 43 |     public static function canServe(RoadRunnerMode $mode): bool
 44 |     {
 45 |         return \PHP_SAPI === 'cli' && $mode === RoadRunnerMode::Jobs;
 46 |     }
 47 | 
 48 |     /**
 49 |      * @throws JobsException
 50 |      * @throws ContainerExceptionInterface
 51 |      * @throws NotFoundExceptionInterface
 52 |      */
 53 |     public function serve(): void
 54 |     {
 55 |         $handler = $this->handler;
 56 | 
 57 |         while ($task = $this->consumer->waitTask()) {
 58 |             try {
 59 |                 /** @psalm-suppress InvalidArgument */
 60 |                 $this->scope->runScope(
 61 |                     new Scope('queue-task', [TaskInterface::class => new Task(
 62 |                         id: $task->getId(),
 63 |                         queue: $task->getQueue(),
 64 |                         name: $task->getName(),
 65 |                         payload: $this->deserializer->deserialize($task),
 66 |                         headers: $task->getHeaders(),
 67 |                     )]),
 68 |                     static function (TaskInterface $queueTask) use ($handler, $task): void {
 69 |                         $handler->handle(
 70 |                             name: $queueTask->getName(),
 71 |                             driver: 'roadrunner',
 72 |                             queue: $queueTask->getQueue(),
 73 |                             id: $queueTask->getId(),
 74 |                             payload: $queueTask->getPayload(),
 75 |                             headers: $queueTask->getHeaders(),
 76 |                         );
 77 | 
 78 |                         $task->ack();
 79 |                     },
 80 |                 );
 81 |             } catch (RetryException $e) {
 82 |                 $this->reporter->report($e);
 83 |                 $this->retry($e, $task);
 84 |                 unset($e);
 85 |             } catch (\Throwable $e) {
 86 |                 $this->reporter->report($e);
 87 |                 $task->nack($e);
 88 |                 unset($e);
 89 |             }
 90 | 
 91 |             $this->finalizer->finalize(terminate: false);
 92 |         }
 93 |     }
 94 | 
 95 |     /**
 96 |      * @throws JobsException
 97 |      */
 98 |     private function retry(RetryException $e, ReceivedTaskInterface $task): void
 99 |     {
100 |         $options = $e->getOptions();
101 | 
102 |         if ($options instanceof ProvidesHeadersInterface || $options instanceof ExtendedOptionsInterface) {
103 |             /** @var array<non-empty-string>|non-empty-string $values */
104 |             foreach ($options->getHeaders() as $header => $values) {
105 |                 $task = $task->withHeader($header, $values);
106 |             }
107 |         }
108 | 
109 |         if ($options instanceof OptionsInterface) {
110 |             $delay = $options->getDelay();
111 |             $delay === null or $task = $task->withDelay($delay);
112 |         }
113 | 
114 |         $task->requeue($e);
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/src/Tcp/Internal/Server.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Tcp\Internal;
  6 | 
  7 | use Psr\Container\ContainerInterface;
  8 | use Spiral\Boot\FinalizerInterface;
  9 | use Spiral\Core\Attribute\Proxy;
 10 | use Spiral\Core\CompatiblePipelineBuilder;
 11 | use Spiral\Core\Scope;
 12 | use Spiral\Core\ScopeInterface;
 13 | use Spiral\Exceptions\ExceptionReporterInterface;
 14 | use Spiral\Interceptors\Context\CallContext;
 15 | use Spiral\Interceptors\Context\Target;
 16 | use Spiral\Interceptors\Handler\AutowireHandler;
 17 | use Spiral\Interceptors\HandlerInterface;
 18 | use Spiral\Interceptors\PipelineBuilderInterface;
 19 | use Spiral\RoadRunner\Payload;
 20 | use Spiral\RoadRunner\Tcp\RequestInterface;
 21 | use Spiral\RoadRunner\Tcp\TcpWorker;
 22 | use Spiral\RoadRunner\Worker;
 23 | use Spiral\RoadRunner\WorkerInterface;
 24 | use Spiral\RoadRunnerBridge\Config\TcpConfig;
 25 | use Spiral\RoadRunnerBridge\Tcp\Interceptor\RegistryInterface as InterceptorRegistry;
 26 | use Spiral\RoadRunnerBridge\Tcp\Response\CloseConnection;
 27 | use Spiral\RoadRunnerBridge\Tcp\Response\ResponseInterface;
 28 | use Spiral\RoadRunnerBridge\Tcp\Service\RegistryInterface as ServiceRegistry;
 29 | 
 30 | final class Server
 31 | {
 32 |     private readonly PipelineBuilderInterface $pipelineBuilder;
 33 |     private readonly HandlerInterface $handler;
 34 | 
 35 |     /** @var array<non-empty-string, HandlerInterface> */
 36 |     private array $pipelines = [];
 37 | 
 38 |     public function __construct(
 39 |         private readonly TcpConfig $config,
 40 |         private readonly InterceptorRegistry $interceptors,
 41 |         private readonly ServiceRegistry $services,
 42 |         #[Proxy] private readonly ContainerInterface $container,
 43 |         private readonly FinalizerInterface $finalizer,
 44 |         private readonly ExceptionReporterInterface $reporter,
 45 |         ?PipelineBuilderInterface $pipelineBuilder = null,
 46 |     ) {
 47 |         $this->pipelineBuilder = $pipelineBuilder ?? $container->get(CompatiblePipelineBuilder::class);
 48 |         $this->handler = new AutowireHandler($container);
 49 |     }
 50 | 
 51 |     /**
 52 |      * @throws \JsonException
 53 |      */
 54 |     public function serve(?WorkerInterface $worker = null): void
 55 |     {
 56 |         $worker ??= Worker::create();
 57 |         $tcpWorker = new TcpWorker($worker);
 58 |         $scope = $this->container->get(ScopeInterface::class);
 59 | 
 60 |         while ($request = $tcpWorker->waitRequest()) {
 61 |             $e = null;
 62 |             try {
 63 |                 $server = $request->getServer();
 64 |                 $pipeline = $this->getPipeline($server);
 65 |                 $services = $this->services;
 66 | 
 67 |                 /**
 68 |                  * @var ResponseInterface $response
 69 |                  */
 70 |                 $response = $scope->runScope(
 71 |                     new Scope('tcp-request', [RequestInterface::class => $request]),
 72 |                     static fn(): mixed => $pipeline->handle(new CallContext(
 73 |                         /** @see \Spiral\RoadRunnerBridge\Tcp\Service\ServiceInterface::handle() */
 74 |                         Target::fromPair($services->getService($server), 'handle'),
 75 |                         [$request],
 76 |                         ['server' => $server],
 77 |                     )),
 78 |                 );
 79 |             } catch (\Throwable $e) {
 80 |                 $worker->error($this->config->isDebugMode() ? (string) $e : $e->getMessage());
 81 |                 $response = new CloseConnection();
 82 |             } finally {
 83 |                 if (isset($response) && $response instanceof ResponseInterface) {
 84 |                     $tcpWorker->getWorker()->respond(
 85 |                         new Payload($response->getBody(), $response->getAction()->value),
 86 |                     );
 87 |                 }
 88 | 
 89 |                 $this->finalize($e);
 90 |             }
 91 |         }
 92 |     }
 93 | 
 94 |     /**
 95 |      * @param non-empty-string $server
 96 |      */
 97 |     private function getPipeline(string $server): HandlerInterface
 98 |     {
 99 |         return $this->pipelines[$server] ??= $this->pipelineBuilder
100 |             ->withInterceptors(...$this->interceptors->getInterceptors($server))
101 |             ->build($this->handler);
102 |     }
103 | 
104 |     private function finalize(?\Throwable $e): void
105 |     {
106 |         if ($e !== null) {
107 |             try {
108 |                 $this->reporter->report($e);
109 |             } catch (\Throwable) {
110 |                 // no need to notify when unable to register an exception
111 |             }
112 |         }
113 | 
114 |         $this->finalizer->finalize(terminate: false);
115 |     }
116 | }
117 | 


--------------------------------------------------------------------------------
/src/Console/Command/Scaffolder/CentrifugoHandlerCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Console\Command\Scaffolder;
  6 | 
  7 | use Spiral\Console\Attribute\Argument;
  8 | use Spiral\Console\Attribute\AsCommand;
  9 | use Spiral\Console\Attribute\Option;
 10 | use Spiral\Console\Attribute\Question;
 11 | use Spiral\RoadRunnerBridge\Scaffolder\Declaration\CentrifugoHandlerDeclaration;
 12 | use Spiral\Scaffolder\Command\AbstractCommand;
 13 | 
 14 | #[AsCommand(name: 'create:centrifugo-handler', description: 'Create Centrifugo handler declaration')]
 15 | final class CentrifugoHandlerCommand extends AbstractCommand
 16 | {
 17 |     #[Argument(description: 'Centrifugo handler name')]
 18 |     #[Question(question: 'What would you like to name the Centrifugo handler?')]
 19 |     private string $name;
 20 | 
 21 |     #[Option(shortcut: 'c', description: 'Optional comment to add as class header')]
 22 |     private ?string $comment = null;
 23 | 
 24 |     #[Option(description: 'Optional, specify a custom namespace')]
 25 |     private ?string $namespace = null;
 26 | 
 27 |     #[Option(shortcut: 't', description: 'Service type [connect, subscribe, rpc, refresh, publish]')]
 28 |     private string $type = 'connect';
 29 | 
 30 |     #[Option(name: 'with-api', shortcut: 'a', description: 'With API dependency')]
 31 |     private bool $withApi = false;
 32 | 
 33 |     public function perform(): int
 34 |     {
 35 |         $declaration = $this->createDeclaration(CentrifugoHandlerDeclaration::class, [
 36 |             'withApi' => $this->withApi,
 37 |         ]);
 38 | 
 39 |         $type = match ($this->type) {
 40 |             'connect' => [
 41 |                 'request' => \RoadRunner\Centrifugo\Request\Connect::class,
 42 |                 'use' => [
 43 |                     \RoadRunner\Centrifugo\Payload\ConnectResponse::class,
 44 |                 ],
 45 |                 'body' => $this->createConnectHandlerBody(),
 46 |             ],
 47 |             'subscribe' => [
 48 |                 'request' => \RoadRunner\Centrifugo\Request\Subscribe::class,
 49 |                 'use' => [
 50 |                     \RoadRunner\Centrifugo\Payload\SubscribeResponse::class,
 51 |                 ],
 52 |                 'body' => $this->createSubscribeHandlerBody(),
 53 |             ],
 54 |             'rpc' => [
 55 |                 'request' => \RoadRunner\Centrifugo\Request\RPC::class,
 56 |                 'use' => [
 57 |                     \RoadRunner\Centrifugo\Payload\RPCResponse::class,
 58 |                 ],
 59 |                 'body' => $this->createRpcHandlerBody(),
 60 |             ],
 61 |             'refresh' => [
 62 |                 'request' => \RoadRunner\Centrifugo\Request\Refresh::class,
 63 |                 'use' => [
 64 |                     \RoadRunner\Centrifugo\Payload\RefreshResponse::class,
 65 |                 ],
 66 |                 'body' => $this->createRefreshHandlerBody(),
 67 |             ],
 68 |             'publish' => [
 69 |                 'request' => \RoadRunner\Centrifugo\Request\Publish::class,
 70 |                 'use' => [
 71 |                     \RoadRunner\Centrifugo\Payload\PublishResponse::class,
 72 |                 ],
 73 |                 'body' => $this->createPublishHandlerBody(),
 74 |             ],
 75 |             default => throw new \InvalidArgumentException('Invalid service type'),
 76 |         };
 77 | 
 78 |         $declaration->setType($type);
 79 | 
 80 |         $this->writeDeclaration($declaration);
 81 | 
 82 |         return self::SUCCESS;
 83 |     }
 84 | 
 85 |     private function createConnectHandlerBody(): string
 86 |     {
 87 |         return <<<'PHP'
 88 | try {
 89 |     $request->respond(
 90 |         new ConnectResponse(
 91 |             user: '', // User ID
 92 |             channels: [
 93 |                 // List of channels to subscribe to on connect to Centrifugo
 94 |                 // 'public',
 95 |             ],
 96 |         )
 97 |     );
 98 | } catch (\Throwable $e) {
 99 |     $request->error($e->getCode(), $e->getMessage());
100 | }
101 | PHP;
102 |     }
103 | 
104 |     private function createSubscribeHandlerBody(): string
105 |     {
106 |         return <<<'PHP'
107 | try {
108 |     // Here you can check if user is allowed to subscribe to requested channel
109 |     if ($request->channel !== 'public') {
110 |         $request->disconnect('403', 'Channel is not allowed.');
111 |         return;
112 |     }
113 | 
114 |     $request->respond(
115 |         new SubscribeResponse()
116 |     );
117 | } catch (\Throwable $e) {
118 |     $request->error($e->getCode(), $e->getMessage());
119 | }
120 | PHP;
121 |     }
122 | 
123 |     private function createRpcHandlerBody(): string
124 |     {
125 |         return <<<'PHP'
126 | $result = match ($request->method) {
127 |     'ping' => ['pong' => 'pong', 'code' => 200],
128 |     default => ['error' => 'Not found', 'code' => 404]
129 | };
130 | 
131 | try {
132 |     $request->respond(
133 |         new RPCResponse(
134 |             data: $result
135 |         )
136 |     );
137 | } catch (\Throwable $e) {
138 |     $request->error($e->getCode(), $e->getMessage());
139 | }
140 | PHP;
141 |     }
142 | 
143 |     private function createRefreshHandlerBody(): string
144 |     {
145 |         return <<<'PHP'
146 | try {
147 |     $request->respond(
148 |         new RefreshResponse(...)
149 |     );
150 | } catch (\Throwable $e) {
151 |     $request->error($e->getCode(), $e->getMessage());
152 | }
153 | PHP;
154 |     }
155 | 
156 |     private function createPublishHandlerBody(): string
157 |     {
158 |         return <<<'PHP'
159 | try {
160 |     $request->respond(
161 |         new PublishResponse(...)
162 |     );
163 | } catch (\Throwable $e) {
164 |     $request->error($e->getCode(), $e->getMessage());
165 | }
166 | PHP;
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/src/Queue/Internal/RPCPipelineRegistry.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Queue\Internal;
  6 | 
  7 | use Psr\Log\LoggerInterface;
  8 | use Spiral\Queue\Exception\InvalidArgumentException;
  9 | use Spiral\RoadRunner\Jobs\Exception\JobsException;
 10 | use Spiral\RoadRunner\Jobs\Jobs;
 11 | use Spiral\RoadRunner\Jobs\JobsInterface;
 12 | use Spiral\RoadRunner\Jobs\OptionsInterface;
 13 | use Spiral\RoadRunner\Jobs\Queue\CreateInfoInterface;
 14 | use Spiral\RoadRunner\Jobs\QueueInterface;
 15 | use Spiral\RoadRunnerBridge\Config\QueueConfig;
 16 | use Spiral\RoadRunnerBridge\Queue\PipelineRegistryInterface;
 17 | use Spiral\RoadRunnerBridge\RoadRunnerMode;
 18 | 
 19 | /**
 20 |  * @internal
 21 |  *
 22 |  * @psalm-import-type TPipeline from \Spiral\RoadRunnerBridge\Config\QueueConfig
 23 |  */
 24 | final class RPCPipelineRegistry implements PipelineRegistryInterface
 25 | {
 26 |     private int $expiresAt = 0;
 27 |     private array $existPipelines = [];
 28 | 
 29 |     /** @var array<non-empty-string,TPipeline> */
 30 |     private readonly array $pipelines;
 31 | 
 32 |     /**
 33 |      * @param Jobs|JobsInterface $jobs
 34 |      * @param int $ttl Time to cache existing RoadRunner pipelines
 35 |      */
 36 |     public function __construct(
 37 |         private readonly LoggerInterface $logger,
 38 |         private readonly JobsInterface $jobs,
 39 |         private readonly RoadRunnerMode $mode,
 40 |         QueueConfig $config,
 41 |         private readonly int $ttl = 60,
 42 |     ) {
 43 |         $this->pipelines = $config->getPipelines();
 44 |     }
 45 | 
 46 |     /**
 47 |      * @throws JobsException
 48 |      * @throws InvalidArgumentException
 49 |      */
 50 |     public function declareConsumerPipelines(): void
 51 |     {
 52 |         if ($this->mode !== RoadRunnerMode::Jobs) {
 53 |             return;
 54 |         }
 55 | 
 56 |         $this->expiresAt = 0;
 57 | 
 58 |         foreach ($this->pipelines as $name => $pipeline) {
 59 |             $consume = $pipeline['consume'] ?? false;
 60 |             if (!$consume) {
 61 |                 continue;
 62 |             }
 63 | 
 64 |             $connector = $this->getConnector($name);
 65 | 
 66 |             if (!$this->isExists($connector)) {
 67 |                 try {
 68 |                     $this->jobs->create($connector)->resume();
 69 |                 } catch (JobsException $e) {
 70 |                     $this->logger->warning(
 71 |                         \sprintf(
 72 |                             'Unable to declare consumer pipeline "%s". Reason: %s',
 73 |                             $name,
 74 |                             $e->getMessage(),
 75 |                         ),
 76 |                     );
 77 |                 }
 78 |             }
 79 |         }
 80 |     }
 81 | 
 82 |     /**
 83 |      * @throws JobsException
 84 |      * @throws InvalidArgumentException
 85 |      */
 86 |     public function getPipeline(string $name): QueueInterface
 87 |     {
 88 |         if (!isset($this->pipelines[$name])) {
 89 |             return $this->jobs->connect($name);
 90 |         }
 91 | 
 92 |         $connector = $this->getConnector($name);
 93 | 
 94 |         /**
 95 |          * @var OptionsInterface|null $options
 96 |          */
 97 |         $options = OptionsFactory::create($this->pipelines[$name]['options'] ?? null)
 98 |             ?? OptionsFactory::fromCreateInfo($connector);
 99 | 
100 |         \assert($options === null || $options instanceof OptionsInterface);
101 | 
102 |         if (!$this->isExists($connector)) {
103 |             return $this->create($connector, $options);
104 |         }
105 | 
106 |         return $this->connect($connector, $options);
107 |     }
108 | 
109 |     /**
110 |      * @param non-empty-string $name
111 |      *
112 |      * @throws InvalidArgumentException
113 |      */
114 |     public function getConnector(string $name): CreateInfoInterface
115 |     {
116 |         // Connector is required for pipeline declaration
117 |         if (!isset($this->pipelines[$name]['connector'])) {
118 |             throw new InvalidArgumentException(
119 |                 \sprintf('You must specify connector for given pipeline `%s`.', $name),
120 |             );
121 |         }
122 | 
123 |         if (!$this->pipelines[$name]['connector'] instanceof CreateInfoInterface) {
124 |             throw new InvalidArgumentException(
125 |                 \sprintf('Connector should implement %s interface.', CreateInfoInterface::class),
126 |             );
127 |         }
128 | 
129 |         return $this->pipelines[$name]['connector'];
130 |     }
131 | 
132 |     /**
133 |      * Check if RoadRunner jobs pipeline exists
134 |      */
135 |     private function isExists(CreateInfoInterface $connector): bool
136 |     {
137 |         if ($this->expiresAt < \time()) {
138 |             $this->existPipelines = \array_keys(
139 |                 \iterator_to_array($this->jobs->getIterator()),
140 |             );
141 | 
142 |             $this->expiresAt = \time() + $this->ttl;
143 |         }
144 | 
145 |         return \in_array($connector->getName(), $this->existPipelines, true);
146 |     }
147 | 
148 |     /**
149 |      * Create a new RoadRunner jobs pipeline
150 |      *
151 |      * @throws JobsException
152 |      */
153 |     private function create(CreateInfoInterface $connector, ?OptionsInterface $options = null): QueueInterface
154 |     {
155 |         $this->expiresAt = 0;
156 |         /** @psalm-suppress TooManyArguments */
157 |         return $this->jobs->create($connector, $options);
158 |     }
159 | 
160 |     /**
161 |      * Connect to the RoadRunner jobs pipeline
162 |      */
163 |     private function connect(CreateInfoInterface $connector, ?OptionsInterface $options = null): QueueInterface
164 |     {
165 |         /** @psalm-suppress TooManyArguments */
166 |         return $this->jobs->connect($connector->getName(), $options);
167 |     }
168 | }
169 | 


--------------------------------------------------------------------------------
/src/Console/Command/GRPC/GenerateCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Console\Command\GRPC;
  6 | 
  7 | use Codedungeon\PHPCliColors\Color;
  8 | use Spiral\Boot\DirectoriesInterface;
  9 | use Spiral\Boot\KernelInterface;
 10 | use Spiral\Console\Command;
 11 | use Spiral\Files\FilesInterface;
 12 | use Spiral\RoadRunnerBridge\Config\GRPCConfig;
 13 | use Spiral\RoadRunnerBridge\GRPC\Exception\CompileException;
 14 | use Spiral\RoadRunnerBridge\GRPC\Generator\GeneratorRegistryInterface;
 15 | use Spiral\RoadRunnerBridge\GRPC\Internal\CommandExecutor;
 16 | use Spiral\RoadRunnerBridge\GRPC\Internal\ProtocCommandBuilder;
 17 | use Spiral\RoadRunnerBridge\GRPC\Internal\ProtoCompiler;
 18 | use Spiral\RoadRunnerBridge\GRPC\ProtoRepository\ProtoFilesRepositoryInterface;
 19 | 
 20 | final class GenerateCommand extends Command
 21 | {
 22 |     protected const SIGNATURE = 'grpc:generate
 23 |                                          {path=auto : Base path for generated service code}
 24 |                                          {namespace=auto : Base namespace for generated service code}';
 25 |     protected const DESCRIPTION = 'Generate GPRC service code using protobuf specification';
 26 | 
 27 |     public function perform(
 28 |         KernelInterface $kernel,
 29 |         FilesInterface $files,
 30 |         DirectoriesInterface $dirs,
 31 |         GRPCConfig $config,
 32 |         ProtoFilesRepositoryInterface $repository,
 33 |         GeneratorRegistryInterface $generatorRegistry,
 34 |     ): int {
 35 |         $binaryPath = $config->getBinaryPath();
 36 | 
 37 |         if ($binaryPath === null && \file_exists($this->getDefaultBinary())) {
 38 |             $binaryPath = $this->getDefaultBinary();
 39 |         }
 40 | 
 41 |         $binaryPath ?? throw new \RuntimeException('Protoc plugin binary was not set in the configuration.');
 42 | 
 43 |         if (!\file_exists($binaryPath)) {
 44 |             $this->error("Protoc plugin binary `$binaryPath` was not found. Use command `./vendor/bin/rr download-protoc-binary` to download it.");
 45 | 
 46 |             return self::FAILURE;
 47 |         }
 48 | 
 49 |         \assert($binaryPath !== null);
 50 | 
 51 |         $compiler = new ProtoCompiler(
 52 |             $this->getPath($kernel, $config->getGeneratedPath()),
 53 |             $this->getNamespace($kernel, $config->getNamespace()),
 54 |             $files,
 55 |             new ProtocCommandBuilder($files, $config, $binaryPath),
 56 |             new CommandExecutor(),
 57 |         );
 58 | 
 59 |         $compiled = [];
 60 |         foreach ($repository->getProtos() as $protoFile) {
 61 |             if (!\file_exists($protoFile)) {
 62 |                 $this->sprintf('<error>Proto file `%s` not found.</error>', $protoFile);
 63 |                 continue;
 64 |             }
 65 |             $protoFile = \realpath($protoFile) ?: $protoFile;
 66 | 
 67 |             $this->sprintf("<info>Compiling <fg=cyan>`%s`</fg=cyan>:</info>\n", $protoFile);
 68 | 
 69 |             try {
 70 |                 $result = $compiler->compile($protoFile);
 71 |             } catch (CompileException $e) {
 72 |                 throw $e;
 73 |             } catch (\Throwable $e) {
 74 |                 $this->sprintf("<error>Error:</error> <fg=red>%s</fg=red>\n", $e->getMessage());
 75 |                 continue;
 76 |             }
 77 | 
 78 |             if ($result === []) {
 79 |                 $this->sprintf("<info>No files were generated for `%s`.</info>\n", $protoFile);
 80 |                 continue;
 81 |             }
 82 | 
 83 |             foreach ($result as $file) {
 84 |                 $this->sprintf(
 85 |                     "<fg=green>•</fg=green> %s%s%s\n",
 86 |                     Color::LIGHT_WHITE,
 87 |                     $files->relativePath($file, $dirs->get('root')),
 88 |                     Color::RESET,
 89 |                 );
 90 | 
 91 |                 $compiled[] = $file;
 92 |             }
 93 |         }
 94 | 
 95 |         foreach ($generatorRegistry->getGenerators() as $generator) {
 96 |             /** @psalm-suppress ArgumentTypeCoercion */
 97 |             $generator->run(
 98 |                 $compiled,
 99 |                 $this->getPath($kernel, $config->getGeneratedPath()),
100 |                 $this->getNamespace($kernel, $config->getNamespace()),
101 |             );
102 |         }
103 | 
104 |         return self::SUCCESS;
105 |     }
106 | 
107 |     /**
108 |      * Get or detect base source code path. By default fallbacks to kernel location.
109 |      *
110 |      * @param non-empty-string|null $generatedPath
111 |      *
112 |      * @return non-empty-string
113 |      */
114 |     protected function getPath(KernelInterface $kernel, ?string $generatedPath): string
115 |     {
116 |         $path = $this->argument('path');
117 |         if ($path !== 'auto') {
118 |             return $path;
119 |         }
120 | 
121 |         if ($generatedPath !== null) {
122 |             return $generatedPath;
123 |         }
124 | 
125 |         $r = new \ReflectionObject($kernel);
126 | 
127 |         /** @psalm-suppress LessSpecificReturnStatement */
128 |         return \dirname($r->getFileName());
129 |     }
130 | 
131 |     /**
132 |      * Get or detect base namespace. By default fallbacks to kernel namespace.
133 |      *
134 |      * @return non-empty-string
135 |      *
136 |      * @psalm-suppress LessSpecificReturnStatement
137 |      */
138 |     protected function getNamespace(KernelInterface $kernel, ?string $protoNamespace): string
139 |     {
140 |         $namespace = $this->argument('namespace');
141 |         if ($namespace !== 'auto') {
142 |             return $namespace;
143 |         }
144 | 
145 |         if ($protoNamespace !== null) {
146 |             return $protoNamespace;
147 |         }
148 | 
149 |         return (new \ReflectionObject($kernel))->getNamespaceName();
150 |     }
151 | 
152 |     private function getDefaultBinary(): string
153 |     {
154 |         return 'protoc-gen-php-grpc' . (PHP_OS_FAMILY === 'Windows' ? '.exe' : '');
155 |     }
156 | }
157 | 


--------------------------------------------------------------------------------
/src/Logger/Internal/RoadRunnerJsonFormatter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Logger\Internal;
  6 | 
  7 | use Monolog\Formatter\NormalizerFormatter;
  8 | use Monolog\Level;
  9 | use Monolog\Logger;
 10 | use Monolog\LogRecord;
 11 | use Spiral\RoadRunnerBridge\Logger\RoadRunnerLogsMode;
 12 | 
 13 | /**
 14 |  * RoadRunner JSON formatter for Monolog that formats log records according to RoadRunner's logging standards.
 15 |  *
 16 |  * This formatter extends Monolog's NormalizerFormatter to provide RoadRunner-specific JSON formatting.
 17 |  * It handles different logging modes (production vs development) and provides configurable options
 18 |  * for logger prefixes, trace counts, and date formatting.
 19 |  *
 20 |  * The formatter produces JSON output compatible with RoadRunner's logging infrastructure and can
 21 |  * be configured to output either human-readable timestamps (development mode) or Unix timestamps
 22 |  * with microseconds (production mode).
 23 |  *
 24 |  * @internal
 25 |  */
 26 | final class RoadRunnerJsonFormatter extends NormalizerFormatter
 27 | {
 28 |     /**
 29 |      * Create a new RoadRunner JSON formatter instance.
 30 |      *
 31 |      * @param string $loggerPrefix Optional prefix to prepend to logger channel names. Useful for
 32 |      *        namespacing logs in multi-application environments.
 33 |      * @param RoadRunnerLogsMode $loggerMode The logging mode that determines timestamp format and log level
 34 |      *        representation. In development mode, provides human-readable timestamps and uppercase log levels.
 35 |      *        In production mode, uses Unix timestamps with microseconds and lowercase log levels.
 36 |      * @param int $traceCount Maximum number of stack trace entries to include when logging
 37 |      *        exceptions. Defaults to 5 to prevent excessive log size.
 38 |      * @param string|null $dateFormat Custom date format string. If null, uses the parent class default format.
 39 |      *        This parameter is passed to the parent NormalizerFormatter.
 40 |      */
 41 |     public function __construct(
 42 |         private readonly string $loggerPrefix = '',
 43 |         private readonly RoadRunnerLogsMode $loggerMode = RoadRunnerLogsMode::Production,
 44 |         private readonly int $traceCount = 5,
 45 |         ?string $dateFormat = null,
 46 |     ) {
 47 |         parent::__construct($dateFormat);
 48 |     }
 49 | 
 50 |     /**
 51 |      * Format a log record into a RoadRunner-compatible JSON structure.
 52 |      *
 53 |      * This method converts Monolog log records into a standardized format that RoadRunner
 54 |      * can process. The output includes essential fields like level, timestamp, logger name,
 55 |      * and message, along with any context and extra data from the original record.
 56 |      *
 57 |      * The formatting behavior varies based on the configured logger mode:
 58 |      * - Development mode: Human-readable timestamps (RFC3339) and uppercase log levels
 59 |      * - Production mode: Unix timestamps with microseconds and lowercase log levels
 60 |      *
 61 |      * @param LogRecord|array{
 62 |      *     message: string,
 63 |      *     level: Logger::DEBUG|Logger::INFO|Logger::NOTICE|Logger::WARNING|Logger::ERROR|Logger::CRITICAL|Logger::ALERT|Logger::EMERGENCY,
 64 |      *     level_name: 'DEBUG'|'INFO'|'NOTICE'|'WARNING'|'ERROR'|'CRITICAL'|'ALERT'|'EMERGENCY',
 65 |      *     channel: string,
 66 |      *     datetime: \DateTimeImmutable,
 67 |      *     context?: array<array-key, mixed>,
 68 |      *     extra?: array<array-key, mixed>
 69 |      * } $record The log record to format, either as a LogRecord object or array
 70 |      *
 71 |      * @return array{
 72 |      *     level: non-empty-string,
 73 |      *     ts: non-empty-string,
 74 |      *     logger: non-empty-string,
 75 |      *     msg: string,
 76 |      *     ...
 77 |      * } The formatted log record as an array with the following structure:
 78 |      *   - level: The log level (string)
 79 |      *   - ts: Timestamp in the configured format
 80 |      *   - logger: Logger name with optional prefix
 81 |      *   - msg: The log message
 82 |      *   - Additional context and extra data merged from the original record
 83 |      *
 84 |      * @throws \InvalidArgumentException If the record structure is invalid
 85 |      */
 86 |     public function format(array|LogRecord $record): array
 87 |     {
 88 |         $normalized = $this->normalize(\is_array($record) ? $record : $record->toArray());
 89 | 
 90 |         $level = match (Logger::toMonologLevel($record['level'])) {
 91 |             Level::Error, Level::Critical, Level::Alert, Level::Emergency => 'error',
 92 |             Level::Warning => 'warning',
 93 |             Level::Info, Level::Notice => 'info',
 94 |             Level::Debug => 'debug',
 95 |         };
 96 | 
 97 |         \assert($record['datetime'] instanceof \DateTimeInterface);
 98 | 
 99 |         $ts = $this->loggerMode === RoadRunnerLogsMode::Development
100 |             ? $record['datetime']->format(\DateTimeInterface::RFC3339)
101 |             : $record['datetime']->format('Uu000');
102 | 
103 |         \assert(\is_string($record['channel']));
104 | 
105 |         return [
106 |             'level' => $this->loggerMode === RoadRunnerLogsMode::Development ? \strtoupper($level) : $level,
107 |             'ts' => $ts,
108 |             'logger' => $this->loggerPrefix . $record['channel'],
109 |             'msg' => $record['message'],
110 |         ]
111 |             + ($normalized['context'] ?? [])
112 |             + ($normalized['extra'] ?? []);
113 |     }
114 | 
115 |     /**
116 |      * Normalize exception data with configurable trace depth limit.
117 |      *
118 |      * This method overrides the parent implementation to limit the number of stack trace
119 |      * entries included in the log output. This prevents excessive log size while still
120 |      * providing useful debugging information.
121 |      *
122 |      * The trace count limit is controlled by the `$traceCount` constructor parameter,
123 |      * which defaults to 5 entries.
124 |      *
125 |      * @param \Throwable $e The exception to normalize
126 |      * @param int $depth The current recursion depth (used by parent implementation)
127 |      *
128 |      * @return array<array-key, string|int|array<string|int|array<string>>> The normalized exception data with limited stack trace
129 |      */
130 |     protected function normalizeException(\Throwable $e, int $depth = 0): array
131 |     {
132 |         $normalized = parent::normalizeException($e, $depth);
133 | 
134 |         if (isset($normalized['trace']) && \is_array($normalized['trace'])) {
135 |             $normalized['trace'] = \array_slice($normalized['trace'], 0, $this->traceCount);
136 |         }
137 | 
138 |         return $normalized;
139 |     }
140 | }
141 | 


--------------------------------------------------------------------------------
/src/Bootloader/GRPCBootloader.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Spiral\RoadRunnerBridge\Bootloader;
  6 | 
  7 | use Psr\Container\ContainerInterface;
  8 | use Spiral\Boot\Bootloader\Bootloader;
  9 | use Spiral\Boot\KernelInterface;
 10 | use Spiral\Config\ConfiguratorInterface;
 11 | use Spiral\Config\Patch\Append;
 12 | use Spiral\Core\Attribute\Proxy;
 13 | use Spiral\Core\CompatiblePipelineBuilder;
 14 | use Spiral\Core\Container\Autowire;
 15 | use Spiral\Core\CoreInterceptorInterface;
 16 | use Spiral\Core\FactoryInterface;
 17 | use Spiral\Grpc\Client\Bridge\GrpcClientBootloader;
 18 | use Spiral\Grpc\Client\Config\GrpcClientConfig;
 19 | use Spiral\Interceptors\Handler\AutowireHandler;
 20 | use Spiral\Interceptors\InterceptorInterface;
 21 | use Spiral\Interceptors\PipelineBuilderInterface;
 22 | use Spiral\RoadRunner\GRPC\InvokerInterface;
 23 | use Spiral\RoadRunner\GRPC\Server;
 24 | use Spiral\RoadRunnerBridge\Config\GRPCConfig;
 25 | use Spiral\RoadRunnerBridge\GRPC\Generator\GeneratorInterface;
 26 | use Spiral\RoadRunnerBridge\GRPC\Generator\GeneratorRegistry;
 27 | use Spiral\RoadRunnerBridge\GRPC\Generator\GeneratorRegistryInterface;
 28 | use Spiral\RoadRunnerBridge\GRPC\Internal\Dispatcher;
 29 | use Spiral\RoadRunnerBridge\GRPC\Internal\Invoker;
 30 | use Spiral\RoadRunnerBridge\GRPC\Internal\ServiceLocator;
 31 | use Spiral\RoadRunnerBridge\GRPC\LocatorInterface;
 32 | use Spiral\RoadRunnerBridge\GRPC\ProtoRepository\FileRepository;
 33 | use Spiral\RoadRunnerBridge\GRPC\ProtoRepository\ProtoFilesRepositoryInterface;
 34 | use Spiral\Tokenizer\TokenizerListenerRegistryInterface;
 35 | 
 36 | final class GRPCBootloader extends Bootloader
 37 | {
 38 |     public function __construct(
 39 |         private readonly ConfiguratorInterface $config,
 40 |     ) {}
 41 | 
 42 |     public function defineDependencies(): array
 43 |     {
 44 |         return [
 45 |             RoadRunnerBootloader::class,
 46 |             GrpcClientBootloader::class,
 47 |         ];
 48 |     }
 49 | 
 50 |     public function defineSingletons(): array
 51 |     {
 52 |         return [
 53 |             Server::class => Server::class,
 54 |             InvokerInterface::class => [self::class, 'initInvoker'],
 55 |             LocatorInterface::class => ServiceLocator::class,
 56 |             ProtoFilesRepositoryInterface::class => [self::class, 'initProtoFilesRepository'],
 57 |             GeneratorRegistryInterface::class => [self::class, 'initGeneratorRegistry'],
 58 |             GrpcClientConfig::class => [GRPCConfig::class, 'getClientConfig'],
 59 |         ];
 60 |     }
 61 | 
 62 |     public function init(
 63 |         TokenizerListenerRegistryInterface $listenerRegistry,
 64 |         LocatorInterface $listener,
 65 |     ): void {
 66 |         $this->initGrpcConfig();
 67 |         $listenerRegistry->addListener($listener);
 68 |     }
 69 | 
 70 |     public function boot(KernelInterface $kernel): void
 71 |     {
 72 |         /** @psalm-suppress InvalidArgument */
 73 |         $kernel->addDispatcher(Dispatcher::class);
 74 |     }
 75 | 
 76 |     /**
 77 |      * @param Autowire|class-string<CoreInterceptorInterface>|CoreInterceptorInterface $interceptor
 78 |      */
 79 |     public function addInterceptor(string|CoreInterceptorInterface|Autowire $interceptor): void
 80 |     {
 81 |         $this->config->modify(
 82 |             GRPCConfig::CONFIG,
 83 |             new Append('interceptors', null, $interceptor),
 84 |         );
 85 |     }
 86 | 
 87 |     /**
 88 |      * @param Autowire|class-string<GeneratorInterface>|GeneratorInterface $generator
 89 |      */
 90 |     public function addGenerator(string|GeneratorInterface|Autowire $generator): void
 91 |     {
 92 |         $this->config->modify(GRPCConfig::CONFIG, new Append('generators', null, $generator));
 93 |     }
 94 | 
 95 |     private function initGrpcConfig(): void
 96 |     {
 97 |         $this->config->setDefaults(
 98 |             GRPCConfig::CONFIG,
 99 |             [
100 |                 /**
101 |                  * Path to protoc-gen-php-grpc library.
102 |                  */
103 |                 'binaryPath' => null,
104 |                 'generatedPath' => null,
105 |                 'namespace' => null,
106 |                 'servicesBasePath' => null,
107 |                 'services' => [],
108 |                 'interceptors' => [],
109 |                 'generators' => [],
110 |                 'client' => [
111 |                     'interceptors' => [],
112 |                 ],
113 |             ],
114 |         );
115 |     }
116 | 
117 |     /**
118 |      * @psalm-suppress DeprecatedInterface
119 |      */
120 |     private function initInvoker(
121 |         GRPCConfig $config,
122 |         #[Proxy] ContainerInterface $container,
123 |         FactoryInterface $factory,
124 |         ?PipelineBuilderInterface $pipelineBuilder = null,
125 |     ): InvokerInterface {
126 |         /** @var PipelineBuilderInterface $pipelineBuilder */
127 |         $pipelineBuilder ??= $container->get(CompatiblePipelineBuilder::class);
128 | 
129 |         $handler = new AutowireHandler($container, false);
130 | 
131 |         /**
132 |          * @var list<InterceptorInterface|CoreInterceptorInterface> $list
133 |          * @var ContainerInterface $c
134 |          * @var FactoryInterface $f
135 |          */
136 |         $list = [];
137 |         $c = $container->get(ContainerInterface::class);
138 |         $f = $c->get(FactoryInterface::class);
139 |         foreach ($config->getInterceptors() as $interceptor) {
140 |             $list[] = $this->resolve($interceptor, $c, $factory);
141 |         }
142 | 
143 |         return $f->make(Invoker::class, [
144 |             'handler' => $pipelineBuilder->withInterceptors(...$list)->build($handler),
145 |         ]);
146 |     }
147 | 
148 |     private function initProtoFilesRepository(GRPCConfig $config): ProtoFilesRepositoryInterface
149 |     {
150 |         return new FileRepository($config->getServices());
151 |     }
152 | 
153 |     private function initGeneratorRegistry(
154 |         GRPCConfig $config,
155 |         ContainerInterface $container,
156 |         FactoryInterface $factory,
157 |     ): GeneratorRegistryInterface {
158 |         $registry = new GeneratorRegistry();
159 |         foreach ($config->getGenerators() as $generator) {
160 |             $generator = $this->resolve($generator, $container, $factory);
161 | 
162 |             \assert($generator instanceof GeneratorInterface);
163 | 
164 |             $registry->addGenerator($generator);
165 |         }
166 | 
167 |         return $registry;
168 |     }
169 | 
170 |     private function resolve(mixed $dependency, ContainerInterface $container, FactoryInterface $factory): object
171 |     {
172 |         return match (true) {
173 |             \is_string($dependency) => $container->get($dependency),
174 |             $dependency instanceof Autowire => $dependency->resolve($factory),
175 |             default => $dependency,
176 |         };
177 |     }
178 | }
179 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # RoadRunner bridge to Spiral Framework
  2 | 
  3 | [![PHP Version Require](https://poser.pugx.org/spiral/roadrunner-bridge/require/php)](https://packagist.org/packages/spiral/roadrunner-bridge)
  4 | [![Latest Stable Version](https://poser.pugx.org/spiral/roadrunner-bridge/v/stable)](https://packagist.org/packages/spiral/roadrunner-bridge)
  5 | [![phpunit](https://github.com/spiral/roadrunner-bridge/actions/workflows/phpunit.yml/badge.svg)](https://github.com/spiral/roadrunner-bridge/actions)
  6 | [![psalm](https://github.com/spiral/roadrunner-bridge/actions/workflows/psalm.yml/badge.svg)](https://github.com/spiral/roadrunner-bridge/actions)
  7 | [![Codecov](https://codecov.io/gh/spiral/roadrunner-bridge/branch/master/graph/badge.svg)](https://codecov.io/gh/spiral/roadrunner-bridge/)
  8 | [![Total Downloads](https://poser.pugx.org/spiral/roadrunner-bridge/downloads)](https://packagist.org/packages/spiral/roadrunner-bridge)
  9 | <a href="https://discord.gg/8bZsjYhVVk"><img src="https://img.shields.io/badge/discord-chat-magenta.svg"></a>
 10 | 
 11 | ## Requirements
 12 | 
 13 | Make sure that your server is configured with following PHP version and extensions:
 14 | 
 15 | - PHP 8.1+
 16 | - Spiral Framework 3.14+
 17 | - Extension `protobuf` (recommended)
 18 | 
 19 | ## Installation
 20 | 
 21 | To install the package:
 22 | 
 23 | ```bash
 24 | composer require spiral/roadrunner-bridge
 25 | ```
 26 | 
 27 | After package install you need to add bootloaders from the package in your application on the top of the list.
 28 | 
 29 | ```php
 30 | use Spiral\RoadRunnerBridge\Bootloader as RoadRunnerBridge;
 31 | 
 32 | protected const LOAD = [
 33 |     RoadRunnerBridge\HttpBootloader::class, // Optional, if it needs to work with http plugin
 34 |     RoadRunnerBridge\QueueBootloader::class, // Optional, if it needs to work with jobs plugin
 35 |     RoadRunnerBridge\CacheBootloader::class, // Optional, if it needs to work with KV plugin
 36 |     RoadRunnerBridge\GRPCBootloader::class, // Optional, if it needs to work with GRPC plugin
 37 |     RoadRunnerBridge\CentrifugoBootloader::class, // Optional, if it needs to work with centrifugo server
 38 |     RoadRunnerBridge\TcpBootloader::class, // Optional, if it needs to work with TCP plugin
 39 |     RoadRunnerBridge\MetricsBootloader::class, // Optional, if it needs to work with metrics plugin
 40 |     RoadRunnerBridge\LoggerBootloader::class, // Optional, if it needs to work with app-logger plugin
 41 |     RoadRunnerBridge\LockBootloader::class, // Optional, if it needs to work with lock plugin
 42 |     RoadRunnerBridge\ScaffolderBootloader::class, // Optional, to generate Centrifugo handlers and TCP services via Scaffolder
 43 |     RoadRunnerBridge\CommandBootloader::class,
 44 |     // ...
 45 | ];
 46 | ```
 47 | 
 48 | ## Usage
 49 | 
 50 | - [Cache](https://spiral.dev/docs/basics-cache)
 51 | - [Queue](https://spiral.dev/docs/queue-configuration)
 52 | - [GRPC](https://spiral.dev/docs/grpc-configuration)
 53 | - [Websockets](https://spiral.dev/docs/websockets-configuration)
 54 | - [Logger](https://spiral.dev/docs/basics-logging/#roadrunner-handler)
 55 | - [Metrics](https://spiral.dev/docs/advanced-prometheus-metrics)
 56 | - [TCP](#tcp)
 57 |     - [Configuration](#configuration-2)
 58 |     - [Services](#services)
 59 | 
 60 | ### TCP
 61 | 
 62 | RoadRunner includes TCP server and can be used to replace classic TCP setup with much greater performance and
 63 | flexibility.
 64 | 
 65 | #### Bootloader
 66 | 
 67 | Add `Spiral\RoadRunnerBridge\Bootloader\TcpBootloader` to application bootloaders list:
 68 | 
 69 | ```php
 70 | use Spiral\RoadRunnerBridge\Bootloader as RoadRunnerBridge;
 71 | 
 72 | protected const LOAD = [
 73 |     // ...
 74 |     RoadRunnerBridge\TcpBootloader::class,
 75 |     // ...
 76 | ];
 77 | ```
 78 | 
 79 | This bootloader adds a dispatcher and necessary services for TCP to work.
 80 | Also, using the `addService` and `addInterceptors` methods can dynamically add services to TCP servers and configure
 81 | interceptors.
 82 | 
 83 | #### Configuration
 84 | 
 85 | Configure `tcp` section in the RoadRunner `.rr.yaml` configuration file with needed TCP servers. Example:
 86 | 
 87 | ```yaml
 88 | tcp:
 89 |   servers:
 90 |     smtp:
 91 |       addr: tcp://127.0.0.1:22
 92 |       delimiter: "\r\n" # by default
 93 |     monolog:
 94 |       addr: tcp://127.0.0.1:9913
 95 | 
 96 |   pool:
 97 |     num_workers: 2
 98 |     max_jobs: 0
 99 |     allocate_timeout: 60s
100 |     destroy_timeout: 60s
101 | ```
102 | 
103 | Create configuration file `app/config/tcp.php`. In the configuration, it's required to specify the services that
104 | will handle requests from a specific TCP server. Optionally, interceptors can be added for each specific server.
105 | With the help there, can add some logic before handling the request in service. Configuration example:
106 | 
107 | ```php
108 | <?php
109 | 
110 | declare(strict_types=1);
111 | 
112 | return [
113 |     /**
114 |      * Services for each server.
115 |      */
116 |     'services' => [
117 |         'smtp' => SomeService::class,
118 |         'monolog' => OtherService::class
119 |     ],
120 | 
121 |     /**
122 |      * Interceptors, this section is optional.
123 |      * @see https://spiral.dev/docs/cookbook-domain-core/2.8/en#core-interceptors
124 |      */
125 |     'interceptors' => [
126 |         // several interceptors
127 |         'smtp' => [
128 |             SomeInterceptor::class,
129 |             OtherInterceptor::class
130 |         ],
131 |         'monolog' => SomeInterceptor::class // one interceptor
132 |     ],
133 | 
134 |     'debug' => env('TCP_DEBUG', false)
135 | ];
136 | ```
137 | 
138 | #### Services
139 | 
140 | A service must implement the interface `Spiral\RoadRunnerBridge\Tcp\Service\ServiceInterface` with one required
141 | method `handle`.
142 | After processing a request, the `handle` method must return the `Spiral\RoadRunnerBridge\Tcp\Response\ResponseInterface`
143 | object
144 | with result (`RespondMessage`, `CloseConnection`, `ContinueRead`).
145 | 
146 | Example:
147 | 
148 | ```php
149 | <?php
150 | 
151 | declare(strict_types=1);
152 | 
153 | namespace App\Tcp\Service;
154 | 
155 | use Spiral\RoadRunner\Tcp\Request;
156 | use Spiral\RoadRunnerBridge\Tcp\Response\RespondMessage;
157 | use Spiral\RoadRunnerBridge\Tcp\Response\ResponseInterface;
158 | use Spiral\RoadRunnerBridge\Tcp\Service\ServiceInterface;
159 | 
160 | class TestService implements ServiceInterface
161 | {
162 |     public function handle(Request $request): ResponseInterface
163 |     {
164 |         // some logic
165 | 
166 |         return new RespondMessage('some message', true);
167 |     }
168 | }
169 | ```
170 | 
171 | The service can be generated using the **Scaffolder** component. Make sure that bootloader
172 | `Spiral\RoadRunnerBridge\Bootloader\ScaffolderBootloader` is added in your application and run:
173 | 
174 | ```bash
175 | php app.php create:tcp-service Test
176 | ```
177 | 
178 | This will generate service **TestService** in the folder **Endpoint/Tcp/Service/TestService.php**.
179 | 
180 | > **Note**
181 | > Namespace (and generation path) can be configured.
182 | > Read more about [Scaffolder component](https://spiral.dev/docs/basics-scaffolding).
183 | 
184 | ----
185 | 
186 | > **Note**
187 | > Read more about RoadRunner configuration on official site https://roadrunner.dev.
188 | 
189 | ## License:
190 | 
191 | MIT License (MIT). Please see [`LICENSE`](./LICENSE) for more information. Maintained by [Spiral Scout](https://spiralscout.com).
192 | 


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