├── .styleci.yml
├── BernardBundle.php
├── Collector
    └── ProducerCollector.php
├── Command
    └── DebugCommand.php
├── DependencyInjection
    ├── BernardExtension.php
    ├── Compiler
    │   ├── NormalizerPass.php
    │   └── ReceiverPass.php
    └── Configuration.php
├── EventListener
    └── SchemaListener.php
├── LICENSE
├── Normalizer
    └── DefaultMessageNormalizer.php
├── README.md
├── Resources
    ├── config
    │   ├── collector.xml
    │   ├── commands.xml
    │   └── services.xml
    └── views
    │   ├── Collector
    │       └── producer.html.twig
    │   └── Icon
    │       └── bernard.svg
├── Tests
    └── DependencyInjection
    │   ├── BernardExtensionTest.php
    │   ├── Compiler
    │       ├── NormalizerPassTest.php
    │       └── ReceiverPassTest.php
    │   └── ConfigurationTest.php
└── composer.json


/.styleci.yml:
--------------------------------------------------------------------------------
1 | preset: symfony
2 | risky: false
3 | 
4 | disabled:
5 |     - yoda_style
6 | 


--------------------------------------------------------------------------------
/BernardBundle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle;
 4 | 
 5 | use Bernard\BernardBundle\DependencyInjection\Compiler\NormalizerPass;
 6 | use Bernard\BernardBundle\DependencyInjection\Compiler\ReceiverPass;
 7 | use Symfony\Component\Console\Application;
 8 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 9 | use Symfony\Component\HttpKernel\Bundle\Bundle;
