Added version restrictions

Author: vladvildanov

redis/connection.py

@@ -9,7 +9,7 @@
 from itertools import chain
 from queue import Empty, Full, LifoQueue
 from time import time
-from typing import Any, Callable, List, Optional, Type, Union
+from typing import Any, Callable, List, Optional, Type, Union, Dict
 from urllib.parse import parse_qs, unquote, urlparse
 
 from redis.cache import (
@@ -43,7 +43,7 @@
     SSL_AVAILABLE,
     format_error_message,
     get_lib_version,
-    str_if_bytes,
+    str_if_bytes, compare_versions,
 )
 
 if HIREDIS_AVAILABLE:
@@ -197,6 +197,11 @@ def pack_command(self, *args):
     def pack_commands(self, commands):
         pass
 
+    @property
+    @abstractmethod
+    def handshake_metadata(self) -> Union[Dict[bytes, bytes], Dict[str, str]]:
+        pass
+
 
 class AbstractConnection(ConnectionInterface):
     "Manages communication to and from a Redis server"
@@ -272,6 +277,7 @@ def __init__(
         self.next_health_check = 0
         self.redis_connect_func = redis_connect_func
         self.encoder = Encoder(encoding, encoding_errors, decode_responses)
+        self.handshake_metadata = None
         self._sock = None
         self._socket_read_size = socket_read_size
         self.set_parser(parser_class)
@@ -414,7 +420,7 @@ def on_connect(self):
             if len(auth_args) == 1:
                 auth_args = ["default", auth_args[0]]
             self.send_command("HELLO", self.protocol, "AUTH", *auth_args)
-            response = self.read_response()
+            self.handshake_metadata = self.read_response()
             # if response.get(b"proto") != self.protocol and response.get(
             #     "proto"
             # ) != self.protocol:
@@ -445,10 +451,10 @@ def on_connect(self):
                 self._parser.EXCEPTION_CLASSES = parser.EXCEPTION_CLASSES
                 self._parser.on_connect(self)
             self.send_command("HELLO", self.protocol)
-            response = self.read_response()
+            self.handshake_metadata = self.read_response()
             if (
-                response.get(b"proto") != self.protocol
-                and response.get("proto") != self.protocol
+                self.handshake_metadata.get(b"proto") != self.protocol
+                and self.handshake_metadata.get("proto") != self.protocol
             ):
                 raise ConnectionError("Invalid RESP version")
 
@@ -649,6 +655,14 @@ def pack_commands(self, commands):
     def get_protocol(self) -> int or str:
         return self.protocol
 
+    @property
+    def handshake_metadata(self) -> Union[Dict[bytes, bytes], Dict[str, str]]:
+        return self._handshake_metadata
+
+    @handshake_metadata.setter
+    def handshake_metadata(self, value: Union[Dict[bytes, bytes], Dict[str, str]]):
+        self._handshake_metadata = value
+
 
 class Connection(AbstractConnection):
     "Manages TCP communication to and from a Redis server"
@@ -731,6 +745,7 @@ def ensure_string(key):
 
 class CacheProxyConnection(ConnectionInterface):
     DUMMY_CACHE_VALUE = b"foo"
+    MIN_ALLOWED_VERSION = '7.4.0'
 
     def __init__(self, conn: ConnectionInterface, cache: CacheInterface):
         self.pid = os.getpid()
@@ -759,6 +774,17 @@ def set_parser(self, parser_class):
     def connect(self):
         self._conn.connect()
 
+        server_ver = self._conn.handshake_metadata.get(b"version", None)
+        if server_ver is None:
+            raise ConnectionError("Cannot retrieve information about server version")
+
+        server_ver = server_ver.decode("utf-8")
+
+        if compare_versions(server_ver, self.MIN_ALLOWED_VERSION) == 1:
+            raise ConnectionError(
+                "Server version does not satisfies a minimal requirement for client-side caching"
+            )
+
     def on_connect(self):
         self._conn.on_connect()
 

redis/utils.py

@@ -153,3 +153,33 @@ def format_error_message(host_error: str, exception: BaseException) -> str:
             f"Error {exception.args[0]} connecting to {host_error}. "
             f"{exception.args[1]}."
         )
