EightPointsGuzzleExtension::createHandler() - Code Metrics - Inspection of "Fix issue #258 - add ability to use clients withou..." - 8p/EightPointsGuzzleBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 210f24...3ccc15 )

unknown

created 2019-06-09 20:12 UTC

EightPointsGuzzleExtension::createHandler() B

↳ Parent: EightPointsGuzzleExtension

Complexity

Conditions	6
Paths	24

Size

Total Lines	46
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	26
nc	24
nop	5
dl	0
loc	46
rs	8.8817
c	0
b	0
f	0

<?php

namespace EightPoints\Bundle\GuzzleBundle\DependencyInjection;

use EightPoints\Bundle\GuzzleBundle\Twig\Extension\DebugExtension;
use RuntimeException;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;
use Symfony\Component\ExpressionLanguage\Expression;
use GuzzleHttp\HandlerStack;

class EightPointsGuzzleExtension extends Extension
{
    /** @var \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] */
    protected $plugins;

    /**
     * @param \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] $plugins
     */
    public function __construct(array $plugins = [])
    {
        $this->plugins = $plugins;
    }

    /**
     * {@inheritdoc}
     */
    public function getConfiguration(array $config, ContainerBuilder $container) : Configuration
    {
        return new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
    }

    /**
     * Loads the Guzzle configuration.
     *
     * @param array $configs an array of configuration settings
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container a ContainerBuilder instance
     *
     * @throws \InvalidArgumentException
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
     * @throws \Exception
     *
     * @return void
     */
    public function load(array $configs, ContainerBuilder $container)
    {
        $configPath = implode(DIRECTORY_SEPARATOR, [__DIR__, '..', 'Resources', 'config']);
        $loader     = new XmlFileLoader($container, new FileLocator($configPath));

        $loader->load('services.xml');

        $configuration = new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
        $config        = $this->processConfiguration($configuration, $configs);
        $logging       = $config['logging'] === true;
        $profiling     = $config['profiling'] === true;

        foreach ($this->plugins as $plugin) {
            $container->addObjectResource(new \ReflectionClass(get_class($plugin)));
            $plugin->load($config, $container);
        }

        if ($logging) {
            $this->defineTwigDebugExtension($container);
            $this->defineLogger($container);
            $this->defineDataCollector($container, $config['slow_response_time'] / 1000);
            $this->defineFormatter($container);
            $this->defineSymfonyLogFormatter($container);
            $this->defineSymfonyLogMiddleware($container);
        }

        foreach ($config['clients'] as $name => $options) {
            $argument = [
                'base_uri' => $options['base_url'],
                'handler'  => $this->createHandler($container, $name, $options, $logging, $profiling)
            ];

            // if present, add default options to the constructor argument for the Guzzle client
            if (isset($options['options']) && is_array($options['options'])) {
                foreach ($options['options'] as $key => $value) {
                    if ($value === null || (is_array($value) && count($value) === 0)) {
                        continue;
                    }

                    $argument[$key] = $value;
                }
            }

            $client = new Definition($options['class']);
            $client->addArgument($argument);
            $client->setPublic(true);
            $client->setLazy($options['lazy']);

            // set service name based on client name
            $serviceName = sprintf('%s.client.%s', $this->getAlias(), $name);
            $container->setDefinition($serviceName, $client);
        }
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param string $clientName
     * @param array $options
     * @param bool $logging
     * @param bool $profiling
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     * @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
     *
     * @return \Symfony\Component\DependencyInjection\Definition
     */
    protected function createHandler(ContainerBuilder $container, string $clientName, array $options, bool $logging, bool $profiling) : Definition
    {
        // Event Dispatching service
        $eventServiceName = sprintf('eight_points_guzzle.middleware.event_dispatch.%s', $clientName);
        $eventService = $this->createEventMiddleware($clientName);
        $container->setDefinition($eventServiceName, $eventService);

        // Create the event Dispatch Middleware
        $eventExpression  = new Expression(sprintf("service('%s').dispatchEvent()", $eventServiceName));

        $handler = new Definition(HandlerStack::class);
        $handler->setFactory([HandlerStack::class, 'create']);
        if (isset($options['handler'])) {

            $handlerServiceName = sprintf('eight_points_guzzle.handler.%s', $clientName);
            $handlerService = new Definition($options['handler']);
            $container->setDefinition($handlerServiceName, $handlerService);

            $handler->addArgument(new Reference($handlerServiceName));
        }
        $handler->setPublic(true);
        $handler->setLazy($options['lazy']);

        $handlerStackServiceName = sprintf('eight_points_guzzle.handler_stack.%s', $clientName);
        $container->setDefinition($handlerStackServiceName, $handler);

        if ($logging) {
            $this->defineLogMiddleware($container, $handler, $clientName);
            $this->defineRequestTimeMiddleware($container, $handler, $clientName);
            $this->attachSymfonyLogMiddlewareToHandler($handler);
        }

        if ($profiling) {
            $this->defineProfileMiddleware($container, $handler, $clientName);
        }

        foreach ($this->plugins as $plugin) {
            if (isset($options['plugin'][$plugin->getPluginName()])) {
                $plugin->loadForClient($options['plugin'][$plugin->getPluginName()], $container, $clientName, $handler);
            }
        }

        // goes on the end of the stack.
        $handler->addMethodCall('unshift', [$eventExpression, 'events']);

        return $handler;
    }

    /**
     * @param ContainerBuilder $container
     *
     * @return void
     */
    protected function defineTwigDebugExtension(ContainerBuilder $container)
    {
        $twigDebugExtensionDefinition = new Definition(DebugExtension::class);
        $twigDebugExtensionDefinition->addTag('twig.extension');
        $twigDebugExtensionDefinition->setPublic(false);
        $container->setDefinition('eight_points_guzzle.twig_extension.debug', $twigDebugExtensionDefinition);
    }

    /**
     * Define Logger
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     *
     * @return void
     */
    protected function defineLogger(ContainerBuilder $container)
    {
        $loggerDefinition = new Definition('%eight_points_guzzle.logger.class%');
        $loggerDefinition->setPublic(true);
        $container->setDefinition('eight_points_guzzle.logger', $loggerDefinition);
    }

    /**
     * Define Data Collector
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param float $slowResponseTime
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     *
     * @return void
     */
    protected function defineDataCollector(ContainerBuilder $container, float $slowResponseTime)
    {
        $dataCollectorDefinition = new Definition('%eight_points_guzzle.data_collector.class%');
        $dataCollectorDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
        $dataCollectorDefinition->addArgument($slowResponseTime);
        $dataCollectorDefinition->setPublic(false);
        $dataCollectorDefinition->addTag('data_collector', [
            'id' => 'eight_points_guzzle',
            'template' => '@EightPointsGuzzle/debug.html.twig',
        ]);
        $container->setDefinition('eight_points_guzzle.data_collector', $dataCollectorDefinition);
    }

    /**
     * Define Formatter
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
     *
     * @return void
     */
    protected function defineFormatter(ContainerBuilder $container)
    {
        $formatterDefinition = new Definition('%eight_points_guzzle.formatter.class%');
        $formatterDefinition->setPublic(true);
        $container->setDefinition('eight_points_guzzle.formatter', $formatterDefinition);
    }

    /**
     * Define Request Time Middleware
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     * @param string $clientName
     *
     * @return void
     */
    protected function defineRequestTimeMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
    {
        $requestTimeMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.request_time.%s', $clientName);
        $requestTimeMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.request_time.class%');
        $requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
        $requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.data_collector'));
        $requestTimeMiddlewareDefinition->setPublic(true);
        $container->setDefinition($requestTimeMiddlewareDefinitionName, $requestTimeMiddlewareDefinition);

        $requestTimeExpression = new Expression(sprintf("service('%s')", $requestTimeMiddlewareDefinitionName));
        $handler->addMethodCall('after', ['log', $requestTimeExpression, 'request_time']);
    }

    /**
     * Define Log Middleware for client
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     * @param string $clientName
     *
     * @return void
     */
    protected function defineLogMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
    {
        $logMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.log.%s', $clientName);
        $logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.log.class%');
        $logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
        $logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.formatter'));
        $logMiddlewareDefinition->setPublic(true);
        $container->setDefinition($logMiddlewareDefinitionName, $logMiddlewareDefinition);

        $logExpression = new Expression(sprintf("service('%s').log()", $logMiddlewareDefinitionName));
        $handler->addMethodCall('push', [$logExpression, 'log']);
    }

    /**
     * Define Profile Middleware for client
     *
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     * @param string $clientName
     *
     * @return void
     */
    protected function defineProfileMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
    {
        $profileMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.profile.%s', $clientName);
        $profileMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.profile.class%');
        $profileMiddlewareDefinition->addArgument(new Reference('debug.stopwatch'));
        $profileMiddlewareDefinition->setPublic(true);
        $container->setDefinition($profileMiddlewareDefinitionName, $profileMiddlewareDefinition);

        $profileExpression = new Expression(sprintf("service('%s').profile()", $profileMiddlewareDefinitionName));
        $handler->addMethodCall('push', [$profileExpression, 'profile']);
    }

    /**
     * @param \Symfony\Component\DependencyInjection\Definition $handler
     *
     * @return void
     */
    protected function attachSymfonyLogMiddlewareToHandler(Definition $handler)
    {
        $logExpression = new Expression(sprintf("service('%s')", 'eight_points_guzzle.middleware.symfony_log'));
        $handler->addMethodCall('push', [$logExpression, 'symfony_log']);
    }

    /**
     * Create Middleware For dispatching events
     *
     * @param string $name
     *
     * @return \Symfony\Component\DependencyInjection\Definition
     */
    protected function createEventMiddleware(string $name) : Definition
    {
        $eventMiddleWare = new Definition('%eight_points_guzzle.middleware.event_dispatcher.class%');
        $eventMiddleWare->addArgument(new Reference('event_dispatcher'));
        $eventMiddleWare->addArgument($name);
        $eventMiddleWare->setPublic(true);

        return $eventMiddleWare;
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @return void
     */
    protected function defineSymfonyLogFormatter(ContainerBuilder $container)
    {
        $formatterDefinition = new Definition('%eight_points_guzzle.symfony_log_formatter.class%');
        $formatterDefinition->setArguments(['%eight_points_guzzle.symfony_log_formatter.pattern%']);
        $formatterDefinition->setPublic(true);
        $container->setDefinition('eight_points_guzzle.symfony_log_formatter', $formatterDefinition);
    }

    /**
     * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
     *
     * @return void
     */
    protected function defineSymfonyLogMiddleware(ContainerBuilder $container)
    {
        $logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.symfony_log.class%');
        $logMiddlewareDefinition->addArgument(new Reference('logger'));
        $logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.symfony_log_formatter'));
        $logMiddlewareDefinition->setPublic(true);
        $logMiddlewareDefinition->addTag('monolog.logger', ['channel' => 'eight_points_guzzle']);
        $container->setDefinition('eight_points_guzzle.middleware.symfony_log', $logMiddlewareDefinition);
    }

    /**
     * Returns alias of extension
     *
     * @return string
     */
    public function getAlias() : string
    {
        return 'eight_points_guzzle';
    }
}


1			<?php
2
3			namespace EightPoints\Bundle\GuzzleBundle\DependencyInjection;
4
5			use EightPoints\Bundle\GuzzleBundle\Twig\Extension\DebugExtension;
6			use RuntimeException;
7			use Symfony\Component\DependencyInjection\ContainerBuilder;
8			use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
9			use Symfony\Component\DependencyInjection\Reference;
10			use Symfony\Component\DependencyInjection\Definition;
11			use Symfony\Component\Config\FileLocator;
12			use Symfony\Component\HttpKernel\DependencyInjection\Extension;
13			use Symfony\Component\ExpressionLanguage\Expression;
14			use GuzzleHttp\HandlerStack;
15
16			class EightPointsGuzzleExtension extends Extension
17			{
18			/** @var \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] */
19			protected $plugins;
20
21			/**
22			* @param \EightPoints\Bundle\GuzzleBundle\EightPointsGuzzleBundlePlugin[] $plugins
23			*/
24			public function __construct(array $plugins = [])
25			{
26			$this->plugins = $plugins;
27			}
28
29			/**
30			* {@inheritdoc}
31			*/
32			public function getConfiguration(array $config, ContainerBuilder $container) : Configuration
33			{
34			return new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
35			}
36
37			/**
38			* Loads the Guzzle configuration.
39			*
40			* @param array $configs an array of configuration settings
41			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container a ContainerBuilder instance
42			*
43			* @throws \InvalidArgumentException
44			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
45			* @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
46			* @throws \Exception
47			*
48			* @return void
49			*/
50			public function load(array $configs, ContainerBuilder $container)
51			{
52			$configPath = implode(DIRECTORY_SEPARATOR, [__DIR__, '..', 'Resources', 'config']);
53			$loader = new XmlFileLoader($container, new FileLocator($configPath));
54
55			$loader->load('services.xml');
56
57			$configuration = new Configuration($this->getAlias(), $container->getParameter('kernel.debug'), $this->plugins);
58			$config = $this->processConfiguration($configuration, $configs);
59			$logging = $config['logging'] === true;
60			$profiling = $config['profiling'] === true;
61
62			foreach ($this->plugins as $plugin) {
63			$container->addObjectResource(new \ReflectionClass(get_class($plugin)));
64			$plugin->load($config, $container);
65			}
66
67			if ($logging) {
68			$this->defineTwigDebugExtension($container);
69			$this->defineLogger($container);
70			$this->defineDataCollector($container, $config['slow_response_time'] / 1000);
71			$this->defineFormatter($container);
72			$this->defineSymfonyLogFormatter($container);
73			$this->defineSymfonyLogMiddleware($container);
74			}
75
76			foreach ($config['clients'] as $name => $options) {
77			$argument = [
78			'base_uri' => $options['base_url'],
79			'handler' => $this->createHandler($container, $name, $options, $logging, $profiling)
80			];
81
82			// if present, add default options to the constructor argument for the Guzzle client
83			if (isset($options['options']) && is_array($options['options'])) {
84			foreach ($options['options'] as $key => $value) {
85			if ($value === null \|\| (is_array($value) && count($value) === 0)) {
86			continue;
87			}
88
89			$argument[$key] = $value;
90			}
91			}
92
93			$client = new Definition($options['class']);
94			$client->addArgument($argument);
95			$client->setPublic(true);
96			$client->setLazy($options['lazy']);
97
98			// set service name based on client name
99			$serviceName = sprintf('%s.client.%s', $this->getAlias(), $name);
100			$container->setDefinition($serviceName, $client);
101			}
102			}
103
104			/**
105			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
106			* @param string $clientName
107			* @param array $options
108			* @param bool $logging
109			* @param bool $profiling
110			*
111			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
112			* @throws \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
113			*
114			* @return \Symfony\Component\DependencyInjection\Definition
115			*/
116			protected function createHandler(ContainerBuilder $container, string $clientName, array $options, bool $logging, bool $profiling) : Definition
117			{
118			// Event Dispatching service
119			$eventServiceName = sprintf('eight_points_guzzle.middleware.event_dispatch.%s', $clientName);
120			$eventService = $this->createEventMiddleware($clientName);
121			$container->setDefinition($eventServiceName, $eventService);
122
123			// Create the event Dispatch Middleware
124			$eventExpression = new Expression(sprintf("service('%s').dispatchEvent()", $eventServiceName));
125
126			$handler = new Definition(HandlerStack::class);
127			$handler->setFactory([HandlerStack::class, 'create']);
128			if (isset($options['handler'])) {
129
130			$handlerServiceName = sprintf('eight_points_guzzle.handler.%s', $clientName);
131			$handlerService = new Definition($options['handler']);
132			$container->setDefinition($handlerServiceName, $handlerService);
133
134			$handler->addArgument(new Reference($handlerServiceName));
135			}
136			$handler->setPublic(true);
137			$handler->setLazy($options['lazy']);
138
139			$handlerStackServiceName = sprintf('eight_points_guzzle.handler_stack.%s', $clientName);
140			$container->setDefinition($handlerStackServiceName, $handler);
141
142			if ($logging) {
143			$this->defineLogMiddleware($container, $handler, $clientName);
144			$this->defineRequestTimeMiddleware($container, $handler, $clientName);
145			$this->attachSymfonyLogMiddlewareToHandler($handler);
146			}
147
148			if ($profiling) {
149			$this->defineProfileMiddleware($container, $handler, $clientName);
150			}
151
152			foreach ($this->plugins as $plugin) {
153			if (isset($options['plugin'][$plugin->getPluginName()])) {
154			$plugin->loadForClient($options['plugin'][$plugin->getPluginName()], $container, $clientName, $handler);
155			}
156			}
157
158			// goes on the end of the stack.
159			$handler->addMethodCall('unshift', [$eventExpression, 'events']);
160
161			return $handler;
162			}
163
164			/**
165			* @param ContainerBuilder $container
166			*
167			* @return void
168			*/
169			protected function defineTwigDebugExtension(ContainerBuilder $container)
170			{
171			$twigDebugExtensionDefinition = new Definition(DebugExtension::class);
172			$twigDebugExtensionDefinition->addTag('twig.extension');
173			$twigDebugExtensionDefinition->setPublic(false);
174			$container->setDefinition('eight_points_guzzle.twig_extension.debug', $twigDebugExtensionDefinition);
175			}
176
177			/**
178			* Define Logger
179			*
180			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
181			*
182			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
183			*
184			* @return void
185			*/
186			protected function defineLogger(ContainerBuilder $container)
187			{
188			$loggerDefinition = new Definition('%eight_points_guzzle.logger.class%');
189			$loggerDefinition->setPublic(true);
190			$container->setDefinition('eight_points_guzzle.logger', $loggerDefinition);
191			}
192
193			/**
194			* Define Data Collector
195			*
196			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
197			* @param float $slowResponseTime
198			*
199			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
200			*
201			* @return void
202			*/
203			protected function defineDataCollector(ContainerBuilder $container, float $slowResponseTime)
204			{
205			$dataCollectorDefinition = new Definition('%eight_points_guzzle.data_collector.class%');
206			$dataCollectorDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
207			$dataCollectorDefinition->addArgument($slowResponseTime);
208			$dataCollectorDefinition->setPublic(false);
209			$dataCollectorDefinition->addTag('data_collector', [
210			'id' => 'eight_points_guzzle',
211			'template' => '@EightPointsGuzzle/debug.html.twig',
212			]);
213			$container->setDefinition('eight_points_guzzle.data_collector', $dataCollectorDefinition);
214			}
215
216			/**
217			* Define Formatter
218			*
219			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
220			*
221			* @throws \Symfony\Component\DependencyInjection\Exception\BadMethodCallException
222			*
223			* @return void
224			*/
225			protected function defineFormatter(ContainerBuilder $container)
226			{
227			$formatterDefinition = new Definition('%eight_points_guzzle.formatter.class%');
228			$formatterDefinition->setPublic(true);
229			$container->setDefinition('eight_points_guzzle.formatter', $formatterDefinition);
230			}
231
232			/**
233			* Define Request Time Middleware
234			*
235			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
236			* @param \Symfony\Component\DependencyInjection\Definition $handler
237			* @param string $clientName
238			*
239			* @return void
240			*/
241			protected function defineRequestTimeMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
242			{
243			$requestTimeMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.request_time.%s', $clientName);
244			$requestTimeMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.request_time.class%');
245			$requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
246			$requestTimeMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.data_collector'));
247			$requestTimeMiddlewareDefinition->setPublic(true);
248			$container->setDefinition($requestTimeMiddlewareDefinitionName, $requestTimeMiddlewareDefinition);
249
250			$requestTimeExpression = new Expression(sprintf("service('%s')", $requestTimeMiddlewareDefinitionName));
251			$handler->addMethodCall('after', ['log', $requestTimeExpression, 'request_time']);
252			}
253
254			/**
255			* Define Log Middleware for client
256			*
257			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
258			* @param \Symfony\Component\DependencyInjection\Definition $handler
259			* @param string $clientName
260			*
261			* @return void
262			*/
263			protected function defineLogMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
264			{
265			$logMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.log.%s', $clientName);
266			$logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.log.class%');
267			$logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.logger'));
268			$logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.formatter'));
269			$logMiddlewareDefinition->setPublic(true);
270			$container->setDefinition($logMiddlewareDefinitionName, $logMiddlewareDefinition);
271
272			$logExpression = new Expression(sprintf("service('%s').log()", $logMiddlewareDefinitionName));
273			$handler->addMethodCall('push', [$logExpression, 'log']);
274			}
275
276			/**
277			* Define Profile Middleware for client
278			*
279			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
280			* @param \Symfony\Component\DependencyInjection\Definition $handler
281			* @param string $clientName
282			*
283			* @return void
284			*/
285			protected function defineProfileMiddleware(ContainerBuilder $container, Definition $handler, string $clientName)
286			{
287			$profileMiddlewareDefinitionName = sprintf('eight_points_guzzle.middleware.profile.%s', $clientName);
288			$profileMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.profile.class%');
289			$profileMiddlewareDefinition->addArgument(new Reference('debug.stopwatch'));
290			$profileMiddlewareDefinition->setPublic(true);
291			$container->setDefinition($profileMiddlewareDefinitionName, $profileMiddlewareDefinition);
292
293			$profileExpression = new Expression(sprintf("service('%s').profile()", $profileMiddlewareDefinitionName));
294			$handler->addMethodCall('push', [$profileExpression, 'profile']);
295			}
296
297			/**
298			* @param \Symfony\Component\DependencyInjection\Definition $handler
299			*
300			* @return void
301			*/
302			protected function attachSymfonyLogMiddlewareToHandler(Definition $handler)
303			{
304			$logExpression = new Expression(sprintf("service('%s')", 'eight_points_guzzle.middleware.symfony_log'));
305			$handler->addMethodCall('push', [$logExpression, 'symfony_log']);
306			}
307
308			/**
309			* Create Middleware For dispatching events
310			*
311			* @param string $name
312			*
313			* @return \Symfony\Component\DependencyInjection\Definition
314			*/
315			protected function createEventMiddleware(string $name) : Definition
316			{
317			$eventMiddleWare = new Definition('%eight_points_guzzle.middleware.event_dispatcher.class%');
318			$eventMiddleWare->addArgument(new Reference('event_dispatcher'));
319			$eventMiddleWare->addArgument($name);
320			$eventMiddleWare->setPublic(true);
321
322			return $eventMiddleWare;
323			}
324
325			/**
326			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
327			*
328			* @return void
329			*/
330			protected function defineSymfonyLogFormatter(ContainerBuilder $container)
331			{
332			$formatterDefinition = new Definition('%eight_points_guzzle.symfony_log_formatter.class%');
333			$formatterDefinition->setArguments(['%eight_points_guzzle.symfony_log_formatter.pattern%']);
334			$formatterDefinition->setPublic(true);
335			$container->setDefinition('eight_points_guzzle.symfony_log_formatter', $formatterDefinition);
336			}
337
338			/**
339			* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
340			*
341			* @return void
342			*/
343			protected function defineSymfonyLogMiddleware(ContainerBuilder $container)
344			{
345			$logMiddlewareDefinition = new Definition('%eight_points_guzzle.middleware.symfony_log.class%');
346			$logMiddlewareDefinition->addArgument(new Reference('logger'));
347			$logMiddlewareDefinition->addArgument(new Reference('eight_points_guzzle.symfony_log_formatter'));
348			$logMiddlewareDefinition->setPublic(true);
349			$logMiddlewareDefinition->addTag('monolog.logger', ['channel' => 'eight_points_guzzle']);
350			$container->setDefinition('eight_points_guzzle.middleware.symfony_log', $logMiddlewareDefinition);
351			}
352
353			/**
354			* Returns alias of extension
355			*
356			* @return string
357			*/
358			public function getAlias() : string
359			{
360			return 'eight_points_guzzle';
361			}
362			}
363

8p / EightPointsGuzzleBundle

GitHub Access Token became invalid

Push — master ( 210f24...3ccc15 )

EightPointsGuzzleExtension::createHandler() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like