meta-memcache 1.1.2.dev2__tar.gz → 1.1.2.dev5__tar.gz

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meta-memcache
-Version: 1.1.2.dev2
+Version: 1.1.2.dev5
 Summary: Modern, pure python, memcache client with support for new meta commands.
 Home-page: https://github.com/RevenueCat/meta-memcache-py
 License: MIT

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "meta-memcache"
-version = "1.1.2-dev2"
+version = "1.1.2-dev5"
 description = "Modern, pure python, memcache client with support for new meta commands."
 license = "MIT"
 readme = "README.md"

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/src/meta_memcache/commands/high_level_commands.py

@@ -32,6 +32,22 @@ from meta_memcache.protocol import (
 T = TypeVar("T")
 _REFILL_FAILURE_HANDLING = FailureHandling(track_write_failures=False)
 
+DEFAULT_FLAGS: Set[Flag] = {
+    Flag.RETURN_VALUE,
+    Flag.RETURN_TTL,
+    Flag.RETURN_CLIENT_FLAG,
+    Flag.RETURN_LAST_ACCESS,
+    Flag.RETURN_FETCHED,
+}
+DEFAULT_CAS_FLAGS: Set[Flag] = {
+    Flag.RETURN_VALUE,
+    Flag.RETURN_TTL,
+    Flag.RETURN_CLIENT_FLAG,
+    Flag.RETURN_LAST_ACCESS,
+    Flag.RETURN_FETCHED,
+    Flag.RETURN_CAS_TOKEN,
+}
+
 
 class HighLevelCommandMixinWithMetaCommands(
     HighLevelCommandsProtocol, MetaCommandsProtocol, Protocol
@@ -328,20 +344,18 @@ class HighLevelCommandsMixin:
         recache_policy: Optional[RecachePolicy] = None,
         return_cas_token: bool = False,
     ) -> Dict[Key, Optional[Value]]:
-        flags = {
-            Flag.RETURN_VALUE,
-            Flag.RETURN_TTL,
-            Flag.RETURN_CLIENT_FLAG,
-            Flag.RETURN_LAST_ACCESS,
-            Flag.RETURN_FETCHED,
-        }
         if return_cas_token:
-            flags.add(Flag.RETURN_CAS_TOKEN)
-        int_flags = {}
-        if recache_policy:
-            int_flags[IntFlag.RECACHE_TTL] = recache_policy.ttl
-        if touch_ttl is not None and touch_ttl >= 0:
-            int_flags[IntFlag.CACHE_TTL] = touch_ttl
+            flags = DEFAULT_CAS_FLAGS.copy()
+        else:
+            flags = DEFAULT_FLAGS.copy()
+        if recache_policy is None and touch_ttl is None:
+            int_flags = None
+        else:
+            int_flags = {}
+            if recache_policy:
+                int_flags[IntFlag.RECACHE_TTL] = recache_policy.ttl
+            if touch_ttl is not None and touch_ttl >= 0:
+                int_flags[IntFlag.CACHE_TTL] = touch_ttl
 
         results = self.meta_multiget(
             keys=[key if isinstance(key, Key) else Key(key) for key in keys],
@@ -377,22 +391,20 @@ class HighLevelCommandsMixin:
         return_cas_token: bool = False,
     ) -> Optional[Value]:
         key = key if isinstance(key, Key) else Key(key)
-        flags = {
-            Flag.RETURN_VALUE,
-            Flag.RETURN_TTL,
-            Flag.RETURN_CLIENT_FLAG,
-            Flag.RETURN_LAST_ACCESS,
-            Flag.RETURN_FETCHED,
-        }
         if return_cas_token:
-            flags.add(Flag.RETURN_CAS_TOKEN)
-        int_flags = {}
-        if lease_policy:
-            int_flags[IntFlag.MISS_LEASE_TTL] = lease_policy.ttl
-        if recache_policy:
-            int_flags[IntFlag.RECACHE_TTL] = recache_policy.ttl
-        if touch_ttl is not None and touch_ttl >= 0:
-            int_flags[IntFlag.CACHE_TTL] = touch_ttl
+            flags = DEFAULT_CAS_FLAGS.copy()
+        else:
+            flags = DEFAULT_FLAGS.copy()
+        if lease_policy is None and recache_policy is None and touch_ttl is None:
+            int_flags = None
+        else:
+            int_flags = {}
+            if lease_policy:
+                int_flags[IntFlag.MISS_LEASE_TTL] = lease_policy.ttl
+            if recache_policy:
+                int_flags[IntFlag.RECACHE_TTL] = recache_policy.ttl
+            if touch_ttl is not None and touch_ttl >= 0:
+                int_flags[IntFlag.CACHE_TTL] = touch_ttl
 
         result = self.meta_get(key, flags=flags, int_flags=int_flags)
         return self._process_get_result(key, result)

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/src/meta_memcache/connection/memcache_socket.py

@@ -21,6 +21,9 @@ from meta_memcache.protocol import (
 )
 
 _log: logging.Logger = logging.getLogger(__name__)
+NOT_STORED = NotStored()
+MISS = Miss()
+CONFLICT = Conflict()
 
 
 class MemcacheSocket:
@@ -224,15 +227,15 @@ class MemcacheSocket:
                 self._add_flags(result, chunks)
             elif response_code == b"NS":
                 # Value response, parse size and flags
-                result = NotStored()
+                result = NOT_STORED
                 assert len(chunks) == 0  # noqa: S101
             elif response_code == b"EX":
                 # Already exists, not changed, CAS conflict
-                result = Conflict()
+                result = CONFLICT
                 assert len(chunks) == 0  # noqa: S101
             elif response_code == b"EN" or response_code == b"NF":
                 # Not Found, Miss.
-                result = Miss()
+                result = MISS
                 assert len(chunks) == 0  # noqa: S101
             else:
                 raise MemcacheError(f"Unknown response: {bytes(response_code)!r}")

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/src/meta_memcache/connection/pool.py

@@ -115,24 +115,29 @@ class ConnectionPool:
 
     @contextmanager
     def get_connection(self) -> Generator[MemcacheSocket, None, None]:
-        try:
-            conn = self._pool.popleft()
-        except IndexError:
-            conn = None
-
-        if conn is None:
-            conn = self._create_connection()
-
+        conn = self.pop_connection()
         try:
             yield conn
         except Exception as e:
+            self.release_connection(conn, error=True)
+            raise MemcacheServerError(self.server, "Memcache error") from e
+        else:
+            self.release_connection(conn, error=False)
+
+    def pop_connection(self) -> MemcacheSocket:
+        try:
+            return self._pool.popleft()
+        except IndexError:
+            return self._create_connection()
+
+    def release_connection(self, conn: MemcacheSocket, error: bool) -> None:
+        if error:
             # Errors, assume connection is in bad state
             _log.warning(
                 "Error during cache conn context (discarding connection)",
                 exc_info=True,
             )
             self._discard_connection(conn, error=True)
-            raise MemcacheServerError(self.server, "Memcache error") from e
         else:
             if len(self._pool) < self._max_pool_size:
                 # If there is a race, the  deque might end with more than

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/src/meta_memcache/connection/providers.py

@@ -1,4 +1,5 @@
 from typing import Dict, List, Protocol
+import zlib
 
 from uhashring import HashRing  # type: ignore
 
@@ -49,3 +50,22 @@ class HashRingConnectionPoolProvider:
         return {
             server: pool.get_counters() for server, pool in self._server_pool.items()
         }
+
+
+class NonConsistentHashPoolProvider:
+    def __init__(self, server_pool: Dict[ServerAddress, ConnectionPool]) -> None:
+        self._server_pool = server_pool
+        self._server_count = len(server_pool)
+        self._servers: List[ServerAddress] = [x for x in server_pool.keys()]
+
+    def get_pool(self, key: Key) -> ConnectionPool:
+        routing_key = key.routing_key or key.key
+        server: ServerAddress = self._servers[
+            zlib.crc32(routing_key.encode()) % self._server_count
+        ]
+        return self._server_pool[server]
+
+    def get_counters(self) -> Dict[ServerAddress, PoolCounters]:
+        return {
+            server: pool.get_counters() for server, pool in self._server_pool.items()
+        }

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/src/meta_memcache/executors/default.py

@@ -115,7 +115,9 @@ class DefaultExecutor:
             else self._prepare_serialized_value_and_int_flags(value, int_flags)
         )
         try:
