Let user configure what do be found in discovery and if profiling should be used.

Author: Nyholm

Collector/PluginJournal.php

@@ -21,7 +21,11 @@ final class PluginJournal
      */
     public function getPlugins($clientName)
     {
-        return $this->data[$clientName];
+        if (isset($this->data[$clientName])) {
+            return $this->data[$clientName];
+        }
+
+        return [];
     }
 
     /**

DependencyInjection/Configuration.php

@@ -83,6 +83,8 @@ public function getConfigTreeBuilder()
                             ->defaultValue('auto')
                         ->end()
                         ->scalarNode('formatter')->defaultNull()->end()
+                        ->booleanNode('profile_discovered_client')->defaultTrue()->end()
+                        ->booleanNode('profile_discovered_async_client')->defaultFalse()->end()
                         ->scalarNode('captured_body_length')
                             ->defaultValue(0)
                             ->canNotBeEmpty()
@@ -124,6 +126,11 @@ protected function configureClients(ArrayNodeDefinition $root)
                         ->defaultFalse()
                         ->info('Set to true to get the client wrapped in a HttpMethodsClient which emulates provides functions for HTTP verbs.')
                     ->end()
+                    ->enumNode('use_with_discovery')
+                        ->values(['async_client', 'http_client', false])
+                        ->defaultFalse()
+                        ->info('If set to "http_client" this will be the client return when using dicovery to find a HTTP client.')
+                    ->end()
                     ->arrayNode('plugins')
                         ->info('A list of service ids of plugins. The order is important.')
                         ->prototype('scalar')->end()

DependencyInjection/HttplugExtension.php

@@ -6,6 +6,7 @@
 use Http\Client\Common\HttpMethodsClient;
 use Http\Client\Common\Plugin\AuthenticationPlugin;
 use Http\Client\Common\PluginClient;
+use Http\Discovery\HttpAsyncClientDiscovery;
 use Http\HttplugBundle\ClientFactory\DummyClient;
 use Http\HttplugBundle\Collector\DebugPlugin;
 use Http\Message\Authentication\BasicAuth;
@@ -65,6 +66,7 @@ public function load(array $configs, ContainerBuilder $container)
 
         $this->configurePlugins($container, $config['plugins']);
         $this->configureClients($container, $config);
+        $this->configureAutoDiscoveryClients($container, $config);
     }
 
     /**
@@ -278,4 +280,72 @@ private function registerDebugPlugin(ContainerBuilder $container, $name)
 
         return $serviceIdDebugPlugin;
     }
+
+    /**
+     * Make sure we inject the debug plugin for clients found by auto discovery.
+     *
+     * @param ContainerBuilder $container
+     * @param array            $config
+     */
+    private function configureAutoDiscoveryClients(ContainerBuilder $container, array $config)
+    {
+        $httpClient = null;
+        $asyncHttpClient = null;
+
+        // Verify if any clients were specifucally set to function as auto discoverable.
+        foreach ($config['clients'] as $name => $arguments) {
+            if ($arguments['use_with_discovery'] === 'http_client') {
+                if ($httpClient !== null) {
+                    throw new \LogicException('Only one client can configured with "use_with_discovery: http_client".');
+                }
+                $httpClient = new Reference('httplug.client.'.$name);
+            } elseif ($arguments['use_with_discovery'] === 'async_client') {
+                if ($asyncHttpClient !== null) {
+                    throw new \LogicException('Only one client can be configured with "use_with_discovery: async_client".');
+                }
+                $asyncHttpClient = new Reference('httplug.client.'.$name);
+            }
+        }
+
+        if ($httpClient === null) {
+            // Use auto discovery
+            if ($config['toolbar']['profile_discovered_client']) {
+                $httpClient = $this->registerAutoDiscoverableClientWithDebugPlugin($container, 'client');
+            }
+        }
+
+        if ($asyncHttpClient === null) {
+            // Use auto discovery
+            if ($config['toolbar']['profile_discovered_async_client']) {
+                $asyncHttpClient = $this->registerAutoDiscoverableClientWithDebugPlugin($container, 'async_client');
+            }
+        }
+
+
+        $container->getDefinition('httplug.strategy')
+            ->addArgument($httpClient)
+            ->addArgument($asyncHttpClient);
+    }
+
+    /**
+     * @param ContainerBuilder $container
+     * @param $name
+     *
+     * @return Reference
+     */
+    private function registerAutoDiscoverableClientWithDebugPlugin(ContainerBuilder $container, $name)
+    {
+        $definition = $container->register('httplug.auto_discovery_'.$name.'.pure', DummyClient::class);
+        $definition->setPublic(false);
+        $definition->setFactory([HttpAsyncClientDiscovery::class, 'find']);
+
+        $serviceIdDebugPlugin = $this->registerDebugPlugin($container, 'auto_discovery_'.$name);
+        $container->register('httplug.auto_discovery_'.$name.'.plugin', PluginClient::class)
+            ->setPublic(false)
+            ->addArgument(new Reference('httplug.auto_discovery_'.$name.'.pure'))
+            ->addArgument([])
+            ->addArgument(['debug_plugins' => [new Reference($serviceIdDebugPlugin)]]);
+
+        return new Reference('httplug.auto_discovery_'.$name.'.plugin');
+    }
 }

Discovery/ConfiguredClientsStrategy.php

@@ -3,6 +3,7 @@
 namespace Http\HttplugBundle\Discovery;
 
 use Http\Client\HttpClient;
+use Http\Client\HttpAsyncClient;
 use Http\Discovery\HttpClientDiscovery;
 use Http\Discovery\Strategy\DiscoveryStrategy;
 use Symfony\Component\Console\ConsoleEvents;
@@ -24,11 +25,18 @@ class ConfiguredClientsStrategy implements DiscoveryStrategy, EventSubscriberInt
     private static $client;
 
     /**
-     * @param HttpClient $httpClient
+     * @var HttpAsyncClient
      */
-    public function __construct(HttpClient $httpClient)
+    private static $asyncClient;
+
+    /**
+     * @param HttpClient      $httpClient
+     * @param HttpAsyncClient $asyncClient
+     */
+    public function __construct(HttpClient $httpClient = null, HttpAsyncClient $asyncClient = null)
     {
         static::$client = $httpClient;
+        static::$asyncClient = $asyncClient;
     }
 
     /**
@@ -42,6 +50,12 @@ public static function getCandidates($type)
             }]];
         }
 
+        if (static::$asyncClient !== null && $type == HttpAsyncClient::class) {
+            return [['class' => function () {
+                return static::$asyncClient;
+            }]];
+        }
+
         return [];
     }
 

Resources/config/services.xml

@@ -5,7 +5,6 @@
 
     <services>
         <service id="httplug.strategy" class="Http\HttplugBundle\Discovery\ConfiguredClientsStrategy" public="true">
-            <argument type="service" id="httplug.client"/>
             <tag name="kernel.event_subscriber"/>
         </service>