Portiny\RabbitMQ\BunnyManager

Complexity

Total Complexity

19

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

27.78%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setLoop()	0	4	1
A	getClient()	0	12	3
A	getChannel()	0	8	2
A	getClassNameByAlias()	0	4	1
A	declare()	0	26	3
A	createChannel()	0	16	3
A	declareExchanges()	0	14	3
A	declareQueues()	0	8	2

<?php declare(strict_types=1);

namespace Portiny\RabbitMQ;

use Bunny\Async\Client as AsyncClient;
use Bunny\Channel;
use Bunny\Client;
use Nette\DI\Container;
use Portiny\RabbitMQ\Exchange\AbstractExchange;
use Portiny\RabbitMQ\Queue\AbstractQueue;
use React\EventLoop\LoopInterface;
use React\Promise\PromiseInterface;

final class BunnyManager
{
	/**
	 * @var array
	 */
	private $config = [];

	/**
	 * @var bool
	 */
	private $isDeclared = FALSE;

	/**
	 * @var Container
	 */
	private $container;

	/**
	 * @var LoopInterface
	 */
	private $loop;

	/**
	 * @var Client|AsyncClient|null
	 */
	private $client;

	/**
	 * @var Channel|PromiseInterface|null
	 */
	private $channel;

	public function __construct(Container $container, array $config)
	{
		$this->container = $container;
		$this->config = $config;
	}

	public function setLoop(LoopInterface $loop): void
	{
		$this->loop = $loop;
	}

	/**
	 * @return Client|AsyncClient
	 */
	public function getClient()
	{
		if ($this->client === null) {
			if ($this->loop === NULL) {
				$this->client = new Client($this->config['connection']);
			} else {
				$this->client = new AsyncClient($this->loop, $this->config['connection']);
			}
		}

		return $this->client;
	}

	/**
	 * @return Channel|PromiseInterface
	 */
	public function getChannel()
	{
		if ($this->channel === null) {
			$this->channel = $this->createChannel();
		}

		return $this->channel;
	}

	public function getClassNameByAlias(string $alias): ?string
	{
		return $this->config['aliases'][$alias] ?? null;
	}

	/**
	 * @return bool|PromiseInterface
	 */
	public function declare()
	{
		if ($this->isDeclared) {
			return false;
		}

		$channel = $this->getChannel();

		if ($channel instanceof PromiseInterface) {

The class React\Promise\PromiseInterface does not exist. Did you forget a USE statement, or did you not list all dependencies?

			$this->isDeclared = true;

			return $channel->then(function (Channel $channel) {
				$this->declareExchanges($channel);
				$this->declareQueues($channel);

				return true;
			});
		}

		$this->declareExchanges($channel);
		$this->declareQueues($channel);

		$this->isDeclared = true;

		return true;
	}

	/**
	 * @return Channel|PromiseInterface
	 */
	private function createChannel()
	{
		$client = $this->getClient();

		if (! $client->isConnected()) {
			if ($client instanceof AsyncClient) {

The class Bunny\Async\Client does not exist. Did you forget a USE statement, or did you not list all dependencies?

				return $client->connect()->then(function (AsyncClient $client) {
					return $client->channel();
				});
			}

			$client->connect();
		}

		return $client->channel();
	}

	private function declareExchanges(Channel $channel): void
	{
		foreach ($this->config['exchanges'] as $exchangeClassName) {
			/** @var AbstractExchange $exchange */
			$exchange = $this->container->getByType($exchangeClassName);
			$exchange->declare($channel);
		}

		foreach ($this->config['exchanges'] as $exchangeClassName) {
			/** @var AbstractExchange $exchange */
			$exchange = $this->container->getByType($exchangeClassName);
			$exchange->declareBindings($channel);
		}
	}

	private function declareQueues(Channel $channel): void
	{
		foreach ($this->config['queues'] as $queueClassName) {
			/** @var AbstractQueue $queue */
			$queue = $this->container->getByType($queueClassName);
			$queue->declare($channel);
		}
	}
}