Added AdapterOptions class and setNodePool() in ClientBuilder

Author: ezimuel

BREAKING_CHANGES.md

@@ -5,13 +5,14 @@ We tried to reduce the BC breaks as much as possible but there are some (big) di
 
 ## Architectural changes:
 
-- we changed the namespace, now everything is under `Elastic\Elasticsearch`;
+- we changed the namespace, now everything is under `Elastic\Elasticsearch`
 - we used the [elastic-transport-php](https://github.com/elastic/elastic-transport-php) library for HTTP communications;
 - we changed the `Exception` model, using the namespace `Elastic\Elasticsearch\Exception`. All the exceptions extends the
-  `ElasticsearchException` interface, as in 7.x;
+  `ElasticsearchException` interface, as in 7.x
 - we changed the response type of each endpoints using an [Elasticsearch](src/Response/Elasticsearch.php) response class.
   This class wraps a a [PSR-7](https://www.php-fig.org/psr/psr-7/) response allowing the access of the body response
   as array or object. This means you can access the API response as in 7.x, no BC break here! :angel:
+- we changed the `ConnectionPool` in `NodePool`. The `connection` naming was ambigous since the objects are nodes (hosts)
 
 ## Specific changes:
 
@@ -24,15 +25,15 @@ The following functions has been removed:
 - `ClientBuilder::multiHandler()`
 - `ClientBuilder::singleHandler()`
 - `ClientBuilder::setConnectionFactory()`
-- `ClientBuilder::setConnectionPool()`
+- `ClientBuilder::setConnectionPool()`, you can use `ClientBuilder::setNodePool` instead
 - `ClientBuilder::setEndpoint()`
 - `ClientBuilder::registerNamespace()`
 - `ClientBuilder::setTransport()`, you can specify an HTTP PSR-18 client using `ClientBuilder::setHttpClient()`
 - `ClientBuilder::setHandler()`
 - `ClientBuilder::setTracer()`, you can only set a Logger using  `ClientBuilder::setLogger()`
 - `ClientBuilder::setSerializer()`
 - `ClientBuilder::setConnectionParams()`, you can use `ClientBuilder::setHttpClientOptions()` instead
-- `ClientBuilder::setSelector()`
+- `ClientBuilder::setSelector()`, you can set a `Selector` using the `setNodePool`, see [here](https://github.com/elastic/elastic-transport-php/blob/8.x/README.md#use-a-custom-selector) for more information
 - `ClientBuilder::setSniffOnStart()`
 - `ClientBuilder::includePortInHostHeader()`
 

src/ClientBuilder.php

@@ -19,27 +19,39 @@
 use Elastic\Elasticsearch\Exception\HttpClientException;
 use Elastic\Elasticsearch\Exception\InvalidArgumentException;
 use Elastic\Elasticsearch\Transport\Adapter\AdapterInterface;
+use Elastic\Elasticsearch\Transport\Adapter\AdapterOptions;
 use Elastic\Elasticsearch\Transport\RequestOptions;
-use Elastic\Transport\Transport;
+use Elastic\Transport\NodePool\NodePoolInterface;
 use Elastic\Transport\TransportBuilder;
 use Http\Client\HttpAsyncClient;
 use Psr\Http\Client\ClientInterface;
 use Psr\Log\LoggerInterface;
-use Psr\Log\NullLogger;
 use ReflectionClass;
 
 class ClientBuilder
 {
     const DEFAULT_HOST = 'localhost:9200';
-    const HTTP_ADAPTERS = [
-        "GuzzleHttp\\Client" => "Elastic\\Elasticsearch\\Transport\\Adapter\\Guzzle"
-    ];
 
-    private Transport $transport;
+    /**
+     * PSR-18 client
+     */
     private ClientInterface $httpClient;
+
+    /**
+     * The HTTP async client
+     */
     private HttpAsyncClient $asyncHttpClient;
+
+    /**
+     * PSR-3 Logger
+     */
     private LoggerInterface $logger;
 
+    /**
+     * The NodelPool
+     */
+    private NodePoolInterface $nodePool;
+
     /**
      * Hosts (elasticsearch nodes)
      */
@@ -181,6 +193,15 @@ public function setLogger(LoggerInterface $logger): ClientBuilder
         return $this;
     }
 
+    /**
+     * Set the NodePool
+     */
+    public function setNodePool(NodePoolInterface $nodePool): ClientBuilder
+    {
+        $this->nodePool = $nodePool;
+        return $this;
+    }
+
     /**
      * Set the hosts (nodes)
      */
@@ -290,21 +311,21 @@ public function setHttpClientOptions(array $options): ClientBuilder
      */
     public function build(): Client
     {
-        // Logger
-        if (empty($this->logger)) {
-            $this->logger = new NullLogger();
-        }
+        // Transport builder
+        $builder = TransportBuilder::create();
 
         // Set the default hosts if empty
         if (empty($this->hosts)) {
             $this->hosts = [self::DEFAULT_HOST];
         }
-
-        // Transport
-        $builder = TransportBuilder::create();    
-        $builder->setLogger($this->logger);
         $builder->setHosts($this->hosts);
 
+        // Logger
+        if (!empty($this->logger)) {    
+            $builder->setLogger($this->logger);
+        }
+
+        // Http client
         if (!empty($this->httpClient)) {
             $builder->setClient($this->httpClient);
         } else {
@@ -315,44 +336,49 @@ public function build(): Client
                 );
             }
         }
+
+        // Cloud id
         if (!empty($this->cloudId)) {
             $builder->setCloudId($this->cloudId);
         }
+
+        // Node Pool
         if (!empty($this->nodePool)) {
             $builder->setNodePool($this->nodePool);
         }
-        $this->transport = $builder->build();
+
+        $transport = $builder->build();
 
         // The default retries is equal to the number of hosts
         if (empty($this->retries)) {
             $this->retries = count($this->hosts);
         }
-        $this->transport->setRetries($this->retries);
+        $transport->setRetries($this->retries);
 
         // Async client
         if (!empty($this->asyncHttpClient)) {
-            $this->transport->setAsyncClient($this->asyncHttpClient);
+            $transport->setAsyncClient($this->asyncHttpClient);
         }
 
         // Basic authentication
         if (!empty($this->username) && !empty($this->password)) {
-            $this->transport->setUserInfo($this->username, $this->password);
+            $transport->setUserInfo($this->username, $this->password);
         }
 
         // API key
         if (!empty($this->apiKey)) {
             if (!empty($this->username)) {
                 throw new AuthenticationException('You cannot use APIKey and Basic Authenication together');
             }
-            $this->transport->setHeader('Authorization', sprintf("ApiKey %s", $this->apiKey));
+            $transport->setHeader('Authorization', sprintf("ApiKey %s", $this->apiKey));
         }
 
         // Elastic cloud optimized with gzip
         if (!empty($this->cloudId)) {
-            $this->transport->setHeader('Accept-Encoding', 'gzip');
+            $transport->setHeader('Accept-Encoding', 'gzip');
         }
 
-        $client = new Client($this->transport, $this->logger);
+        $client = new Client($transport, $transport->getLogger());
         // Enable or disable the x-elastic-client-meta header
         $client->setElasticMetaHeader($this->elasticMetaHeader);
 
@@ -386,13 +412,13 @@ protected function setOptions(ClientInterface $client, array $config, array $cli
             return $client;
         }
         $class = get_class($client);
-        if (!isset(self::HTTP_ADAPTERS[$class])) {
+        if (!isset(AdapterOptions::HTTP_ADAPTERS[$class])) {
             throw new HttpClientException(sprintf(
                 "The HTTP client %s is not supported for custom options",
                 $class
             ));
         }
-        $adapterClass = self::HTTP_ADAPTERS[$class];
+        $adapterClass = AdapterOptions::HTTP_ADAPTERS[$class];
         if (!class_exists($adapterClass) || !in_array(AdapterInterface::class, class_implements($adapterClass))) {
             throw new HttpClientException(sprintf(
                 "The class %s does not exists or does not implement %s",

src/Transport/Adapter/AdapterOptions.php

@@ -0,0 +1,25 @@
+<?php
+/**
+ * Elasticsearch PHP Client
+ *
+ * @link      https://github.com/elastic/elasticsearch-php
+ * @copyright Copyright (c) Elasticsearch B.V (https://www.elastic.co)
+ * @license   https://opensource.org/licenses/MIT MIT License
+ *
+ * Licensed to Elasticsearch B.V under one or more agreements.
+ * Elasticsearch B.V licenses this file to you under the MIT License.
+ * See the LICENSE file in the project root for more information.
+ */
+declare(strict_types = 1);
+
+namespace Elastic\Elasticsearch\Transport\Adapter;
+
+/**
+ * The HTTP client adapters supported
+ */
+final class AdapterOptions
+{
+    const HTTP_ADAPTERS = [
+        "GuzzleHttp\\Client" => "Elastic\\Elasticsearch\\Transport\\Adapter\\Guzzle"
+    ];
+}

tests/ClientBuilderTest.php

@@ -19,6 +19,7 @@
 use Elastic\Elasticsearch\Exception\AuthenticationException;
 use Elastic\Elasticsearch\Exception\ConfigException;
 use Elastic\Elasticsearch\Exception\InvalidArgumentException;
+use Elastic\Transport\NodePool\NodePoolInterface;
 use Http\Client\HttpAsyncClient;
 use Nyholm\Psr7\Factory\Psr17Factory;
 use PHPUnit\Framework\TestCase;
@@ -35,6 +36,7 @@ public function setUp(): void
         $this->httpClient = $this->createStub(ClientInterface::class);
         $this->asyncHttpClient = $this->createStub(HttpAsyncClient::class);
         $this->logger = $this->createStub(LoggerInterface::class);
+        $this->nodePool = $this->createStub(NodePoolInterface::class);
         $this->psr17Factory = new Psr17Factory();
         $this->builder = ClientBuilder::create();
     }
@@ -116,6 +118,12 @@ public function testSetLogger()
         $this->assertEquals($this->builder, $result);
     }
 
+    public function testSetNodePool()
+    {
+        $result = $this->builder->setNodePool($this->nodePool);
+        $this->assertEquals($this->builder, $result);
+    }
+
     public function testSetHosts()
     {
         $result = $this->builder->setHosts(['localhost:9200']);

tests/ClientTest.php

@@ -15,11 +15,11 @@
 namespace Elastic\Elasticsearch\Tests;
 
 use Elastic\Elasticsearch\Client;
-use Elastic\Elasticsearch\Exception\NamespaceException;
 use Elastic\Elasticsearch\Exception\ProductCheckException;
 use Elastic\Elasticsearch\Exception\ClientResponseException;
 use Elastic\Elasticsearch\Exception\ServerResponseException;
 use Elastic\Elasticsearch\Response\Elasticsearch;
+use Elastic\Transport\NodePool\NodePoolInterface;
 use Elastic\Transport\TransportBuilder;
 use Http\Mock\Client as MockClient;
 use Http\Promise\Promise;
@@ -33,12 +33,10 @@ public function setUp(): void
     {
         $this->logger = $this->createStub(LoggerInterface::class);
         $this->httpClient = new MockClient();
-        //$this->httpAsyncClient = $this->createStub(HttpAsyncClient::class);
 
         $this->transport = TransportBuilder::create()
             ->setClient($this->httpClient)
             ->build();
-        //$this->transport->setAsyncClient($this->httpAsyncClient);
 
         $this->psr17Factory = new Psr17Factory();
         $this->client = new Client($this->transport, $this->logger);
@@ -59,20 +57,20 @@ public function testDefaultAsyncIsFalse()
         $this->assertFalse($this->client->getAsync());
     }
 
-    public function testSetAsync()
+    public function testSetGetAsync()
     {
         $async = $this->client->getAsync();
         $this->client->setAsync(!$async);
         $this->assertEquals(!$async, $this->client->getAsync());
     }
 
-    public function testSetElasticMetaHeader()
+    public function testSetGetElasticMetaHeader()
     {
         $this->client->setElasticMetaHeader(false);
         $this->assertFalse($this->client->getElasticMetaHeader());
     }
 
-    public function testSetResponseException()
+    public function testSetGetResponseException()
     {
         $this->client->setResponseException(false);
         $this->assertFalse($this->client->getResponseException());