SonataNotificationExtension::configureClass() - Code Metrics - Inspection of "Refactor bundle configuration to create recipe for..." - sonata-project/SonataNotificationBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 3.x (#314)

by Andrey F.

created 2018-02-09 22:45 UTC

SonataNotificationExtension::configureClass() A

↳ Parent: SonataNotificationExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	2

<?php

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\NotificationBundle\DependencyInjection;

use Sonata\EasyExtendsBundle\Mapper\DoctrineCollector;
use Sonata\NotificationBundle\Backend\AMQPBackend;
use Sonata\NotificationBundle\Backend\MessageManagerBackend;
use Sonata\NotificationBundle\Model\MessageInterface;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\Loader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

class SonataNotificationExtension extends Extension
{
    /**
     * @var int
     */
    protected $amqpCounter = 0;

    /**
     * {@inheritdoc}
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configuration = new Configuration();
        $config = $this->processConfiguration($configuration, $configs);

        $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));

        /**
         * @todo check
         */
        $this->checkConfiguration($config);

        /*
         * NEXT_MAJOR: Remove the check for ServiceClosureArgument as well as core_legacy.xml.
         */
        if (class_exists(ServiceClosureArgument::class)) {
            $loader->load('core.xml');
        } else {
            $loader->load('core_legacy.xml');
        }

        $loader->load('backend.xml');
        $loader->load('consumer.xml');

        if ('sonata.notification.backend.doctrine' === $config['backend']) {
            $loader->load('doctrine_orm.xml');
            $loader->load('selector.xml');
            $loader->load('event.xml');
        }

        if ($config['consumers']['register_default']) {
            $loader->load('default_consumers.xml');
        }

        $bundles = $container->getParameter('kernel.bundles');

        if (isset($bundles['FOSRestBundle'], $bundles['NelmioApiDocBundle'])) {
            $loader->load('api_controllers.xml');
            $loader->load('api_form.xml');
        }

        // for now, only support for ORM
        if ($config['admin']['enabled'] && isset($bundles['SonataDoctrineORMAdminBundle'])) {
            $loader->load('admin.xml');
        }

        if (isset($bundles['LiipMonitorBundle'])) {
            $loader->load('checkmonitor.xml');
        }

        $container->setAlias('sonata.notification.backend', $config['backend']);
        // NEXT_MAJOR: remove this getter when requiring sf3.4+
        $container->getAlias('sonata.notification.backend')->setPublic(true);
        $container->setParameter('sonata.notification.backend', $config['backend']);

        $this->registerDoctrineMapping($config);
        $this->registerParameters($container, $config);
        $this->configureBackends($container, $config);
        $this->configureClass($container, $config);
        $this->configureListeners($container, $config);
        $this->configureAdmin($container, $config);
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    public function configureClass(ContainerBuilder $container, $config)
    {
        // admin configuration
        $container->setParameter('sonata.notification.admin.message.entity', $config['class']['message']);

        // manager configuration
        $container->setParameter('sonata.notification.manager.message.entity', $config['class']['message']);
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    public function configureAdmin(ContainerBuilder $container, $config)
    {
        $container->setParameter('sonata.notification.admin.message.class', $config['admin']['message']['class']);
        $container->setParameter('sonata.notification.admin.message.controller', $config['admin']['message']['controller']);
        $container->setParameter('sonata.notification.admin.message.translation_domain', $config['admin']['message']['translation']);
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    public function registerParameters(ContainerBuilder $container, $config)
    {
        $container->setParameter('sonata.notification.message.class', $config['class']['message']);
        $container->setParameter('sonata.notification.admin.message.entity', $config['class']['message']);
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    public function configureBackends(ContainerBuilder $container, $config)
    {
        if (isset($config['backends']['rabbitmq']) && 'sonata.notification.backend.rabbitmq' === $config['backend']) {
            $this->configureRabbitmq($container, $config);
        } else {
            $container->removeDefinition('sonata.notification.backend.rabbitmq');
        }

        if (isset($config['backends']['doctrine']) && 'sonata.notification.backend.doctrine' === $config['backend']) {
            $checkLevel = [
                MessageInterface::STATE_DONE => $config['backends']['doctrine']['states']['done'],
                MessageInterface::STATE_ERROR => $config['backends']['doctrine']['states']['error'],
                MessageInterface::STATE_IN_PROGRESS => $config['backends']['doctrine']['states']['in_progress'],
                MessageInterface::STATE_OPEN => $config['backends']['doctrine']['states']['open'],
            ];

            $pause = $config['backends']['doctrine']['pause'];
            $maxAge = $config['backends']['doctrine']['max_age'];
            $batchSize = $config['backends']['doctrine']['batch_size'];
            $container->setAlias('sonata.notification.manager.message', $config['backends']['doctrine']['message_manager']);

            $this->configureDoctrineBackends($container, $config, $checkLevel, $pause, $maxAge, $batchSize);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

            // NEXT_MAJOR: remove this getter when requiring sf3.4+
            $container->getAlias('sonata.notification.manager.message')->setPublic(true);
        } else {
            $container->removeDefinition('sonata.notification.backend.doctrine');
        }
    }

    /**
     * @param array $config
     */
    public function registerDoctrineMapping(array $config)
    {
        $collector = DoctrineCollector::getInstance();

        $collector->addIndex($config['class']['message'], 'idx_state', [
            'state',
        ]);

        $collector->addIndex($config['class']['message'], 'idx_created_at', [
            'created_at',
        ]);
    }

    /**
     * @param array $config
     */
    protected function checkConfiguration(array $config)
    {
        if (isset($config['backends']) && count($config['backends']) > 1) {
            throw new \RuntimeException('more than one backend configured, you can have only one backend configuration');
        }

        if (!isset($config['backends']['rabbitmq']) && 'sonata.notification.backend.rabbitmq' === $config['backend']) {
            throw new \RuntimeException('Please configure the sonata_notification.backends.rabbitmq section');
        }

        if (!isset($config['backends']['doctrine']) && 'sonata.notification.backend.doctrine' === $config['backend']) {
            throw new \RuntimeException('Please configure the sonata_notification.backends.doctrine section');
        }
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    protected function configureListeners(ContainerBuilder $container, array $config)
    {
        $ids = $config['iteration_listeners'];

        if ('sonata.notification.backend.doctrine' === $config['backend']) {
            // this one clean the unit of work after every iteration
            $ids[] = 'sonata.notification.event.doctrine_optimize';

            if ($config['backends']['doctrine']['batch_size'] > 1) {
                // if the backend is doctrine and the batch size > 1, then
                // the unit of work must be cleaned wisely to avoid any issue
                // while persisting entities
                $ids = [
                    'sonata.notification.event.doctrine_backend_optimize',
                ];
            }
        }

        $container->setParameter('sonata.notification.event.iteration_listeners', $ids);
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     * @param bool             $checkLevel
     * @param int              $pause
     * @param int              $maxAge
     * @param int              $batchSize
     *
     * @throws \RuntimeException
     */
    protected function configureDoctrineBackends(ContainerBuilder $container, array $config, $checkLevel, $pause, $maxAge, $batchSize)
    {
        $queues = $config['queues'];
        $qBackends = [];

        $definition = $container->getDefinition('sonata.notification.backend.doctrine');

        // no queue defined, set a default one
        if (0 == count($queues)) {
            $queues = [[
                'queue' => 'default',
                'default' => true,
                'types' => [],
            ]];
        }

        $defaultSet = false;
        $declaredQueues = [];

        foreach ($queues as $pos => &$queue) {
            if (in_array($queue['queue'], $declaredQueues)) {
                throw new \RuntimeException('The doctrine backend does not support 2 identicals queue name, please rename one queue');
            }

            $declaredQueues[] = $queue['queue'];

            // make the configuration compatible with old code and rabbitmq
            if (isset($queue['routing_key']) && strlen($queue['routing_key']) > 0) {
                $queue['types'] = [$queue['routing_key']];
            }

            if (empty($queue['types']) && false === $queue['default']) {
                throw new \RuntimeException('You cannot declared a doctrine queue with no type defined with default = false');
            }

            if (!empty($queue['types']) && true === $queue['default']) {
                throw new \RuntimeException('You cannot declared a doctrine queue with types defined with default = true');
            }

            $id = $this->createDoctrineQueueBackend($container, $definition->getArgument(0), $checkLevel, $pause, $maxAge, $batchSize, $queue['queue'], $queue['types']);
            $qBackends[$pos] = [
                'types' => $queue['types'],
                'backend' => new Reference($id),
            ];

            if (true === $queue['default']) {
                if (true === $defaultSet) {
                    throw new \RuntimeException('You can only set one doctrine default queue in your sonata notification configuration.');
                }

                $defaultSet = true;
                $defaultQueue = $queue['queue'];
            }
        }

        if (false === $defaultSet) {
            throw new \RuntimeException('You need to specify a valid default queue for the doctrine backend!');
        }

        $definition
            ->replaceArgument(1, $queues)
            ->replaceArgument(2, $defaultQueue)
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            ->replaceArgument(3, $qBackends)
        ;
    }

    /**
     * @param ContainerBuilder $container
     * @param string           $manager
     * @param bool             $checkLevel
     * @param int              $pause
     * @param int              $maxAge
     * @param int              $batchSize
     * @param string           $key
     * @param array            $types
     *
     * @return string
     */
    protected function createDoctrineQueueBackend(ContainerBuilder $container, $manager, $checkLevel, $pause, $maxAge, $batchSize, $key, array $types = [])
    {
        if ('' == $key) {
            $id = 'sonata.notification.backend.doctrine.default_'.$this->amqpCounter++;
        } else {
            $id = 'sonata.notification.backend.doctrine.'.$key;
        }

        $definition = new Definition(MessageManagerBackend::class, [$manager, $checkLevel, $pause, $maxAge, $batchSize, $types]);
        $definition->setPublic(false);

        $container->setDefinition($id, $definition);

        return $id;
    }

    /**
     * @param ContainerBuilder $container
     * @param array            $config
     */
    protected function configureRabbitmq(ContainerBuilder $container, array $config)
    {
        $queues = $config['queues'];
        $connection = $config['backends']['rabbitmq']['connection'];
        $baseExchange = $config['backends']['rabbitmq']['exchange'];
        $amqBackends = [];

        if (0 == count($queues)) {
            $queues = [[
                'queue' => 'default',
                'default' => true,
                'routing_key' => '',
                'recover' => false,
                'dead_letter_exchange' => null,
                'dead_letter_routing_key' => null,
                'ttl' => null,
                'prefetch_count' => null,
            ]];
        }

        $deadLetterRoutingKeys = $this->getQueuesParameters('dead_letter_routing_key', $queues);
        $routingKeys = $this->getQueuesParameters('routing_key', $queues);

        foreach ($deadLetterRoutingKeys as $key) {
            if (!in_array($key, $routingKeys)) {
                throw new \RuntimeException(sprintf(
                    'You must configure the queue having the routing_key "%s" same as dead_letter_routing_key', $key
                ));
            }
        }

        $declaredQueues = [];

        $defaultSet = false;
        foreach ($queues as $pos => $queue) {
            if (in_array($queue['queue'], $declaredQueues)) {
                throw new \RuntimeException('The RabbitMQ backend does not support 2 identicals queue name, please rename one queue');
            }

            $declaredQueues[] = $queue['queue'];

            if ($queue['dead_letter_routing_key']) {
                if (null === $queue['dead_letter_exchange']) {
                    throw new \RuntimeException(
                        'dead_letter_exchange must be configured when dead_letter_routing_key is set'
                    );
                }
            }

            if (in_array($queue['routing_key'], $deadLetterRoutingKeys)) {
                $exchange = $this->getAMQPDeadLetterExchangeByRoutingKey($queue['routing_key'], $queues);
            } else {
                $exchange = $baseExchange;
            }

            $id = $this->createAMQPBackend(
                $container,
                $exchange,
                $queue['queue'],
                $queue['recover'],
                $queue['routing_key'],
                $queue['dead_letter_exchange'],
                $queue['dead_letter_routing_key'],
                $queue['ttl'],
                $queue['prefetch_count']
            );

            $amqBackends[$pos] = [
                'type' => $queue['routing_key'],
                'backend' => new Reference($id),
            ];

            if (true === $queue['default']) {
                if (true === $defaultSet) {
                    throw new \RuntimeException('You can only set one rabbitmq default queue in your sonata notification configuration.');
                }
                $defaultSet = true;
                $defaultQueue = $queue['routing_key'];
            }
        }

        if (false === $defaultSet) {
            throw new \RuntimeException('You need to specify a valid default queue for the rabbitmq backend!');
        }

        $container->getDefinition('sonata.notification.backend.rabbitmq')
            ->replaceArgument(0, $connection)
            ->replaceArgument(1, $queues)
            ->replaceArgument(2, $defaultQueue)
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            ->replaceArgument(3, $amqBackends)
        ;
    }

    /**
     * @param ContainerBuilder $container
     * @param string           $exchange
     * @param string           $name
     * @param string           $recover
     * @param string           $key
     * @param string           $deadLetterExchange
     * @param string           $deadLetterRoutingKey
     * @param int|null         $ttl
     * @param int|null         $prefetchCount
     *
     * @return string
     */
    protected function createAMQPBackend(ContainerBuilder $container, $exchange, $name, $recover, $key = '', $deadLetterExchange = null, $deadLetterRoutingKey = null, $ttl = null, $prefetchCount = null)
    {
        $id = 'sonata.notification.backend.rabbitmq.'.$this->amqpCounter++;

        $definition = new Definition(
            AMQPBackend::class,
            [
                $exchange,
                $name,
                $recover,
                $key,
                $deadLetterExchange,
                $deadLetterRoutingKey,
                $ttl,
                $prefetchCount,
            ]
        );
        $definition->setPublic(false);
        $container->setDefinition($id, $definition);

        return $id;
    }

    /**
     * @param string $name
     * @param array  $queues
     *
     * @return string[]
     */
    private function getQueuesParameters($name, array $queues)
    {
        $params = array_unique(array_map(function ($q) use ($name) {
            return $q[$name];
        }, $queues));

        $idx = array_search(null, $params);
        if (false !== $idx) {
            unset($params[$idx]);
        }

        return $params;
    }

    /**
     * @param string $key
     * @param array  $queues
     *
     * @return string
     */
    private function getAMQPDeadLetterExchangeByRoutingKey($key, array $queues)
    {
        foreach ($queues as $queue) {
            if ($queue['dead_letter_routing_key'] === $key) {
                return $queue['dead_letter_exchange'];
            }
        }
    }
}


Pull Request — 3.x (#314)

SonataNotificationExtension::configureClass() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

1			<?php
2
3			/*
4			* This file is part of the Sonata Project package.
5			*
6			* (c) Thomas Rabaix <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sonata\NotificationBundle\DependencyInjection;
13
14			use Sonata\EasyExtendsBundle\Mapper\DoctrineCollector;
15			use Sonata\NotificationBundle\Backend\AMQPBackend;
16			use Sonata\NotificationBundle\Backend\MessageManagerBackend;
17			use Sonata\NotificationBundle\Model\MessageInterface;
18			use Symfony\Component\Config\FileLocator;
19			use Symfony\Component\DependencyInjection\Argument\ServiceClosureArgument;
20			use Symfony\Component\DependencyInjection\ContainerBuilder;
21			use Symfony\Component\DependencyInjection\Definition;
22			use Symfony\Component\DependencyInjection\Loader;
23			use Symfony\Component\DependencyInjection\Reference;
24			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
25
26			class SonataNotificationExtension extends Extension
27			{
28			/**
29			* @var int
30			*/
31			protected $amqpCounter = 0;
32
33			/**
34			* {@inheritdoc}
35			*/
36			public function load(array $configs, ContainerBuilder $container)
37			{
38			$configuration = new Configuration();
39			$config = $this->processConfiguration($configuration, $configs);
40
41			$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
42
43			/**
44			* @todo check
45			*/
46			$this->checkConfiguration($config);
47
48			/*
49			* NEXT_MAJOR: Remove the check for ServiceClosureArgument as well as core_legacy.xml.
50			*/
51			if (class_exists(ServiceClosureArgument::class)) {
52			$loader->load('core.xml');
53			} else {
54			$loader->load('core_legacy.xml');
55			}
56
57			$loader->load('backend.xml');
58			$loader->load('consumer.xml');
59
60			if ('sonata.notification.backend.doctrine' === $config['backend']) {
61			$loader->load('doctrine_orm.xml');
62			$loader->load('selector.xml');
63			$loader->load('event.xml');
64			}
65
66			if ($config['consumers']['register_default']) {
67			$loader->load('default_consumers.xml');
68			}
69
70			$bundles = $container->getParameter('kernel.bundles');
71
72			if (isset($bundles['FOSRestBundle'], $bundles['NelmioApiDocBundle'])) {
73			$loader->load('api_controllers.xml');
74			$loader->load('api_form.xml');
75			}
76
77			// for now, only support for ORM
78			if ($config['admin']['enabled'] && isset($bundles['SonataDoctrineORMAdminBundle'])) {
79			$loader->load('admin.xml');
80			}
81
82			if (isset($bundles['LiipMonitorBundle'])) {
83			$loader->load('checkmonitor.xml');
84			}
85
86			$container->setAlias('sonata.notification.backend', $config['backend']);
87			// NEXT_MAJOR: remove this getter when requiring sf3.4+
88			$container->getAlias('sonata.notification.backend')->setPublic(true);
89			$container->setParameter('sonata.notification.backend', $config['backend']);
90
91			$this->registerDoctrineMapping($config);
92			$this->registerParameters($container, $config);
93			$this->configureBackends($container, $config);
94			$this->configureClass($container, $config);
95			$this->configureListeners($container, $config);
96			$this->configureAdmin($container, $config);
97			}
98
99			/**
100			* @param ContainerBuilder $container
101			* @param array $config
102			*/
103			public function configureClass(ContainerBuilder $container, $config)
104			{
105			// admin configuration
106			$container->setParameter('sonata.notification.admin.message.entity', $config['class']['message']);
107
108			// manager configuration
109			$container->setParameter('sonata.notification.manager.message.entity', $config['class']['message']);
110			}
111
112			/**
113			* @param ContainerBuilder $container
114			* @param array $config
115			*/
116			public function configureAdmin(ContainerBuilder $container, $config)
117			{
118			$container->setParameter('sonata.notification.admin.message.class', $config['admin']['message']['class']);
119			$container->setParameter('sonata.notification.admin.message.controller', $config['admin']['message']['controller']);
120			$container->setParameter('sonata.notification.admin.message.translation_domain', $config['admin']['message']['translation']);
121			}
122
123			/**
124			* @param ContainerBuilder $container
125			* @param array $config
126			*/
127			public function registerParameters(ContainerBuilder $container, $config)
128			{
129			$container->setParameter('sonata.notification.message.class', $config['class']['message']);
130			$container->setParameter('sonata.notification.admin.message.entity', $config['class']['message']);
131			}
132
133			/**
134			* @param ContainerBuilder $container
135			* @param array $config
136			*/
137			public function configureBackends(ContainerBuilder $container, $config)
138			{
139			if (isset($config['backends']['rabbitmq']) && 'sonata.notification.backend.rabbitmq' === $config['backend']) {
140			$this->configureRabbitmq($container, $config);
141			} else {
142			$container->removeDefinition('sonata.notification.backend.rabbitmq');
143			}
144
145			if (isset($config['backends']['doctrine']) && 'sonata.notification.backend.doctrine' === $config['backend']) {
146			$checkLevel = [
147			MessageInterface::STATE_DONE => $config['backends']['doctrine']['states']['done'],
148			MessageInterface::STATE_ERROR => $config['backends']['doctrine']['states']['error'],
149			MessageInterface::STATE_IN_PROGRESS => $config['backends']['doctrine']['states']['in_progress'],
150			MessageInterface::STATE_OPEN => $config['backends']['doctrine']['states']['open'],
151			];
152
153			$pause = $config['backends']['doctrine']['pause'];
154			$maxAge = $config['backends']['doctrine']['max_age'];
155			$batchSize = $config['backends']['doctrine']['batch_size'];
156			$container->setAlias('sonata.notification.manager.message', $config['backends']['doctrine']['message_manager']);
157
158			$this->configureDoctrineBackends($container, $config, $checkLevel, $pause, $maxAge, $batchSize);
			0 ignored issues – show Documentation introduced 2015-11-22 19:11 UTC by Report Bug Copy Issue Report `$checkLevel` is of type `array`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
159
160			// NEXT_MAJOR: remove this getter when requiring sf3.4+
161			$container->getAlias('sonata.notification.manager.message')->setPublic(true);
162			} else {
163			$container->removeDefinition('sonata.notification.backend.doctrine');
164			}
165			}
166
167			/**
168			* @param array $config
169			*/
170			public function registerDoctrineMapping(array $config)
171			{
172			$collector = DoctrineCollector::getInstance();
173
174			$collector->addIndex($config['class']['message'], 'idx_state', [
175			'state',
176			]);
177
178			$collector->addIndex($config['class']['message'], 'idx_created_at', [
179			'created_at',
180			]);
181			}
182
183			/**
184			* @param array $config
185			*/
186			protected function checkConfiguration(array $config)
187			{
188			if (isset($config['backends']) && count($config['backends']) > 1) {
189			throw new \RuntimeException('more than one backend configured, you can have only one backend configuration');
190			}
191
192			if (!isset($config['backends']['rabbitmq']) && 'sonata.notification.backend.rabbitmq' === $config['backend']) {
193			throw new \RuntimeException('Please configure the sonata_notification.backends.rabbitmq section');
194			}
195
196			if (!isset($config['backends']['doctrine']) && 'sonata.notification.backend.doctrine' === $config['backend']) {
197			throw new \RuntimeException('Please configure the sonata_notification.backends.doctrine section');
198			}
199			}
200
201			/**
202			* @param ContainerBuilder $container
203			* @param array $config
204			*/
205			protected function configureListeners(ContainerBuilder $container, array $config)
206			{
207			$ids = $config['iteration_listeners'];
208
209			if ('sonata.notification.backend.doctrine' === $config['backend']) {
210			// this one clean the unit of work after every iteration
211			$ids[] = 'sonata.notification.event.doctrine_optimize';
212
213			if ($config['backends']['doctrine']['batch_size'] > 1) {
214			// if the backend is doctrine and the batch size > 1, then
215			// the unit of work must be cleaned wisely to avoid any issue
216			// while persisting entities
217			$ids = [
218			'sonata.notification.event.doctrine_backend_optimize',
219			];
220			}
221			}
222
223			$container->setParameter('sonata.notification.event.iteration_listeners', $ids);
224			}
225
226			/**
227			* @param ContainerBuilder $container
228			* @param array $config
229			* @param bool $checkLevel
230			* @param int $pause
231			* @param int $maxAge
232			* @param int $batchSize
233			*
234			* @throws \RuntimeException
235			*/
236			protected function configureDoctrineBackends(ContainerBuilder $container, array $config, $checkLevel, $pause, $maxAge, $batchSize)
237			{
238			$queues = $config['queues'];
239			$qBackends = [];
240
241			$definition = $container->getDefinition('sonata.notification.backend.doctrine');
242
243			// no queue defined, set a default one
244			if (0 == count($queues)) {
245			$queues = [[
246			'queue' => 'default',
247			'default' => true,
248			'types' => [],
249			]];
250			}
251
252			$defaultSet = false;
253			$declaredQueues = [];
254
255			foreach ($queues as $pos => &$queue) {
256			if (in_array($queue['queue'], $declaredQueues)) {
257			throw new \RuntimeException('The doctrine backend does not support 2 identicals queue name, please rename one queue');
258			}
259
260			$declaredQueues[] = $queue['queue'];
261
262			// make the configuration compatible with old code and rabbitmq
263			if (isset($queue['routing_key']) && strlen($queue['routing_key']) > 0) {
264			$queue['types'] = [$queue['routing_key']];
265			}
266
267			if (empty($queue['types']) && false === $queue['default']) {
268			throw new \RuntimeException('You cannot declared a doctrine queue with no type defined with default = false');
269			}
270
271			if (!empty($queue['types']) && true === $queue['default']) {
272			throw new \RuntimeException('You cannot declared a doctrine queue with types defined with default = true');
273			}
274
275			$id = $this->createDoctrineQueueBackend($container, $definition->getArgument(0), $checkLevel, $pause, $maxAge, $batchSize, $queue['queue'], $queue['types']);
276			$qBackends[$pos] = [
277			'types' => $queue['types'],
278			'backend' => new Reference($id),
279			];
280
281			if (true === $queue['default']) {
282			if (true === $defaultSet) {
283			throw new \RuntimeException('You can only set one doctrine default queue in your sonata notification configuration.');
284			}
285
286			$defaultSet = true;
287			$defaultQueue = $queue['queue'];
288			}
289			}
290
291			if (false === $defaultSet) {
292			throw new \RuntimeException('You need to specify a valid default queue for the doctrine backend!');
293			}
294
295			$definition
296			->replaceArgument(1, $queues)
297			->replaceArgument(2, $defaultQueue)
			0 ignored issues – show Bug introduced 2017-02-03 07:58 UTC by Report Bug Copy Issue Report The variable `$defaultQueue` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
298			->replaceArgument(3, $qBackends)
299			;
300			}
301
302			/**
303			* @param ContainerBuilder $container
304			* @param string $manager
305			* @param bool $checkLevel
306			* @param int $pause
307			* @param int $maxAge
308			* @param int $batchSize
309			* @param string $key
310			* @param array $types
311			*
312			* @return string
313			*/
314			protected function createDoctrineQueueBackend(ContainerBuilder $container, $manager, $checkLevel, $pause, $maxAge, $batchSize, $key, array $types = [])
315			{
316			if ('' == $key) {
317			$id = 'sonata.notification.backend.doctrine.default_'.$this->amqpCounter++;
318			} else {
319			$id = 'sonata.notification.backend.doctrine.'.$key;
320			}
321
322			$definition = new Definition(MessageManagerBackend::class, [$manager, $checkLevel, $pause, $maxAge, $batchSize, $types]);
323			$definition->setPublic(false);
324
325			$container->setDefinition($id, $definition);
326
327			return $id;
328			}
329
330			/**
331			* @param ContainerBuilder $container
332			* @param array $config
333			*/
334			protected function configureRabbitmq(ContainerBuilder $container, array $config)
335			{
336			$queues = $config['queues'];
337			$connection = $config['backends']['rabbitmq']['connection'];
338			$baseExchange = $config['backends']['rabbitmq']['exchange'];
339			$amqBackends = [];
340
341			if (0 == count($queues)) {
342			$queues = [[
343			'queue' => 'default',
344			'default' => true,
345			'routing_key' => '',
346			'recover' => false,
347			'dead_letter_exchange' => null,
348			'dead_letter_routing_key' => null,
349			'ttl' => null,
350			'prefetch_count' => null,
351			]];
352			}
353
354			$deadLetterRoutingKeys = $this->getQueuesParameters('dead_letter_routing_key', $queues);
355			$routingKeys = $this->getQueuesParameters('routing_key', $queues);
356
357			foreach ($deadLetterRoutingKeys as $key) {
358			if (!in_array($key, $routingKeys)) {
359			throw new \RuntimeException(sprintf(
360			'You must configure the queue having the routing_key "%s" same as dead_letter_routing_key', $key
361			));
362			}
363			}
364
365			$declaredQueues = [];
366
367			$defaultSet = false;
368			foreach ($queues as $pos => $queue) {
369			if (in_array($queue['queue'], $declaredQueues)) {
370			throw new \RuntimeException('The RabbitMQ backend does not support 2 identicals queue name, please rename one queue');
371			}
372
373			$declaredQueues[] = $queue['queue'];
374
375			if ($queue['dead_letter_routing_key']) {
376			if (null === $queue['dead_letter_exchange']) {
377			throw new \RuntimeException(
378			'dead_letter_exchange must be configured when dead_letter_routing_key is set'
379			);
380			}
381			}
382
383			if (in_array($queue['routing_key'], $deadLetterRoutingKeys)) {
384			$exchange = $this->getAMQPDeadLetterExchangeByRoutingKey($queue['routing_key'], $queues);
385			} else {
386			$exchange = $baseExchange;
387			}
388
389			$id = $this->createAMQPBackend(
390			$container,
391			$exchange,
392			$queue['queue'],
393			$queue['recover'],
394			$queue['routing_key'],
395			$queue['dead_letter_exchange'],
396			$queue['dead_letter_routing_key'],
397			$queue['ttl'],
398			$queue['prefetch_count']
399			);
400
401			$amqBackends[$pos] = [
402			'type' => $queue['routing_key'],
403			'backend' => new Reference($id),
404			];
405
406			if (true === $queue['default']) {
407			if (true === $defaultSet) {
408			throw new \RuntimeException('You can only set one rabbitmq default queue in your sonata notification configuration.');
409			}
410			$defaultSet = true;
411			$defaultQueue = $queue['routing_key'];
412			}
413			}
414
415			if (false === $defaultSet) {
416			throw new \RuntimeException('You need to specify a valid default queue for the rabbitmq backend!');
417			}
418
419			$container->getDefinition('sonata.notification.backend.rabbitmq')
420			->replaceArgument(0, $connection)
421			->replaceArgument(1, $queues)
422			->replaceArgument(2, $defaultQueue)
			0 ignored issues – show Bug introduced 2017-02-03 07:58 UTC by Report Bug Copy Issue Report The variable `$defaultQueue` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
423			->replaceArgument(3, $amqBackends)
424			;
425			}
426
427			/**
428			* @param ContainerBuilder $container
429			* @param string $exchange
430			* @param string $name
431			* @param string $recover
432			* @param string $key
433			* @param string $deadLetterExchange
434			* @param string $deadLetterRoutingKey
435			* @param int\|null $ttl
436			* @param int\|null $prefetchCount
437			*
438			* @return string
439			*/
440			protected function createAMQPBackend(ContainerBuilder $container, $exchange, $name, $recover, $key = '', $deadLetterExchange = null, $deadLetterRoutingKey = null, $ttl = null, $prefetchCount = null)
441			{
442			$id = 'sonata.notification.backend.rabbitmq.'.$this->amqpCounter++;
443
444			$definition = new Definition(
445			AMQPBackend::class,
446			[
447			$exchange,
448			$name,
449			$recover,
450			$key,
451			$deadLetterExchange,
452			$deadLetterRoutingKey,
453			$ttl,
454			$prefetchCount,
455			]
456			);
457			$definition->setPublic(false);
458			$container->setDefinition($id, $definition);
459
460			return $id;
461			}
462
463			/**
464			* @param string $name
465			* @param array $queues
466			*
467			* @return string[]
468			*/
469			private function getQueuesParameters($name, array $queues)
470			{
471			$params = array_unique(array_map(function ($q) use ($name) {
472			return $q[$name];
473			}, $queues));
474
475			$idx = array_search(null, $params);
476			if (false !== $idx) {
477			unset($params[$idx]);
478			}
479
480			return $params;
481			}
482
483			/**
484			* @param string $key
485			* @param array $queues
486			*
487			* @return string
488			*/
489			private function getAMQPDeadLetterExchangeByRoutingKey($key, array $queues)
490			{
491			foreach ($queues as $queue) {
492			if ($queue['dead_letter_routing_key'] === $key) {
493			return $queue['dead_letter_exchange'];
494			}
495			}
496			}
497			}
498

sonata-project / SonataNotificationBundle

Pull Request — 3.x (#314)

SonataNotificationExtension::configureClass() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like