+
+
+def compare_versions(version1: str, version2: str) -> int:
+    """
+    Compare two versions.
+
+    :return: -1 if version1 > version2
+             0 if both versions are equal
+             1 if version1 < version2
+    """
+
+    num_versions1 = list(map(int, version1.split(".")))
+    num_versions2 = list(map(int, version2.split(".")))
+
+    if len(num_versions1) > len(num_versions2):
+        diff = len(num_versions1) - len(num_versions2)
+        for _ in range(diff):
+            num_versions2.append(0)
+    elif len(num_versions1) < len(num_versions2):
+        diff = len(num_versions2) - len(num_versions1)
+        for _ in range(diff):
+            num_versions1.append(0)
+
+    for i, ver in enumerate(num_versions1):
+        if num_versions1[i] > num_versions2[i]:
+            return -1
+        elif num_versions1[i] < num_versions2[i]:
+            return 1
+
+    return 0

tests/test_cache.py

@@ -13,7 +13,7 @@
     LRUPolicy,
 )
 from redis.utils import HIREDIS_AVAILABLE
-from tests.conftest import _get_client, skip_if_resp_version
+from tests.conftest import _get_client, skip_if_resp_version, skip_if_server_version_lt
 
 
 @pytest.fixture()
@@ -40,6 +40,7 @@ def r(request):
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
 @pytest.mark.onlynoncluster
 @skip_if_resp_version(2)
+@skip_if_server_version_lt("7.4.0")
 class TestCache:
     @pytest.mark.parametrize(
         "r",
@@ -343,6 +344,7 @@ def test_cache_flushed_on_server_flush(self, r):
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
 @pytest.mark.onlycluster
 @skip_if_resp_version(2)
+@skip_if_server_version_lt("7.4.0")
 class TestClusterCache:
     @pytest.mark.parametrize(
         "r",
@@ -605,6 +607,7 @@ def test_cache_flushed_on_server_flush(self, r, cache):
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
 @pytest.mark.onlynoncluster
 @skip_if_resp_version(2)
+@skip_if_server_version_lt("7.4.0")
 class TestSentinelCache:
     @pytest.mark.parametrize(
         "sentinel_setup",
@@ -729,6 +732,7 @@ def test_cache_clears_on_disconnect(self, master, cache):
 @pytest.mark.skipif(HIREDIS_AVAILABLE, reason="PythonParser only")
 @pytest.mark.onlynoncluster
 @skip_if_resp_version(2)
+@skip_if_server_version_lt("7.4.0")
 class TestSSLCache:
     @pytest.mark.parametrize(
         "r",

tests/test_utils.py

@@ -0,0 +1,27 @@
+import pytest
+from redis.utils import compare_versions
+
+
+@pytest.mark.parametrize(
+    "version1,version2,expected_res",
+    [
+        ("1.0.0", "0.9.0", -1),
+        ("1.0.0", "1.0.0", 0),
+        ("0.9.0", "1.0.0", 1),
+        ("1.09.0", "1.9.0", 0),
+        ("1.090.0", "1.9.0", -1),
+        ("1", "0.9.0", -1),
+        ("1", "1.0.0", 0),
+    ],
+    ids=[
+        "version1 > version2",
+        "version1 == version2",
+        "version1 < version2",
+        "version1 == version2 - different minor format",
+        "version1 > version2 - different minor format",
+        "version1 > version2 - major version only",
+        "version1 == version2 - major version only",
+    ],
+)
+def test_compare_versions(version1, version2, expected_res):
+    assert compare_versions(version1, version2) == expected_res