Fixed #35166 -- Reinstated support for python-memcached.

ngnpope · ngnpope · commit 82aa86d2d7b8 · 2024-02-07T09:46:12.000Z
As of ``python-memcached&gt;=1.62``, all previous incompatibilities have
been resolved.
diff --git a/django/core/cache/backends/memcached.py b/django/core/cache/backends/memcached.py
@@ -1,5 +1,6 @@
 "Memcached cache backend"
 
+import pickle
 import re
 import time
 
@@ -141,6 +142,17 @@ def validate_key(self, key):
             raise InvalidCacheKey(warning)
 
 
+class MemcachedCache(BaseMemcachedCache):
+    """An implementation of a cache binding using python-memcached."""
+
+    def __init__(self, server, params):
+        import memcache
+        super().__init__(
+            server, params, library=memcache, value_not_found_exception=ValueError
+        )
+        self._options = {"pickleProtocol": pickle.HIGHEST_PROTOCOL} | self._options
+
+
 class PyLibMCCache(BaseMemcachedCache):
     "An implementation of a cache binding using pylibmc"
 
diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
@@ -153,6 +153,7 @@ The cache backend to use. The built-in cache backends are:
 * ``'django.core.cache.backends.locmem.LocMemCache'``
 * ``'django.core.cache.backends.memcached.PyMemcacheCache'``
 * ``'django.core.cache.backends.memcached.PyLibMCCache'``
+* ``'django.core.cache.backends.memcached.MemcachedCache'``
 * ``'django.core.cache.backends.redis.RedisCache'``
 
 You can use a cache backend that doesn't ship with Django by setting
diff --git a/docs/releases/5.1.txt b/docs/releases/5.1.txt
@@ -138,7 +138,9 @@ Asynchronous views
 Cache
 ~~~~~
 
-* ...
+* The ``django.core.cache.backends.memcached.MemcachedCache`` backend that was
+  removed in Django 4.1 due to incompatibilities has been restored and requires
+  ``python-memcached>=1.62``.
 
 CSRF
 ~~~~
diff --git a/docs/topics/cache.txt b/docs/topics/cache.txt
@@ -78,13 +78,15 @@ database or filesystem usage.
 
 After installing Memcached itself, you'll need to install a Memcached
 binding. There are several Python Memcached bindings available; the
-two supported by Django are :pypi:`pylibmc` and :pypi:`pymemcache`.
+three supported by Django are :pypi:`pymemcache`, :pypi:`pylibmc`, and
+:pypi:`python-memcached`.
 
 To use Memcached with Django:
 
 * Set :setting:`BACKEND <CACHES-BACKEND>` to
-  ``django.core.cache.backends.memcached.PyMemcacheCache`` or
-  ``django.core.cache.backends.memcached.PyLibMCCache`` (depending on your
+  ``django.core.cache.backends.memcached.PyMemcacheCache``,
+  ``django.core.cache.backends.memcached.PyLibMCCache``, or
+  ``django.core.cache.backends.memcached.MemcachedCache`` (depending on your
   chosen memcached binding)
 
 * Set :setting:`LOCATION <CACHES-LOCATION>` to ``ip:port`` values,
@@ -166,6 +168,12 @@ permanent storage -- they're all intended to be solutions for caching, not
 storage -- but we point this out here because memory-based caching is
 particularly temporary.
 
+.. versionchanged:: 5.1
+
+    The ``MemcachedCache`` backend is reinstated having previously been removed
+    in Django 4.1 due to incompatibilities that have been resolved as of
+    ``python-memcached>=1.62``.
+
 .. _redis:
 
 Redis
@@ -525,6 +533,19 @@ of 60 seconds, and a maximum capacity of 1000 items::
         }
     }
 
+Here's an example configuration for a ``python-memcached`` based backend with
+an object size limit of 2MB::
+
+    CACHES = {
+        "default": {
+            "BACKEND": "django.core.cache.backends.memcached.MemcachedCache",
+            "LOCATION": "127.0.0.1:11211",
+            "OPTIONS": {
+                "server_max_value_length": 2 * 1024 ** 2,
+            },
+        }
+    }
+
 Here's an example configuration for a ``pylibmc`` based backend that enables
 the binary protocol, SASL authentication, and the ``ketama`` behavior mode::
 
diff --git a/tests/cache/tests.py b/tests/cache/tests.py
@@ -1446,6 +1446,9 @@ def test_lru_incr(self):
 for _cache_params in settings.CACHES.values():
     configured_caches[_cache_params["BACKEND"]] = _cache_params
 
+MemcachedCache_params = configured_caches.get(
+    "django.core.cache.backends.memcached.MemcachedCache"
+)
 PyLibMCCache_params = configured_caches.get(
     "django.core.cache.backends.memcached.PyLibMCCache"
 )
@@ -1579,6 +1582,34 @@ def fail_set_multi(mapping, *args, **kwargs):
             self.assertEqual(failing_keys, ["key"])
 
 
+@unittest.skipUnless(MemcachedCache_params, "MemcachedCache backend not configured")
+@override_settings(
+    CACHES=caches_setting_for_tests(
+        base=MemcachedCache_params,
+        exclude=memcached_excluded_caches,
+    )
+)
+class MemcachedCacheTests(BaseMemcachedTests, TestCase):
+    base_params = MemcachedCache_params
+    incr_decr_type_error = ValueError
+
+    def test_memcached_uses_highest_pickle_version(self):
+        for cache_key in settings.CACHES:
+            with self.subTest(cache_key=cache_key):
+                cache = caches[cache_key]
+                self.assertEqual(cache._cache.pickleProtocol, pickle.HIGHEST_PROTOCOL)
+
+    @override_settings(
+        CACHES=caches_setting_for_tests(
+            base=MemcachedCache_params,
+            exclude=memcached_excluded_caches,
+            OPTIONS={"server_max_value_length": 9999},
+        )
+    )
+    def test_memcached_options(self):
+        self.assertEqual(cache._cache.server_max_value_length, 9999)
+
+
 @unittest.skipUnless(PyLibMCCache_params, "PyLibMCCache backend not configured")
 @override_settings(
     CACHES=caches_setting_for_tests(
diff --git a/tests/requirements/py3.txt b/tests/requirements/py3.txt
@@ -11,6 +11,7 @@ Pillow >= 6.2.1; sys.platform != 'win32' or python_version < '3.13'
 # pylibmc/libmemcached can't be built on Windows.
 pylibmc; sys.platform != 'win32'
 pymemcache >= 3.4.0
+python-memcached >= 1.62
 pywatchman; sys.platform != 'win32'
 PyYAML
 redis >= 3.4.0
