[7.14] Rename product error to 'UnsupportedProductError'

Author: sethmlarson

elasticsearch/_async/transport.py

@@ -27,11 +27,10 @@
     ConnectionError,
     ConnectionTimeout,
     ElasticsearchWarning,
-    NotElasticsearchError,
     SerializationError,
     TransportError,
 )
-from ..transport import Transport, _verify_elasticsearch
+from ..transport import Transport, _ProductChecker
 from .compat import get_running_loop
 from .http_aiohttp import AIOHttpConnection
 
@@ -340,12 +339,9 @@ async def perform_request(self, method, url, headers=None, params=None, body=Non
         if self._verified_elasticsearch is None:
             await self._do_verify_elasticsearch(headers=headers, timeout=timeout)
 
-        # If '_verified_elasticsearch' is False we know we're not connected to Elasticsearch.
-        if self._verified_elasticsearch is False:
-            raise NotElasticsearchError(
-                "The client noticed that the server is not Elasticsearch "
-                "and we do not support this unknown product"
-            )
+        # If '_verified_elasticsearch' isn't 'True' then we raise an error.
+        if self._verified_elasticsearch is not True:
+            _ProductChecker.raise_error(self._verified_elasticsearch)
 
         for attempt in range(self.max_retries + 1):
             connection = self.get_connection()
@@ -496,6 +492,6 @@ async def _do_verify_elasticsearch(self, headers, timeout):
                 raise error
 
             # Check the information we got back from the index request.
-            self._verified_elasticsearch = _verify_elasticsearch(
+            self._verified_elasticsearch = _ProductChecker.check_product(
                 info_headers, info_response
             )

elasticsearch/exceptions.py

@@ -51,9 +51,9 @@ class SerializationError(ElasticsearchException):
     """
 
 
-class NotElasticsearchError(ElasticsearchException):
+class UnsupportedProductError(ElasticsearchException):
     """Error which is raised when the client detects
-    it's not connected to an Elasticsearch cluster.
+    it's not connected to a supported product.
     """
 
 

elasticsearch/exceptions.pyi

@@ -20,7 +20,7 @@ from typing import Any, Dict, Union
 class ImproperlyConfigured(Exception): ...
 class ElasticsearchException(Exception): ...
 class SerializationError(ElasticsearchException): ...
-class NotElasticsearchError(ElasticsearchException): ...
+class UnsupportedProductError(ElasticsearchException): ...
 
 class TransportError(ElasticsearchException):
     @property

elasticsearch/transport.py

@@ -31,9 +31,9 @@
     ConnectionError,
     ConnectionTimeout,
     ElasticsearchWarning,
-    NotElasticsearchError,
     SerializationError,
     TransportError,
+    UnsupportedProductError,
 )
 from .serializer import DEFAULT_SERIALIZERS, Deserializer, JSONSerializer
 from .utils import _client_meta_version
@@ -214,8 +214,8 @@ def __init__(
         # - 'True': Means we've verified that we're talking to Elasticsearch or
         #   that we can't rule out Elasticsearch due to auth issues. A warning
         #   will be raised if we receive 401/403.
-        # - 'False': Means we've discovered we're not talking to Elasticsearch,
-        #   should raise an error in this case for every request.
+        # - 'int': Means we're talking to an unsupported product, should raise
+        #   the corresponding error.
         self._verified_elasticsearch = None
 
         # Ensures that the ES verification request only fires once and that
@@ -408,12 +408,9 @@ def perform_request(self, method, url, headers=None, params=None, body=None):
         if self._verified_elasticsearch is None:
             self._do_verify_elasticsearch(headers=headers, timeout=timeout)
 
-        # If '_verified_elasticsearch' is False we know we're not connected to Elasticsearch.
-        if self._verified_elasticsearch is False:
-            raise NotElasticsearchError(
-                "The client noticed that the server is not Elasticsearch "
-                "and we do not support this unknown product"
-            )
+        # If '_verified_elasticsearch' isn't 'True' then we raise an error.
+        if self._verified_elasticsearch is not True:
+            _ProductChecker.raise_error(self._verified_elasticsearch)
 
         for attempt in range(self.max_retries + 1):
             connection = self.get_connection()
@@ -601,53 +598,84 @@ def _do_verify_elasticsearch(self, headers, timeout):
                 raise error
 
             # Check the information we got back from the index request.
-            self._verified_elasticsearch = _verify_elasticsearch(
+            self._verified_elasticsearch = _ProductChecker.check_product(
                 info_headers, info_response
             )
 
 
-def _verify_elasticsearch(headers, response):
-    """Verifies that the server we're talking to is Elasticsearch.
-    Does this by checking HTTP headers and the deserialized
-    response to the 'info' API. Returns 'True' if we're verified
-    against Elasticsearch, 'False' otherwise.
-    """
-    try:
-        version = response.get("version", {})
-        version_number = tuple(
-            int(x) if x is not None else 999
-            for x in re.search(
-                r"^([0-9]+)\.([0-9]+)(?:\.([0-9]+))?", version["number"]
-            ).groups()
-        )
-    except (KeyError, TypeError, ValueError, AttributeError):
-        # No valid 'version.number' field, effectively 0.0.0
-        version = {}
-        version_number = (0, 0, 0)
-
-    # Check all of the fields and headers for missing/valid values.
-    try:
-        bad_tagline = response.get("tagline", None) != "You Know, for Search"
-        bad_build_flavor = version.get("build_flavor", None) != "default"
-        bad_product_header = headers.get("x-elastic-product", None) != "Elasticsearch"
-    except (AttributeError, TypeError):
-        bad_tagline = True
-        bad_build_flavor = True
-        bad_product_header = True
-
-    if (
-        # No version or version less than 6.x
-        version_number < (6, 0, 0)
-        # 6.x and there's a bad 'tagline'
-        or ((6, 0, 0) <= version_number < (7, 0, 0) and bad_tagline)
-        # 7.0-7.13 and there's a bad 'tagline' or 'build_flavor'
-        or (
-            (7, 0, 0) <= version_number < (7, 14, 0)
-            and (bad_tagline or bad_build_flavor)
-        )
-        # 7.14+ and there's a bad 'X-Elastic-Product' HTTP header
-        or ((7, 14, 0) <= version_number and bad_product_header)
-    ):
-        return False
+class _ProductChecker:
+    """Class which verifies we're connected to a supported product"""
+
+    # States that can be returned from 'check_product'
+    SUCCESS = True
+    UNSUPPORTED_PRODUCT = 2
+    UNSUPPORTED_DISTRIBUTION = 3
 
-    return True
+    @classmethod
+    def raise_error(cls, state):
+        # These states mean the product_check() didn't fail so do nothing.
+        if state in (None, True):
+            return
+
+        if state == cls.UNSUPPORTED_DISTRIBUTION:
+            message = (
+                "The client noticed that the server is not "
+                "a supported distribution of Elasticsearch"
+            )
+        else:  # UNSUPPORTED_PRODUCT
+            message = (
+                "The client noticed that the server is not Elasticsearch "
+                "and we do not support this unknown product"
+            )
+        raise UnsupportedProductError(message)
+
+    @classmethod
+    def check_product(cls, headers, response):
+        # type: (dict[str, str], dict[str, str]) -> int
+        """Verifies that the server we're talking to is Elasticsearch.
+        Does this by checking HTTP headers and the deserialized
+        response to the 'info' API. Returns one of the states above.
+        """
+        try:
+            version = response.get("version", {})
+            version_number = tuple(
+                int(x) if x is not None else 999
+                for x in re.search(
+                    r"^([0-9]+)\.([0-9]+)(?:\.([0-9]+))?", version["number"]
+                ).groups()
+            )
+        except (KeyError, TypeError, ValueError, AttributeError):
+            # No valid 'version.number' field, effectively 0.0.0
+            version = {}
+            version_number = (0, 0, 0)
+
+        # Check all of the fields and headers for missing/valid values.
+        try:
+            bad_tagline = response.get("tagline", None) != "You Know, for Search"
+            bad_build_flavor = version.get("build_flavor", None) != "default"
+            bad_product_header = (
+                headers.get("x-elastic-product", None) != "Elasticsearch"
+            )
+        except (AttributeError, TypeError):
+            bad_tagline = True
+            bad_build_flavor = True
+            bad_product_header = True
+
+        # 7.0-7.13 and there's a bad 'tagline' or unsupported 'build_flavor'
+        if (7, 0, 0) <= version_number < (7, 14, 0):
+            if bad_tagline:
+                return cls.UNSUPPORTED_PRODUCT
+            elif bad_build_flavor:
+                return cls.UNSUPPORTED_DISTRIBUTION
+
+        elif (
+            # No version or version less than 6.x
+            version_number < (6, 0, 0)
+            # 6.x and there's a bad 'tagline'
+            or ((6, 0, 0) <= version_number < (7, 0, 0) and bad_tagline)
+            # 7.14+ and there's a bad 'X-Elastic-Product' HTTP header
+            or ((7, 14, 0) <= version_number and bad_product_header)
+        ):
+            return cls.UNSUPPORTED_PRODUCT
+
+        return True

test_elasticsearch/test_async/test_transport.py

@@ -33,10 +33,11 @@
     AuthorizationException,
     ConnectionError,
     ElasticsearchWarning,
-    NotElasticsearchError,
     NotFoundError,
     TransportError,
+    UnsupportedProductError,
 )
+from elasticsearch.transport import _ProductChecker
 
 pytestmark = pytest.mark.asyncio
 
@@ -641,7 +642,7 @@ async def test_verify_elasticsearch(self, headers, data):
             [{"data": data, "headers": headers}], connection_class=DummyConnection
         )
         await t.perform_request("GET", "/_search")