10 | 
11 | class BernardBundle extends Bundle
12 | {
13 |     public function build(ContainerBuilder $builder)
14 |     {
15 |         $builder
16 |             ->addCompilerPass(new ReceiverPass())
17 |             ->addCompilerPass(new NormalizerPass())
18 |         ;
19 |     }
20 | 
21 |     public function registerCommands(Application $application)
22 |     {
23 |         parent::registerCommands($application);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Collector/ProducerCollector.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\Collector;
 4 | 
 5 | use Bernard\BernardEvents;
 6 | use Bernard\Event\EnvelopeEvent;
 7 | use Symfony\Component\EventDispatcher\EventSubscriberInterface;
 8 | use Symfony\Component\HttpFoundation\Request;
 9 | use Symfony\Component\HttpFoundation\Response;
10 | use Symfony\Component\HttpKernel\DataCollector\DataCollector;
11 | 
12 | class ProducerCollector extends DataCollector implements EventSubscriberInterface
13 | {
14 |     public function __construct()
15 |     {
16 |         $this->data = [
17 |             'messageCount' => 0,
18 |             'messages' => [],
19 |         ];
20 |     }
21 | 
22 |     /**
23 |      * Collects data for the given Request and Response.
24 |      *
25 |      * @param Request    $request   A Request instance
26 |      * @param Response   $response  A Response instance
27 |      * @param \Exception $exception An Exception instance
28 |      */
29 |     public function collect(Request $request, Response $response, \Exception $exception = null)
30 |     {
31 |         // We don't collect anything from the request data
32 |     }
33 | 
34 |     /**
35 |      * Returns the name of the collector.
36 |      *
37 |      * @return string The collector name
38 |      */
39 |     public function getName()
40 |     {
41 |         return 'bernard';
42 |     }
43 | 
44 |     public function onBernardProduce(EnvelopeEvent $event)
45 |     {
46 |         $envelope = $event->getEnvelope();
47 | 
48 |         $this->data['messages'][(string) $event->getQueue()][] = [
49 |             'name' => $envelope->getName(),
50 |             'message' => $this->cloneVar($envelope->getMessage()),
51 |             'timestamp' => $envelope->getTimestamp(),
52 |             'class' => $envelope->getClass(),
53 |         ];
54 | 
55 |         ++$this->data['messageCount'];
56 |     }
57 | 
58 |     public static function getSubscribedEvents()
59 |     {
60 |         return array(
61 |             BernardEvents::PRODUCE => 'onBernardProduce',
62 |         );
63 |     }
64 | 
65 |     public function getMessageCount()
66 |     {
67 |         return $this->data['messageCount'];
68 |     }
69 | 
70 |     public function getDistinctQueueCount()
71 |     {
72 |         return count($this->data['messages']);
73 |     }
74 | 
75 |     public function getAllMessages()
76 |     {
77 |         return $this->data['messages'];
78 |     }
79 | 
80 |     /**
81 |      * Resets this data collector to its initial state.
82 |      */
83 |     public function reset()
84 |     {
85 |         $this->data = [
86 |             'messageCount' => 0,
87 |             'messages' => [],
88 |         ];
89 |     }
90 | }
91 | 


--------------------------------------------------------------------------------
/Command/DebugCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\Command;
 4 | 
 5 | use Bernard\Router;
 6 | use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
 7 | use Symfony\Component\Console\Helper\Table;
 8 | use Symfony\Component\Console\Input\InputInterface;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | /**
12 |  * @final since 2.1
13 |  */
14 | class DebugCommand extends ContainerAwareCommand
15 | {
16 |     /**
17 |      * @var Router
18 |      */
19 |     private $router;
20 | 
21 |     public function __construct($router = null)
22 |     {
23 |         parent::__construct();
24 | 
25 |         if (!$router instanceof Router) {
26 |             @trigger_error(sprintf('Passing a command name as the first argument of "%s" is deprecated since version symfony 3.4 and will be removed in symfony 4.0. If the command was registered by convention, make it a service instead as this will be the only supported way in bernard bundle 3.0. ', __METHOD__), E_USER_DEPRECATED);
27 | 
28 |             $this->setName(null === $router ? 'bernard:debug' : $router);
29 | 
30 |             return;
31 |         }
32 | 
33 |         $this->router = $router;
34 |     }
35 | 
36 |     public function configure()
37 |     {
38 |         $this
39 |             ->setName('bernard:debug')
40 |             ->setDescription('Displays a table of receivers that are registered with "bernard.receiver" tag.')
41 |         ;
42 |     }
43 | 
44 |     protected function execute(InputInterface $input, OutputInterface $output)
45 |     {
46 |         if (null === $this->router) {
47 |             $this->router = $this->getContainer()->get('bernard.router');
48 |         }
49 | 
50 |         $r = new \ReflectionProperty($this->router, 'receivers');
51 |         $r->setAccessible(true);
52 | 
53 |         $rows = [];
54 |         foreach ($r->getValue($this->router) as $key => $val) {
55 |             $rows[] = [$key, $val];
56 |         }
57 | 
58 |         $table = new Table($output);
59 |         $table
60 |             ->setHeaders(['Message', 'Service'])
61 |             ->addRows($rows)
62 |             ->render()
63 |         ;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/DependencyInjection/BernardExtension.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Bernard\BernardBundle\DependencyInjection;
  4 | 
  5 | use Symfony\Component\Config\FileLocator;
  6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
  7 | use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
  8 | use Symfony\Component\DependencyInjection\Reference;
  9 | use Symfony\Component\HttpKernel\DependencyInjection\ConfigurableExtension;
 10 | 
 11 | class BernardExtension extends ConfigurableExtension
 12 | {
 13 |     protected function loadInternal(array $config, ContainerBuilder $container)
 14 |     {
 15 |         $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
 16 |         $loader->load('services.xml');
 17 |         $loader->load('commands.xml');
 18 | 
 19 |         switch ($config['driver']) {
 20 |             case 'doctrine':
 21 |                 $this->registerDoctrineConfiguration($config['options'], $container);
 22 | 
 23 |                 break;
 24 | 
 25 |             case 'file':
 26 |                 $this->registerFlatFileConfiguration($config['options'], $container);
 27 | 
 28 |                 break;
 29 | 
 30 |             case 'phpamqp':
 31 |                 $this->registerPhpAmqpConfiguration($config['options'], $container);
 32 | 
 33 |                 break;
 34 | 
 35 |             case 'phpredis':
 36 |                 $this->registerPhpRedisConfiguration($config['options'], $container);
 37 | 
 38 |                 break;
 39 | 
 40 |             case 'predis':
 41 |                 $this->registerPredisConfiguration($config['options'], $container);
 42 | 
 43 |                 break;
 44 | 
 45 |             case 'ironmq':
 46 |                 $this->registerIronMQConfiguration($config['options'], $container);
 47 | 
 48 |                 break;
 49 | 
 50 |             case 'sqs':
 51 |                 $this->registerSqsConfiguration($config['options'], $container);
 52 | 
 53 |                 break;
 54 | 
 55 |             case 'pheanstalk':
 56 |                 $this->registerPheanstalkConfiguration($config['options'], $container);
 57 | 
 58 |                 break;
 59 |         }
 60 | 
 61 |         if ($config['driver'] === 'custom') {
 62 |             $container->setAlias('bernard.driver', $config['options']['custom_service']);
 63 |         } else {
 64 |             $container->setAlias('bernard.driver', 'bernard.driver.'.$config['driver']);
 65 |         }
 66 | 
 67 |         $this->registerListeners($config['listeners'], $container);
 68 | 
 69 |         if ($container->getParameter('kernel.debug')) {
 70 |             $loader->load('collector.xml');
 71 |         }
 72 |     }
 73 | 
 74 |     private function registerDoctrineConfiguration($config, ContainerBuilder $container)
 75 |     {
 76 |         $container->setAlias('bernard.dbal.connection', 'doctrine.dbal.'.$config['connection'].'_connection');
 77 |         $container
 78 |             ->getDefinition('bernard.listener.doctrine_schema')
 79 |             ->addTag('doctrine.event_listener', [
 80 |                 'lazy' => true,
 81 |                 'event' => 'postGenerateSchema',
 82 |                 'connection' => $config['connection'],
 83 |             ]
 84 |         );
 85 |     }
 86 | 
 87 |     private function registerFlatFileConfiguration(array $config, ContainerBuilder $container)
 88 |     {
 89 |         $container->getDefinition('bernard.driver.file')->replaceArgument(0, $config['directory']);
 90 |     }
 91 | 
 92 |     private function registerPhpAmqpConfiguration(array $config, ContainerBuilder $container)
 93 |     {
 94 |         $container->getDefinition('bernard.driver.phpamqp')->replaceArgument(0, new Reference($config['phpamqp_service']))
 95 |                                                            ->replaceArgument(1, $config['phpamqp_exchange'])
 96 |                                                            ->replaceArgument(2, $config['phpamqp_default_message_parameters']);
 97 |     }
 98 | 
 99 |     private function registerPhpRedisConfiguration(array $config, ContainerBuilder $container)
100 |     {
101 |         $container->getDefinition('bernard.driver.phpredis')->replaceArgument(0, new Reference($config['phpredis_service']));
102 |     }
103 | 
104 |     private function registerPredisConfiguration(array $config, ContainerBuilder $container)
105 |     {
106 |         $container->getDefinition('bernard.driver.predis')->replaceArgument(0, new Reference($config['predis_service']));
107 |     }
108 | 
109 |     private function registerIronMQConfiguration(array $config, ContainerBuilder $container)
110 |     {
111 |         $container->getDefinition('bernard.driver.ironmq')->replaceArgument(0, new Reference($config['ironmq_service']));
112 |     }
113 | 
114 |     private function registerSqsConfiguration(array $config, ContainerBuilder $container)
115 |     {
116 |         $container->getDefinition('bernard.driver.sqs')->replaceArgument(0, new Reference($config['sqs_service']))
117 |                                                        ->replaceArgument(1, $config['sqs_queue_map'])
118 |                                                        ->replaceArgument(2, $config['prefetch']);
119 |     }
120 | 
121 |     private function registerPheanstalkConfiguration(array $config, ContainerBuilder $container)
122 |     {
123 |         $container->getDefinition('bernard.driver.pheanstalk')->replaceArgument(0, new Reference($config['pheanstalk_service']));
124 |     }
125 | 
126 |     private function registerListeners(array $config, ContainerBuilder $container)
127 |     {
128 |         foreach ($config as $id => $params) {
129 |             if (empty($params) || (is_array($params) && !$params['enabled'])) {
130 |                 $container->removeDefinition('bernard.listener.'.$id);
131 | 
132 |                 continue;
133 |             }
134 | 
135 |             // Enable listener.
136 |             $listener = $container->getDefinition('bernard.listener.'.$id);
137 |             $listener->addTag('kernel.event_subscriber');
138 | 
139 |             if ($id === 'logger') {
140 |                 $listener->replaceArgument(0, new Reference($params['service']));
141 |             } elseif ($id === 'failure') {
142 |                 $listener->replaceArgument(1, $params['queue_name']);
143 |             }
144 |         }
145 |     }
146 | }
147 | 


--------------------------------------------------------------------------------
/DependencyInjection/Compiler/NormalizerPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\DependencyInjection\Compiler;
 4 | 
 5 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 7 | use Symfony\Component\DependencyInjection\Reference;
 8 | 
 9 | class NormalizerPass implements CompilerPassInterface
10 | {
11 |     public function process(ContainerBuilder $container)
12 |     {
13 |         $normalizers = array_map(function ($id) {
14 |             return new Reference($id);
15 |         }, array_keys($container->findTaggedServiceIds('bernard.normalizer')));
16 | 
17 |         $container->getDefinition('bernard.normalizer')->replaceArgument(0, $normalizers);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/DependencyInjection/Compiler/ReceiverPass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\DependencyInjection\Compiler;
 4 | 
 5 | use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 7 | 
 8 | class ReceiverPass implements CompilerPassInterface
 9 | {
10 |     public function process(ContainerBuilder $container)
11 |     {
12 |         $receivers = [];
13 | 
14 |         foreach ($container->findTaggedServiceIds('bernard.receiver') as $id => $tags) {
15 |             foreach ($tags as $attrs) {
16 |                 if (!isset($attrs['message'])) {
17 |                     throw new \RuntimeException(sprintf('Each tag named "bernard.receiver" of service "%s" must have at "message" attribute that species the message name it is associated with.', $id));
18 |                 }
19 | 
20 |                 $receivers[$attrs['message']] = $id;
21 |             }
22 |         }
23 | 
24 |         $container->getDefinition('bernard.router')->replaceArgument(1, $receivers);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/DependencyInjection/Configuration.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Bernard\BernardBundle\DependencyInjection;
  4 | 
  5 | use Symfony\Component\Config\Definition\Builder\NodeDefinition;
  6 | use Symfony\Component\Config\Definition\Builder\TreeBuilder;
  7 | use Symfony\Component\Config\Definition\ConfigurationInterface;
  8 | 
  9 | class Configuration implements ConfigurationInterface
 10 | {
 11 |     public function getConfigTreeBuilder()
 12 |     {
 13 |         $tree = new TreeBuilder('bernard');
 14 |         if (method_exists(TreeBuilder::class, 'getRootNode')) {
 15 |             $root = $tree->getRootNode();
 16 |         } else {
 17 |             // BC layer for symfony/config 4.1 and older
 18 |             $root = $tree->root('bernard');
 19 |         }
 20 | 
 21 |         $root
 22 |             ->children()
 23 |                 ->enumNode('driver')
 24 |                     ->isRequired()
 25 |                     ->cannotBeEmpty()
 26 |                     ->values(['doctrine', 'file', 'phpamqp', 'phpredis', 'predis', 'ironmq', 'sqs', 'pheanstalk', 'custom'])
 27 |                 ->end()
 28 | 
 29 |                 ->arrayNode('options')
 30 |                     ->addDefaultsIfNotSet()
 31 |                     ->children()
 32 |                         ->scalarNode('connection')->defaultValue('default')->end()
 33 |                         ->scalarNode('directory')->defaultValue('%kernel.cache_dir%/bernard')->end()
 34 |                         ->scalarNode('phpamqp_service')->defaultValue('old_sound_rabbit_mq.connection.default')->end()
 35 |                         ->scalarNode('phpamqp_exchange')->defaultNull()->end()
 36 |                         ->arrayNode('phpamqp_default_message_parameters')
 37 |                             ->useAttributeAsKey('name')
 38 |                             ->prototype('scalar')->end()
 39 |                         ->end()
 40 |                         ->scalarNode('phpredis_service')->defaultValue('snc_redis.bernard')->end()
 41 |                         ->scalarNode('predis_service')->defaultValue('snc_redis.bernard')->end()
 42 |                         ->scalarNode('ironmq_service')->defaultNull()->end()
 43 |                         ->scalarNode('sqs_service')->defaultNull()->end()
 44 |                         ->arrayNode('sqs_queue_map')
 45 |                             ->useAttributeAsKey('name')
 46 |                             ->prototype('scalar')->end()
 47 |                         ->end()
 48 |                         ->scalarNode('prefetch')->defaultNull()->end()
 49 |                         ->scalarNode('pheanstalk_service')->defaultNull()->end()
 50 |                         ->scalarNode('custom_service')->defaultNull()->end()
 51 |                     ->end()
 52 |                 ->end()
 53 | 
 54 |                 ->arrayNode('listeners')
 55 |                     ->addDefaultsIfNotSet()
 56 |                     ->children()
 57 |                         ->booleanNode('error_log')->defaultFalse()->end()
 58 |                         ->arrayNode('logger')
 59 |                             ->canBeEnabled()
 60 |                             ->children()
 61 |                                 ->scalarNode('service')->defaultValue('logger')->end()
 62 |                             ->end()
 63 |                             ->beforeNormalization()
 64 |                                 ->ifString()
 65 |                                 ->then(function ($v) {
 66 |                                     return ['enabled' => true, 'service' => $v];
 67 |                                 })
 68 |                             ->end()
 69 |                         ->end()
 70 |                         ->arrayNode('failure')
 71 |                             ->canBeEnabled()
 72 |                             ->children()
 73 |                                 ->scalarNode('queue_name')->defaultValue('failed')->end()
 74 |                             ->end()
 75 |                             ->beforeNormalization()
 76 |                                 ->ifString()
 77 |                                 ->then(function ($v) {
 78 |                                     return ['enabled' => true, 'queue_name' => $v];
 79 |                                 })
 80 |                             ->end()
 81 |                         ->end()
 82 |                     ->end()
 83 |                 ->end()
 84 |             ->end()
 85 |         ;
 86 | 
 87 |         $this
 88 |             ->validateDriver($root, 'file', 'directory')
 89 |             ->validateDriver($root, 'phpamqp', 'connection')
 90 |             ->validateDriver($root, 'phpamqp', 'phpamqp_exchange')
 91 |             ->validateDriver($root, 'phpredis', 'phpredis_service')
 92 |             ->validateDriver($root, 'predis', 'predis_service')
 93 |             ->validateDriver($root, 'ironmq', 'ironmq_service')
 94 |             ->validateDriver($root, 'sqs', 'sqs_service')
 95 |             ->validateDriver($root, 'pheanstalk', 'pheanstalk_service')
 96 |             ->validateDriver($root, 'custom', 'custom_service')
 97 |         ;
 98 | 
 99 |         return $tree;
100 |     }
101 | 
102 |     /**
103 |      * @param NodeDefinition $node
104 |      * @param string         $driver
105 |      * @param string         $option
106 |      *
107 |      * @return self
108 |      */
109 |     private function validateDriver(NodeDefinition $node, $driver, $option)
110 |     {
111 |         $node
112 |             ->validate()
113 |                 ->ifTrue(function ($v) use ($driver, $option) {
114 |                     return $driver === $v['driver'] && empty($v['options'][$option]);
115 |                 })
116 |                 ->thenInvalid(sprintf('The "%s" option must be defined when using the "%s" driver.', $option, $driver))
117 |             ->end()
118 |         ;
119 | 
120 |         return $this;
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/EventListener/SchemaListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\EventListener;
 4 | 
 5 | use Bernard\Doctrine\MessagesSchema;
 6 | use Doctrine\ORM\Tools\Event\GenerateSchemaEventArgs;
 7 | 
 8 | class SchemaListener
 9 | {
10 |     public function postGenerateSchema(GenerateSchemaEventArgs $args)
11 |     {
12 |         MessagesSchema::create($args->getSchema());
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Bernard
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | 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, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/Normalizer/DefaultMessageNormalizer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\Normalizer;
 4 | 
 5 | use Assert\Assertion;
 6 | use Bernard\Message\DefaultMessage;
 7 | use Bernard\Normalizer\PlainMessageNormalizer;
 8 | 
 9 | class DefaultMessageNormalizer extends PlainMessageNormalizer
10 | {
11 |     /**
12 |      * {@inheritdoc}
13 |      */
14 |     public function normalize($object, $format = null, array $context = [])
15 |     {
16 |         @trigger_error('The '.__CLASS__.' class is deprecated and will removed in version 3.0. Use '.PlainMessageNormalizer::class.' instead.', E_USER_DEPRECATED);
17 | 
18 |         parent::normalize($object, $format, $context);
19 |     }
20 | 
21 |     /**
22 |      * {@inheritdoc}
23 |      */
24 |     public function denormalize($data, $class, $format = null, array $context = [])
25 |     {
26 |         @trigger_error('The '.__CLASS__.' class is deprecated and will removed in version 3.0. Use '.PlainMessageNormalizer::class.' instead.', E_USER_DEPRECATED);
27 | 
28 |         Assertion::notEmptyKey($data, 'name');
29 |         Assertion::keyExists($data, 'arguments');
30 |         Assertion::isArray($data['arguments']);
31 | 
32 |         return new DefaultMessage($data['name'], $data['arguments']);
33 |     }
34 | 
35 |     /**
36 |      * {@inheritdoc}
37 |      */
38 |     public function supportsDenormalization($data, $type, $format = null)
39 |     {
40 |         return $type === DefaultMessage::class;
41 |     }
42 | 
43 |     /**
44 |      * {@inheritdoc}
45 |      */
46 |     public function supportsNormalization($data, $format = null)
47 |     {
48 |         return $data instanceof DefaultMessage;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | BernardBundle
  2 | =============
  3 | 
  4 | Integrates Bernard neatly with a Symfony application.
  5 | 
  6 | [![Build Status](https://travis-ci.org/bernardphp/BernardBundle.png?branch=master)](https://travis-ci.org/bernardphp/BernardBundle)
  7 | 
  8 | Getting Started
  9 | ---------------
 10 | 
 11 | Everything starts by installing the bundle. This is done through composer by adding the following lines
 12 | to your `composer.json` file and running `composer update bernard/bernard-bundle`.
 13 | 
 14 | ``` json
 15 | {
 16 |     "require" : {
 17 |         "bernard/bernard-bundle" : "~1.0"
 18 |     }
 19 | }
 20 | ```
 21 | 
 22 | Next up is adding the bundle to your kernel and configuring it in `config.yml`.
 23 | 
 24 | ``` php
 25 | // app/AppKernel.php
 26 | // .. previous class definition
 27 | public function registerBundles()
 28 | {
 29 |     // .. all the other bundles you have registered.
 30 |     $bundles[] = new Bernard\BernardBundle\BernardBundle();
 31 |     // .. the rest of the method
 32 | }
 33 | ```
 34 | 
 35 | ``` yml
 36 | # .. previous content of app/config/config.yml
 37 | bernard:
 38 |     driver: file # you can choose predis, phpredis, file, doctrine, sqs etc.
 39 | ```
 40 | 
 41 | Great! You are now ready to use this diddy. Go and read the rest of the documentation on Bernard at [bernard.readthedocs.org](http://bernard.readthedocs.org).
 42 | 
 43 | ### Running the Consumer
 44 | 
 45 | What good is a message queue if you don't know how to run the consumer? Luckily this bundle auto registers the commands
 46 | with your application. So if you run `php app/console` you should see `bernard:consume` and `bernard:produce`. These
 47 | work just as the documentation describes but if you are in doubt just add `--help` when running the command.
 48 | 
 49 | It is important to use `--no-debug` when running the consumer for longer periods of time. This is because Symfony by
 50 | default in debug mode collects a lot of information and logging and if this is omitted you will run into memory problems
 51 | sooner or later.
 52 | 
 53 | ### Adding Receivers
 54 | 
 55 | In order to know what messages needs to go where you have to register some receivers. This is done with a tag in your
 56 | service definitions.
 57 | 
 58 | ``` yaml
 59 | my_receiver:
 60 |     class: Acme\Receiver
 61 |     # public: true # Make sure the service is public
 62 |     tags:
 63 |          - { name: bernard.receiver, message: SendNewsletter }
 64 |          - { name: bernard.receiver, message: ImportUsers }
 65 | ```
 66 | 
 67 | As the example shows it is possible to register the same receiver for many different message types.
 68 | 
 69 | Configuration Options
 70 | ---------------------
 71 | 
 72 | There are different options that can be set that changes the behaviour for various drivers.
 73 | 
 74 | ### Doctrine
 75 | 
 76 | When using the doctrine driver it can be useful to use a seperate connection when using Bernard. In order to
 77 | change it use the `connection` option. This also needs to be set if you default connection is called anything else
 78 | than `default`.
 79 | 
 80 | ``` yaml
 81 | doctrine:
 82 |     dbal:
 83 |         connections:
 84 |             bernard:
 85 |                 host:     "%database_host%"
 86 |                 charset:  UTF8
 87 | 
 88 | bernard:
 89 |     driver: doctrine
 90 |     options:
 91 |         connection: bernard # default is the default value
 92 | ```
 93 | 
 94 | ### FlatFile
 95 | 
 96 | The file driver needs to know what directory it should use for storing messages and its queue metadata.
 97 | 
 98 | ``` yaml
 99 | bernard:
100 |     driver: file
101 |     options:
102 |         directory: %kernel.cache_dir%/bernard
103 | ```
104 | 
105 | The above example will dump your messages in the cache folder. In most cases you will want to change this to something
106 | because the cache folder is deleted every time the cache is cleared (obviously).
107 | 
108 | ### PhpAmqp / RabbitMQ
109 | 
110 | PhpAmqp depends on a service called `old_sound_rabbit_mq.connection.default` with a configured connection instance that extends `\PhpAmqpLib\Connection\AbstractConnection` class.
111 | If you want to use a different name use the `phpamqp_service` option:
112 | 
113 | ``` yaml
114 | bernard:
115 |     driver: phpamqp
116 |     options:
117 |         phpamqp_service: my_phpamqp_service
118 | ```
119 | 
120 | You need to define the `phpamqp_exchange`. Optional, you can define `phpamqp_default_message_parameters`:
121 | ``` yaml
122 | bernard:
123 |     driver: phpamqp
124 |     options:
125 |         phpamqp_exchange: my_phpamqp_service
126 |         phpamqp_default_message_parameters:
127 |             content_type: application/json
128 |             delivery_mode: 2
129 | ```
130 | 
131 | ### PhpRedis
132 | 
133 | PhpRedis depends on a service called `snc_redis.bernard` with a configured `Redis` instance. If you want to use a
134 | different name use the `phpredis_service` option:
135 | 
136 | ``` yaml
137 | bernard:
138 |     driver: phpredis
139 |     options:
140 |         phpredis_service: my_redis_service
141 | ```
142 | 
143 | If you're using the [SncRedisBundle](https://github.com/snc/SncRedisBundle) you have to set logging to false for the
144 | bernhard client to ensure that is is a ``Redis`` instance and not wrapped. Also, if the consumer is throwing `RedisException: read error on connection`, you need to set `connection_timeout` (see SncRedisBundle configuration options) option to a value higher than 5 (seconds).
145 | 
146 | ### IronMQ
147 | 
148 | When using the IronMQ driver you have to configure an `IronMQ` connection instance. You can configure it like the following:
149 | 
150 | ``` yaml
151 | services:
152 |     ironmq_connection:
153 |         class: IronMQ
154 |         arguments:
155 |             - { token: %ironmq_token%, project_id: %ironmq_project_id% }
156 |         public: false
157 | 
158 | bernard:
159 |     driver: ironmq
160 |     options:
161 |         ironmq_service: ironmq_connection
162 | ```
163 | 
164 | ### Amazon SQS
165 | 
166 | To use Amazon SQS, configure your driver like this:
167 | 
168 | ``` yaml
169 | services:
170 |     my_sqs_client:
171 |         class: Aws\Sqs\SqsClient
172 |         factory: Aws\Sqs\SqsClient::factory
173 |         arguments:
174 |             region: "your aws region" # e.g. "eu-west-1"
175 |             key: "your aws user's key"
176 |             secret: "your aws user's secret"
177 | 
178 | bernard:
179 |     driver: sqs
180 |     options:
181 |         sqs_service: my_sqs_client
182 |         sqs_queue_map: # optional for aliasing queue urls (default alias is the url section after the last "/"), e.g.:
183 |             send_newsletter: https://sqs.eu-west-1.amazonaws.com/...
184 |         prefetch: 1 # optional, but beware the default is >1 and you may run into invisibility timeout problems with that
185 | ```
186 | 
187 | ### Pheanstalk
188 | 
189 | To use Pheanstalk (pda/pheanstalk), configure your driver like this:
190 | 
191 | ``` yaml
192 | services:
193 |     my.pheanstalk.connection:
194 |         class: Pheanstalk\Pheanstalk
195 |         arguments:
196 |             - %some.parameter.containing.pheanstalk.host%
197 | 
198 | bernard:
199 |     driver: pheanstalk
200 |     options:
201 |         pheanstalk_service: my.pheanstalk.connection
202 | ```
203 | 


--------------------------------------------------------------------------------
/Resources/config/collector.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8" ?>
 2 | <container xmlns="http://symfony.com/schema/dic/services"
 3 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 4 |     xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
 5 | 
 6 |     <services>
 7 |         <service id="bernard.data_collector.message" class="Bernard\BernardBundle\Collector\ProducerCollector">
 8 |             <tag name="kernel.event_subscriber" />
 9 |             <tag name="data_collector" template="@Bernard/Collector/producer.html.twig" id="bernard" priority="254" />
10 |         </service>
11 |     </services>
12 | </container>
13 | 


--------------------------------------------------------------------------------
/Resources/config/commands.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <container xmlns="http://symfony.com/schema/dic/services" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
 3 |     <services>
 4 |         <service id="bernard.command.consume" class="Bernard\Command\ConsumeCommand">
 5 |             <argument type="service" id="bernard.consumer" />
 6 |             <argument type="service" id="bernard.queue_factory" />
 7 |             <tag name="console.command" command="bernard:consume" />
 8 |         </service>
 9 | 
10 |         <service id="bernard.command.produce" class="Bernard\Command\ProduceCommand">
11 |             <argument type="service" id="bernard.producer" />
12 |             <tag name="console.command" command="bernard:produce" />
13 |         </service>
14 | 
15 |         <service class="Bernard\BernardBundle\Command\DebugCommand" id="Bernard\BernardBundle\Command\DebugCommand">
16 |             <argument type="service" id="bernard.router" />
17 |             <tag name="console.command" command="bernard:debug" />
18 |         </service>
19 |     </services>
20 | </container>
21 | 


--------------------------------------------------------------------------------
/Resources/config/services.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8" ?>
  2 | <container xmlns="http://symfony.com/schema/dic/services"
  3 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4 |     xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
  5 | 
  6 |     <services>
  7 |         <service id="Bernard\Producer" alias="bernard.producer" public="false" />
  8 |         <service id="Bernard\Consumer" alias="bernard.consumer" public="false" />
  9 |         <service id="Bernard\QueueFactory\PersistentFactory" alias="bernard.queue_factory" public="false" />
 10 | 
 11 |         <service id="bernard.router" class="Bernard\Router\ContainerAwareRouter">
 12 |             <argument type="service" id="service_container" />
 13 |             <argument type="collection" /><!-- Receivers -->
 14 |         </service>
 15 | 
 16 |         <service id="bernard.consumer" class="Bernard\Consumer">
 17 |             <argument type="service" id="bernard.router" />
 18 |             <argument type="service" id="event_dispatcher" />
 19 |         </service>
 20 | 
 21 |         <service id="bernard.producer" class="Bernard\Producer">
 22 |             <argument type="service" id="bernard.queue_factory" />
 23 |             <argument type="service" id="event_dispatcher" />
 24 |         </service>
 25 | 
 26 |         <service id="bernard.queue_factory" class="Bernard\QueueFactory\PersistentFactory" public="false">
 27 |             <argument type="service" id="bernard.driver" />
 28 |             <argument type="service" id="bernard.serializer" />
 29 |         </service>
 30 | 
 31 |         <service id="bernard.normalizer" class="Normalt\Normalizer\AggregateNormalizer" public="false">
 32 |             <argument type="collection" />
 33 |         </service>
 34 | 
 35 |         <service id="bernard.serializer" class="Bernard\Serializer" public="false">
 36 |             <argument type="service" id="bernard.normalizer" />
 37 |         </service>
 38 | 
 39 |         <!-- Listeners -->
 40 | 
 41 |         <service id="bernard.listener.failure" class="Bernard\EventListener\FailureSubscriber">
 42 |             <argument type="service" id="bernard.producer" />
 43 |             <argument /><!-- Queue name -->
 44 |         </service>
 45 | 
 46 |         <service id="bernard.listener.logger" class="Bernard\EventListener\LoggerSubscriber">
 47 |             <argument /><!-- Logger -->
 48 |         </service>
 49 | 
 50 |         <service id="bernard.listener.error_log" class="Bernard\EventListener\ErrorLogSubscriber" />
 51 | 
 52 |         <service id="bernard.listener.doctrine_schema" class="Bernard\BernardBundle\EventListener\SchemaListener" public="false" />
 53 | 
 54 |         <!-- Normalizers -->
 55 | 
 56 |         <service id="bernard.normalizer.envelope" class="Bernard\Normalizer\EnvelopeNormalizer">
 57 |             <tag name="bernard.normalizer" />
 58 |         </service>
 59 | 
 60 |         <service id="bernard.normalizer.plain_message" class="Bernard\Normalizer\PlainMessageNormalizer">
 61 |             <tag name="bernard.normalizer" />
 62 |         </service>
 63 | 
 64 |         <service id="bernard.normalizer.default_message" class="Bernard\BernardBundle\Normalizer\DefaultMessageNormalizer">
 65 |             <tag name="bernard.normalizer" />
 66 |         </service>
 67 | 
 68 | 
 69 |         <!-- Drivers -->
 70 | 
 71 |         <service id="bernard.driver.doctrine" class="Bernard\Driver\DoctrineDriver" public="false">
 72 |             <argument type="service" id="bernard.dbal.connection" />
 73 |         </service>
 74 | 
 75 |         <service id="bernard.driver.file" class="Bernard\Driver\FlatFileDriver" public="false">
 76 |             <argument /><!-- Base directory -->
 77 |         </service>
 78 | 
 79 |         <service id="bernard.driver.phpamqp" class="Bernard\Driver\PhpAmqpDriver" public="false">
 80 |             <argument /><!-- Connection -->
 81 |             <argument /><!-- exchange -->
 82 |             <argument /><!-- defaultMessageParams -->
 83 |         </service>
 84 | 
 85 |         <service id="bernard.driver.phpredis" class="Bernard\Driver\PhpRedisDriver" public="false">
 86 |             <argument /><!-- Redis -->
 87 |         </service>
 88 | 
 89 |         <service id="bernard.driver.predis" class="Bernard\Driver\PredisDriver" public="false">
 90 |             <argument /><!-- Predis client -->
 91 |         </service>
 92 | 
 93 |         <service id="bernard.driver.sqs" class="Bernard\Driver\SqsDriver" public="false">
 94 |             <argument /><!-- SQS client-->
 95 |             <argument /><!-- queue map -->
 96 |             <argument /><!-- prefetch -->
 97 |         </service>
 98 | 
 99 |         <service id="bernard.driver.ironmq" class="Bernard\Driver\IronMqDriver" public="false">
100 |             <argument /><!-- IronMQ connection -->
101 |         </service>
102 | 
103 |         <service id="bernard.driver.pheanstalk" class="Bernard\Driver\PheanstalkDriver" public="false">
104 |             <argument /><!-- Pheanstalk connection -->
105 |         </service>
106 | 
107 |     </services>
108 | </container>
109 | 


--------------------------------------------------------------------------------
/Resources/views/Collector/producer.html.twig:
--------------------------------------------------------------------------------
 1 | {% extends '@WebProfiler/Profiler/layout.html.twig' %}
 2 | 
 3 | {% block toolbar %}
 4 |     {% if collector.messageCount > 0 %}
 5 |         {% set icon %}
 6 |             {{ include('@Bernard/Icon/bernard.svg') }}
 7 |             <span class="sf-toolbar-value">{{ collector.messageCount }}</span>
 8 |         {% endset %}
 9 | 
10 |         {% set text %}
11 |             <div class="sf-toolbar-info-piece">
12 |                 <b>Total messages:</b>
13 |                 <span class="sf-toolbar-status">{{ collector.messageCount }}</span>
14 |             </div>
15 |             <div class="sf-toolbar-info-piece">
16 |                 <b>Total distinct queues:</b>
17 |                 <span class="sf-toolbar-status">{{ collector.distinctQueueCount }}</span>
18 |             </div>
19 |         {% endset %}
20 | 
21 |         {{ include('@WebProfiler/Profiler/toolbar_item.html.twig', { link: profiler_url, name: 'bernard' }) }}
22 |     {% endif %}
23 | {% endblock %}
24 | 
25 | {% block menu %}
26 |     <span class="label {{ collector.messageCount > 0 ?: 'disabled' }}">
27 |         <span class="icon">{{ include('@Bernard/Icon/bernard.svg') }}</span>
28 |         <strong>Bernard</strong>
29 |     </span>
30 | {% endblock %}
31 | 
32 | {% block panel %}
33 |     <h2>Bernard</h2>
34 | 
35 |     {% if collector.messageCount > 0 %}
36 |         <div class="sf-dump sf-reset">
37 |             {% for queue,messages in collector.allMessages %}
38 |                 <h4>Queue: {{ queue }}</h4>
39 |                 <table>
40 |                     <thead>
41 |                     <tr>
42 |                         <th>#</th>
43 |                         <th>Message</th>
44 |                         <th>Produced at</th>
45 |                     </tr>
46 |                     </thead>
47 |                     <tbody>
48 |                     {% for message in messages %}
49 |                         <tr>
50 |                             <td class="font-normal text-small text-muted nowrap">{{ loop.index }}</td>
51 |                             <td class="font-normal">
52 |                                 {% set context_id = 'context-' ~ queue ~ '-' ~ loop.index %}
53 | 
54 |                                 {{ message.class }}
55 | 
56 |                                 <a class="text-small sf-toggle" data-toggle-selector="#{{ context_id }}" data-toggle-alt-content="Hide message">Show message</a>
57 | 
58 |                                 <div class="sf-dump-compact hidden" id="{{ context_id }}">
59 |                                     {{ profiler_dump(message.message, maxDepth=2) }}
60 |                                 </div>
61 |                             </td>
62 |                             <td class="nowrap">{{ message.timestamp|date('d/m/Y H:i:s') }}</td>
63 |                         </tr>
64 |                     {% endfor %}
65 |                     </tbody>
66 |                 </table>
67 |             {% endfor %}
68 |         </div>
69 |     {% else %}
70 |         <div class="empty">
71 |             <p>No messages were produced.</p>
72 |         </div>
73 |     {% endif %}
74 | {% endblock %}
75 | 


--------------------------------------------------------------------------------
/Resources/views/Icon/bernard.svg:
--------------------------------------------------------------------------------
1 | <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24">
2 | 	<path fill="#AAAAAA " d="M14.94 10.03c-1.42-.494-3.92 0-3.92 0V6.11c0-.978.653-2.61.653-2.61L6.45 5.048V6.11h1.305V20.48s5.964.086 5.964-.085c0-.164 3.83-1.96 3.83-5.792 0-3.27-1.612-4.223-2.61-4.57zm-1.96 7.836c-1.307 1.307-1.96 0-1.96 0v-5.224s.902-1.064 1.96 0c1.064 1.06 1.306 3.92 0 5.224z"/>
3 | </svg>
4 | 


--------------------------------------------------------------------------------
/Tests/DependencyInjection/BernardExtensionTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Bernard\BernardBundle\Tests\DependencyInjection;
  4 | 
  5 | use Bernard\BernardBundle\DependencyInjection\BernardExtension;
  6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
  7 | 
  8 | class BernardExtensionTest extends \PHPUnit\Framework\TestCase
  9 | {
 10 |     /** @var BernardExtension */
 11 |     private $extension;
 12 | 
 13 |     /** @var ContainerBuilder */
 14 |     private $container;
 15 | 
 16 |     public function setUp()
 17 |     {
 18 |         $this->extension = new BernardExtension();
 19 |         $this->container = new ContainerBuilder();
 20 | 
 21 |         $this->container->setParameter('kernel.debug', true);
 22 |     }
 23 | 
 24 |     public function testServicesExists()
 25 |     {
 26 |         $config = ['driver' => 'doctrine'];
 27 |         $this->extension->load([$config], $this->container);
 28 | 
 29 |         // Make sure we don't have a dependencies on a real driver.
 30 |         $this->container->set('bernard.driver', $this->createMock('Bernard\Driver'));
 31 |         $this->container->set('event_dispatcher', $this->createMock('Symfony\Component\EventDispatcher\EventDispatcherInterface'));
 32 | 
 33 |         // Real services.
 34 |         $this->assertInstanceOf('Bernard\Producer', $this->container->get('bernard.producer'));
 35 |         $this->assertInstanceOf('Bernard\Consumer', $this->container->get('bernard.consumer'));
 36 |         $this->assertInstanceOf('Bernard\Command\ConsumeCommand', $this->container->get('bernard.command.consume'));
 37 |         $this->assertInstanceOf('Bernard\Command\ProduceCommand', $this->container->get('bernard.command.produce'));
 38 |     }
 39 | 
 40 |     public function testListenersAreNotRegisteredByDefault()
 41 |     {
 42 |         $config = ['driver' => 'doctrine'];
 43 |         $this->extension->load([$config], $this->container);
 44 | 
 45 |         foreach (['error_log', 'logger', 'failure'] as $listener) {
 46 |             $this->assertFalse($this->container->hasDefinition('bernard.listener.'.$listener));
 47 |         }
 48 |     }
 49 | 
 50 |     public function testListenersHaveSubscriberTag()
 51 |     {
 52 |         $config = [
 53 |             'driver' => 'doctrine',
 54 |             'listeners' => [
 55 |                 'error_log' => true,
 56 |                 'logger' => true,
 57 |                 'failure' => true,
 58 |             ],
 59 |         ];
 60 |         $this->extension->load([$config], $this->container);
 61 | 
 62 |         foreach (['error_log', 'logger', 'failure'] as $listener) {
 63 |             $definition = $this->container->getDefinition('bernard.listener.'.$listener);
 64 |             $this->assertTrue($definition->hasTag('kernel.event_subscriber'));
 65 |         }
 66 |     }
 67 | 
 68 |     public function testDoctrineEventListenerIsAdded()
 69 |     {
 70 |         $config = [
 71 |             'driver' => 'doctrine',
 72 |             'options' => [
 73 |                 'connection' => 'bernard',
 74 |             ],
 75 |         ];
 76 |         $this->extension->load([$config], $this->container);
 77 | 
 78 |         $definition = $this->container->getDefinition('bernard.listener.doctrine_schema');
 79 | 
 80 |         $expected = [
 81 |             'event' => 'postGenerateSchema',
 82 |             'connection' => 'bernard',
 83 |             'lazy' => true,
 84 |         ];
 85 | 
 86 |         $this->assertTrue($definition->hasTag('doctrine.event_listener'));
 87 |         $this->assertEquals([$expected], $definition->getTag('doctrine.event_listener'));
 88 |         $this->assertEquals('doctrine.dbal.bernard_connection', $this->container->getAlias('bernard.dbal.connection'));
 89 |     }
 90 | 
 91 |     public function testDirectoryIsAddedToFileDriver()
 92 |     {
 93 |         $config = [
 94 |             'driver' => 'file',
 95 |             'options' => [
 96 |                 'directory' => __DIR__,
 97 |             ],
 98 |         ];
 99 |         $this->extension->load([$config], $this->container);
100 | 
101 |         $definition = $this->container->getDefinition('bernard.driver.file');
102 | 
103 |         $this->assertCount(1, $definition->getArguments());
104 |         $this->assertEquals(__DIR__, $definition->getArgument(0));
105 |     }
106 | 
107 |     public function testDriverIsAliased()
108 |     {
109 |         $config = ['driver' => 'doctrine'];
110 |         $this->extension->load([$config], $this->container);
111 | 
112 |         $alias = $this->container->getAlias('bernard.driver');
113 | 
114 |         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Alias', $alias);
115 |         $this->assertEquals('bernard.driver.doctrine', (string) $alias);
116 |     }
117 | 
118 |     public function testSqsDriverCanBeBuildFromConfiguration()
119 |     {
120 |         $configuredClientService = 'sqs-client-service';
121 |         $configuredQueueMap = ['name1' => 'url1', 'name2' => 'url2'];
122 |         $configuredPrefetchValue = 1;
123 | 
124 |         $config = [
125 |             'driver' => 'sqs',
126 |             'options' => [
127 |                 'sqs_service' => $configuredClientService,
128 |                 'sqs_queue_map' => $configuredQueueMap,
129 |                 'prefetch' => $configuredPrefetchValue,
130 |             ],
131 |         ];
132 | 
133 |         $this->extension->load([$config], $this->container);
134 |         $driverDefinition = $this->container->getDefinition('bernard.driver.sqs');
135 | 
136 |         $this->assertCount(3, $driverDefinition->getArguments());
137 |         $this->assertEquals($configuredClientService, $driverDefinition->getArgument(0));
138 |         $this->assertEquals($configuredQueueMap, $driverDefinition->getArgument(1));
139 |         $this->assertEquals($configuredPrefetchValue, $driverDefinition->getArgument(2));
140 |     }
141 | }
142 | 


--------------------------------------------------------------------------------
/Tests/DependencyInjection/Compiler/NormalizerPassTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\Tests\DependencyInjection\Compiler;
 4 | 
 5 | use Bernard\BernardBundle\DependencyInjection\Compiler\NormalizerPass;
 6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 7 | 
 8 | class NormalizerPassTest extends \PHPUnit\Framework\TestCase
 9 | {
10 |     /** @var ContainerBuilder */
11 |     private $container;
12 | 
13 |     public function setUp()
14 |     {
15 |         $this->container = new ContainerBuilder();
16 |         $this->container
17 |             ->register('bernard.normalizer', 'Normalt\Normalizer\AggregateNormalizer')
18 |             ->addArgument([])
19 |         ;
20 |     }
21 | 
22 |     public function testRegister()
23 |     {
24 |         $this->container->register('normalizer_one', 'stdClass')->addTag('bernard.normalizer');
25 |         $this->container->register('normalizer_two', 'stdClass')->addTag('bernard.normalizer');
26 | 
27 |         $pass = new NormalizerPass();
28 |         $pass->process($this->container);
29 | 
30 |         $refs = $this->container->getDefinition('bernard.normalizer')->getArgument(0);
31 | 
32 |         $this->assertCount(2, $refs);
33 |         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $refs[0]);
34 |         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $refs[1]);
35 |         $this->assertEquals('normalizer_one', (string) $refs[0]);
36 |         $this->assertEquals('normalizer_two', (string) $refs[1]);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Tests/DependencyInjection/Compiler/ReceiverPassTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Bernard\BernardBundle\Tests\DependencyInjection\Compiler;
 4 | 
 5 | use Bernard\BernardBundle\DependencyInjection\Compiler\ReceiverPass;
 6 | use Symfony\Component\DependencyInjection\ContainerBuilder;
 7 | use Symfony\Component\DependencyInjection\Reference;
 8 | 
 9 | class ReceiverPassTest extends \PHPUnit\Framework\TestCase
10 | {
11 |     /** @var ContainerBuilder */
12 |     private $container;
13 | 
14 |     public function setUp()
15 |     {
16 |         $this->container = new ContainerBuilder();
17 |         $this->container
18 |             ->register('bernard.router', 'Bernard\Router\ContainerAwareRouter')
19 |             ->setArguments([new Reference('service_container'), []])
20 |         ;
21 |     }
22 | 
23 |     public function testRegisterMultipleTags()
24 |     {
25 |         $this->container->register('test_receiver', 'stdClass')
26 |             ->addTag('bernard.receiver', ['message' => 'ImportUsers'])
27 |             ->addTag('bernard.receiver', ['message' => 'SendNewsletter'])
28 |             ->addTag('bernard.receiver', ['message' => 'DeleteWorld'])
29 |         ;
30 | 
31 |         $pass = new ReceiverPass();
32 |         $pass->process($this->container);
33 | 
34 |         $arguments = $this->container->getDefinition('bernard.router')->getArguments();
35 | 
36 |         $expected = [
37 |             'ImportUsers' => 'test_receiver',
38 |             'SendNewsletter' => 'test_receiver',
39 |             'DeleteWorld' => 'test_receiver',
40 |         ];
41 | 
42 |         $this->assertCount(2, $arguments);
43 |         $this->assertInstanceOf('Symfony\Component\DependencyInjection\Reference', $arguments[0]);
44 |         $this->assertEquals('service_container', (string) $arguments[0]);
45 |         $this->assertEquals($expected, $arguments[1]);
46 |     }
47 | 
48 |     /**
49 |      * @expectedException \RuntimeException
50 |      */
51 |     public function testExceptionWhenNameAttributeIsMissing()
52 |     {
53 |         $this->container->register('test_receiver', 'stdClass')->addTag('bernard.receiver', []);
54 | 
55 |         $pass = new ReceiverPass();
56 |         $pass->process($this->container);
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/Tests/DependencyInjection/ConfigurationTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Bernard\BernardBundle\Tests\DependencyInjection;
  4 | 
  5 | use Bernard\BernardBundle\DependencyInjection\Configuration;
  6 | use Symfony\Component\Config\Definition\Processor;
  7 | 
  8 | class ConfigurationTest extends \PHPUnit\Framework\TestCase
  9 | {
 10 |     public function testDefaults()
 11 |     {
 12 |         $config = $this->processConfig(['driver' => 'doctrine']);
 13 | 
 14 |         $this->assertEquals([
 15 |             'error_log' => false,
 16 |             'logger' => [
 17 |                 'enabled' => false,
 18 |                 'service' => 'logger',
 19 |             ],
 20 |             'failure' => [
 21 |                 'enabled' => false,
 22 |                 'queue_name' => 'failed',
 23 |             ],
 24 |         ], $config['listeners']);
 25 | 
 26 |         $this->assertEquals([
 27 |             'prefetch' => null,
 28 |             'connection' => 'default',
 29 |             'directory' => '%kernel.cache_dir%/bernard',
 30 |             'phpamqp_service' => 'old_sound_rabbit_mq.connection.default',
 31 |             'phpamqp_exchange' => null,
 32 |             'phpamqp_default_message_parameters' => [],
 33 |             'phpredis_service' => 'snc_redis.bernard',
 34 |             'predis_service' => 'snc_redis.bernard',
 35 |             'ironmq_service' => null,
 36 |             'sqs_service' => null,
 37 |             'sqs_queue_map' => [],
 38 |             'pheanstalk_service' => null,
 39 |             'custom_service' => null,
 40 |         ], $config['options']);
 41 |     }
 42 | 
 43 |     /**
 44 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 45 |      * @expectedExceptionMessage The child node "driver" at path "bernard" must be configured.
 46 |      */
 47 |     public function testEmpty()
 48 |     {
 49 |         $this->processConfig([]);
 50 |     }
 51 | 
 52 |     /**
 53 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 54 |      */
 55 |     public function testInvalidDriver()
 56 |     {
 57 |         $this->processConfig(['driver' => 'non_existent']);
 58 |     }
 59 | 
 60 |     /**
 61 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 62 |      * @expectedExceptionMessage The "phpamqp_exchange" option must be defined when using the "phpamqp" driver.
 63 |      */
 64 |     public function testPhpAmqpDriverRequiresExchangeOptionToBeSet()
 65 |     {
 66 |         $this->processConfig(['driver' => 'phpamqp']);
 67 |     }
 68 | 
 69 |     /**
 70 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 71 |      * @expectedExceptionMessage The "ironmq_service" option must be defined when using the "ironmq" driver.
 72 |      */
 73 |     public function testIronMqDriverRequiresServiceOptionToBeSet()
 74 |     {
 75 |         $this->processConfig(['driver' => 'ironmq']);
 76 |     }
 77 | 
 78 |     /**
 79 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 80 |      * @expectedExceptionMessage The "sqs_service" option must be defined when using the "sqs" driver.
 81 |      */
 82 |     public function testSqsDriverRequiresServiceOptionToBeSet()
 83 |     {
 84 |         $this->processConfig(['driver' => 'sqs']);
 85 |     }
 86 | 
 87 |     /**
 88 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 89 |      * @expectedExceptionMessage The "pheanstalk_service" option must be defined when using the "pheanstalk" driver.
 90 |      */
 91 |     public function testPheanstalkDriverRequiresServiceOptionToBeSet()
 92 |     {
 93 |         $this->processConfig(['driver' => 'pheanstalk']);
 94 |     }
 95 | 
 96 |     /**
 97 |      * @expectedException \Symfony\Component\Config\Definition\Exception\InvalidConfigurationException
 98 |      * @expectedExceptionMessage The "custom_service" option must be defined when using the "custom" driver.
 99 |      */
100 |     public function testCustomDriverRequiresServiceOptionToBeSet()
101 |     {
102 |         $this->processConfig(['driver' => 'custom']);
103 |     }
104 | 
105 |     /**
106 |      * @param array $config
107 |      *
108 |      * @return array
109 |      */
110 |     private function processConfig(array $config)
111 |     {
112 |         return (new Processor())->processConfiguration(new Configuration(), [$config]);
113 |     }
114 | }
115 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name"        : "bernard/bernard-bundle",
 3 |     "description" : "Integrates Bernard into a Symfony2 application.",
 4 |     "type"        : "symfony-bundle",
 5 |     "homepage"    : "http://bernard.readthedocs.org/",
 6 |     "license"     : "MIT",
 7 | 
 8 |     "autoload" : {
 9 |         "psr-4" : { "Bernard\\BernardBundle\\" : "" },
10 |         "exclude-from-classmap": [
11 |             "/Tests/"
12 |         ]
13 |     },
14 | 
15 |     "require" : {
16 |         "php": "^5.6|^7.0",
17 |         "bernard/bernard": "1.0.0-alpha9",
18 |         "symfony/framework-bundle": "^2.8|^3.2|^4.0|^5.0"
19 |     },
20 | 
21 |     "require-dev" : {
22 |         "symfony/console": "^2.8|^3.0|^4.0",
23 |         "symfony/finder": "^2.8|^3.0|^4.0",
24 |         "symfony/phpunit-bridge": "^3.3"
25 |     },
26 | 
27 |     "extra" : {
28 |         "branch-alias" : {
29 |             "dev-master" : "2.0.x-dev"
30 |         }
31 |     }
32 | }
33 | 


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