-            with pool.get_connection() as conn:
+            conn = pool.pop_connection()
+            error = False
+            try:
                 self._conn_send_cmd(
                     conn,
                     command=command,
@@ -126,6 +128,11 @@ class DefaultExecutor:
                     token_flags=token_flags,
                 )
                 return self._conn_recv_response(conn, flags=flags)
+            except Exception as e:
+                error = True
+                raise MemcacheServerError(pool.server, "Memcache error") from e
+            finally:
+                pool.release_connection(conn, error=error)
         except MemcacheServerError:
             if track_write_failures and self._is_a_write_failure(command, int_flags):
                 self.on_write_failure(key)
@@ -141,7 +148,7 @@ class DefaultExecutor:
             else:
                 return NotStored()
 
-    def exec_multi_on_pool(
+    def exec_multi_on_pool(  # noqa: C901
         self,
         pool: ConnectionPool,
         command: MetaCommand,
@@ -154,7 +161,10 @@ class DefaultExecutor:
     ) -> Dict[Key, MemcacheResponse]:
         results: Dict[Key, MemcacheResponse] = {}
         try:
-            with pool.get_connection() as conn:
+            conn = pool.pop_connection()
+            error = False
+            try:
+                # with pool.get_connection() as conn:
                 for key, value in key_values:
                     cmd_value, int_flags = (
                         (None, int_flags)
@@ -175,6 +185,11 @@ class DefaultExecutor:
                     )
                 for key, _ in key_values:
                     results[key] = self._conn_recv_response(conn, flags=flags)
+            except Exception as e:
+                error = True
+                raise MemcacheServerError(pool.server, "Memcache error") from e
+            finally:
+                pool.release_connection(conn, error=error)
         except MemcacheServerError:
             if track_write_failures and self._is_a_write_failure(command, int_flags):
                 for key, _ in key_values:

{meta_memcache-1.1.2.dev2 → meta_memcache-1.1.2.dev5}/src/meta_memcache/protocol.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum, IntEnum
-from typing import Any, Dict, List, NamedTuple, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union
 
 ENDL = b"\r\n"
 NOOP: bytes = b"mn" + ENDL
@@ -8,10 +8,25 @@ ENDL_LEN = 2
 SPACE: int = ord(" ")
 
 
-class Key(NamedTuple):
+@dataclass
+class Key:
+    __slots__ = ("key", "routing_key", "is_unicode")
     key: str
-    routing_key: Optional[str] = None
-    is_unicode: bool = False
+    routing_key: Optional[str]
+    is_unicode: bool
+
+    def __init__(
+        self,
+        key: str,
+        routing_key: Optional[str] = None,
+        is_unicode: bool = False,
+    ) -> None:
+        self.key = key
+        self.routing_key = routing_key
+        self.is_unicode = is_unicode
+
+    def __hash__(self) -> int:
+        return hash((self.key, self.routing_key))
 
 
 class MetaCommand(Enum):
@@ -84,16 +99,19 @@ int_flags_values: Dict[int, IntFlag] = {f.value[0]: f for f in IntFlag}
 token_flags_values: Dict[int, TokenFlag] = {f.value[0]: f for f in TokenFlag}
 
 
+@dataclass
 class MemcacheResponse:
-    pass
+    __slots__ = ()
 
 
+@dataclass
 class Miss(MemcacheResponse):
-    pass
+    __slots__ = ()
 
 
 @dataclass
 class Success(MemcacheResponse):
+    __slots__ = ("flags", "int_flags", "token_flags")
     flags: Set[Flag]
     int_flags: Dict[IntFlag, int]
     token_flags: Dict[TokenFlag, bytes]
@@ -111,6 +129,7 @@ class Success(MemcacheResponse):
 
 @dataclass
 class Value(Success):
+    __slots__ = ("flags", "int_flags", "token_flags", "size", "value")
     size: int
     value: Optional[Any]
 
@@ -127,7 +146,9 @@ class Value(Success):
         self.value = value
 
 
-class ValueContainer(NamedTuple):
+@dataclass
+class ValueContainer:
+    __slots__ = ("value",)
     value: Any
 
 
@@ -137,12 +158,12 @@ MaybeValues = Optional[List[ValueContainer]]
 
 @dataclass
 class NotStored(MemcacheResponse):
-    pass
+    __slots__ = ()
 
 
 @dataclass
 class Conflict(MemcacheResponse):
-    pass
+    __slots__ = ()
 
 
 ReadResponse = Union[Miss, Value, Success]