-        assert t._verified_elasticsearch
+        assert t._verified_elasticsearch is True
 
         calls = t.connection_pool.connections[0].calls
         _ = [call[1]["headers"].pop("x-elastic-client-meta") for call in calls]
@@ -688,7 +689,7 @@ async def test_verify_elasticsearch_skips_on_auth_errors(self, exception_cls):
         ]
 
         # Assert that the cluster is "verified"
-        assert t._verified_elasticsearch
+        assert t._verified_elasticsearch is True
 
         # See that the headers were passed along to the "info" request made
         calls = t.connection_pool.connections[0].calls
@@ -762,7 +763,7 @@ async def request_task():
         )
 
         # Assert that the cluster is "verified"
-        assert t._verified_elasticsearch
+        assert t._verified_elasticsearch is True
 
         # See that the first request is always 'GET /' for ES check
         calls = t.connection_pool.connections[0].calls
@@ -771,13 +772,37 @@ async def request_task():
         # The rest of the requests are 'GET /_search' afterwards
         assert all(call[0][:2] == ("GET", "/_search") for call in calls[1:])
 
+    @pytest.mark.parametrize(
+        ["build_flavor", "tagline", "product_error", "error_message"],
+        [
+            (
+                "default",
+                "BAD TAGLINE",
+                _ProductChecker.UNSUPPORTED_PRODUCT,
+                "The client noticed that the server is not Elasticsearch and we do not support this unknown product",
+            ),
+            (
+                "BAD BUILD FLAVOR",
+                "BAD TAGLINE",
+                _ProductChecker.UNSUPPORTED_PRODUCT,
+                "The client noticed that the server is not Elasticsearch and we do not support this unknown product",
+            ),
+            (
+                "BAD BUILD FLAVOR",
+                "You Know, for Search",
+                _ProductChecker.UNSUPPORTED_DISTRIBUTION,
+                "The client noticed that the server is not a supported distribution of Elasticsearch",
+            ),
+        ],
+    )
     async def test_multiple_requests_verify_elasticsearch_product_error(
-        self, event_loop
+        self, event_loop, build_flavor, tagline, product_error, error_message
     ):
         t = AsyncTransport(
             [
                 {
-                    "data": '{"version":{"number":"7.13.0","build_flavor":"default"},"tagline":"BAD TAGLINE"}',
+                    "data": '{"version":{"number":"7.13.0","build_flavor":"%s"},"tagline":"%s"}'
+                    % (build_flavor, tagline),
                     "delay": 1,
                 }
             ],
@@ -806,7 +831,8 @@ async def request_task():
         assert len(results) == 10
 
         # All results were errors
-        assert all(isinstance(result, NotElasticsearchError) for result in results)
+        assert all(isinstance(result, UnsupportedProductError) for result in results)
+        assert all(str(result) == error_message for result in results)
 
         # Assert that one request was made but not 2 requests.
         duration = end_time - start_time
@@ -818,7 +844,7 @@ async def request_task():
         )
 
         # Assert that the cluster is definitely not Elasticsearch
-        assert t._verified_elasticsearch is False
+        assert t._verified_elasticsearch == product_error
 
         # See that the first request is always 'GET /' for ES check
         calls = t.connection_pool.connections[0].calls