Spiral\Queue\QueueManager

Complexity

Total Complexity

9

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Test Coverage

Coverage

55.88%

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	getConnection()	0	11	2
A	getDefaultDriver()	0	3	1
A	__construct()	0	6	1
A	resolveConnection()	0	32	5

<?php

declare(strict_types=1);

namespace Spiral\Queue;

use Psr\Container\ContainerInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Spiral\Core\Container\Autowire;
use Spiral\Core\CoreInterceptorInterface;
use Spiral\Core\Exception\Container\ContainerException;
use Spiral\Core\FactoryInterface;
use Spiral\Core\InterceptableCore;
use Spiral\Queue\Config\QueueConfig;
use Spiral\Queue\Interceptor\Push\Core as PushCore;

final class QueueManager implements QueueConnectionProviderInterface
{
    /** @var QueueInterface[] */
    private array $pipelines = [];

    public function __construct(
        private readonly QueueConfig $config,
        private readonly ContainerInterface $container,
        private readonly FactoryInterface $factory,
        private readonly ?EventDispatcherInterface $dispatcher = null
    ) {
    }

    public function getConnection(?string $name = null): QueueInterface
    {
        $name ??= $this->getDefaultDriver();
        // Replaces alias with real pipeline name
        $name = $this->config->getAliases()[$name] ?? $name;

        if (!isset($this->pipelines[$name])) {
            $this->pipelines[$name] = $this->resolveConnection($name);
        }

        return $this->pipelines[$name];
    }

    /**
     * @throws Exception\InvalidArgumentException
     * @throws Exception\NotSupportedDriverException
     */
    private function resolveConnection(string $name): QueueInterface
    {
        $config = $this->config->getConnection($name);

        try {
            $driver = $this->factory->make($config['driver'], $config);

            $core = new InterceptableCore(
                new PushCore($driver),
                $this->dispatcher
            );

            foreach ($this->config->getPushInterceptors() as $interceptor) {
                if (\is_string($interceptor) || $interceptor instanceof Autowire) {
                    $interceptor = $this->container->get($interceptor);

It seems like $interceptor can also be of type Spiral\Core\Container\Autowire; however, parameter $id of Psr\Container\ContainerInterface::get() does only seem to accept string, maybe add an additional type check?

                }

                \assert($interceptor instanceof CoreInterceptorInterface);
                $core->addInterceptor($interceptor);
            }

            return new Queue($core);
        } catch (ContainerException $e) {
            throw new Exception\NotSupportedDriverException(
                \sprintf(
                    'Driver `%s` is not supported. Connection `%s` cannot be created. Reason: `%s`',
                    $config['driver'],
                    $name,
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        }
    }

    /**
     * @throws Exception\InvalidArgumentException
     */
    private function getDefaultDriver(): string
    {
        return $this->config->getDefaultDriver();
    }
}