Use Django cache to store instantiated components.

Author: adamghill

django_unicorn/components/unicorn_view.py

@@ -4,17 +4,21 @@
 import pickle
 from typing import Any, Callable, Dict, List, Optional, Sequence, Type, Union
 
+from django.core.cache import caches
 from django.core.exceptions import ImproperlyConfigured
 from django.db.models import Model
 from django.http import HttpRequest
 from django.views.generic.base import TemplateView
 
 from cachetools.lru import LRUCache
 
+from django_unicorn.settings import get_cache_alias
+
 from .. import serializer
 from ..decorators import timed
-from ..errors import ComponentLoadError
+from ..errors import ComponentLoadError, UnicornCacheError
 from ..settings import get_setting
+from ..utils import get_cacheable_component
 from .fields import UnicornField
 from .unicorn_template_response import UnicornTemplateResponse
 
@@ -29,6 +33,7 @@
 # Module cache for constructed component classes
 # This can create a subtle race condition so a more long-term solution needs to be found
 constructed_views_cache = LRUCache(maxsize=100)
+COMPONENTS_MODULE_CACHE_ENABLED = True
 
 
 def convert_to_snake_case(s: str) -> str:
@@ -646,6 +651,9 @@ def create(
         assert component_id, "Component id is required"
         assert component_name, "Component name is required"
 
+        cache = caches[get_cache_alias()]
+        component_cache_key = f"unicorn:component:{component_id}"
+
         @timed
         def _get_component_class(
             module_name: str, class_name: str
@@ -658,16 +666,30 @@ def _get_component_class(
 
             return component_class
 
-        if use_cache and component_id in constructed_views_cache:
+        cached_component = cache.get(component_cache_key)
+
+        if cached_component:
+            if cached_component.parent:
+                parent_component_cache_key = (
+                    f"unicorn:component:{cached_component.parent.component_id}"
+                )
+                cached_parent_component = cache.get(parent_component_cache_key)
+
+                if cached_parent_component:
+                    cached_component.parent = cached_parent_component
+                    cached_component.parent.setup(request)
+        else:
+            cached_component = constructed_views_cache.get(component_id)
+
+        if use_cache and cached_component:
             # Note that `hydrate()` and `complete` don't need to be called here
             # because this path only happens for re-rendering from the view
-            component = constructed_views_cache[component_id]
-            component.setup(request)
-            component._validate_called = False
-            component.calls = []
+            cached_component.setup(request)
+            cached_component._validate_called = False
+            cached_component.calls = []
             logger.debug(f"Retrieve {component_id} from constructed views cache")
 
-            return component
+            return cached_component
 
         if component_id in views_cache:
             (component_class, parent, kwargs) = views_cache[component_id]
@@ -705,9 +727,22 @@ def _get_component_class(
                     **kwargs,
                 )
 
-                # Put the component's class in a "cache" to skip looking for the component on the next request
+                # Put the component's class in a module cache to skip looking for the component again
                 views_cache[component_id] = (component_class, parent, kwargs)
-                constructed_views_cache[component_id] = component
+
+                # Put the instantiated component into a module cache and the Django cache
+                cacheable_component = None
+
+                try:
+                    cacheable_component = get_cacheable_component(component)
+                except UnicornCacheError as e:
+                    logger.exception(e)
+
+                if cacheable_component:
+                    if COMPONENTS_MODULE_CACHE_ENABLED:
+                        constructed_views_cache[component_id] = cacheable_component
+
+                    cache.set(component_cache_key, cacheable_component)
 
                 return component
             except ModuleNotFoundError as e:

django_unicorn/errors.py

@@ -1,3 +1,7 @@
+class UnicornCacheError(Exception):
+    pass
+
+
 class UnicornViewError(Exception):
     pass
 

django_unicorn/utils.py

@@ -1,13 +1,25 @@
 import hmac
+import logging
+import pickle
 
 from django.conf import settings
 
 import shortuuid
 
+from django_unicorn.errors import UnicornCacheError
 
-def generate_checksum(data_bytes):
-    if isinstance(data_bytes, str):
-        data_bytes = str.encode(data_bytes)
+
+logger = logging.getLogger(__name__)
+
+
+def generate_checksum(data):
+    """
+    Generates a checksum for the passed-in data.
+    """
+    if isinstance(data, str):
+        data_bytes = str.encode(data)
+    else:
+        data_bytes = data
 
     checksum = hmac.new(
         str.encode(settings.SECRET_KEY), data_bytes, digestmod="sha256",
@@ -17,8 +29,37 @@ def generate_checksum(data_bytes):
     return checksum
 
 
-def dicts_equal(d1, d2):
-    """ return True if all keys and values are the same """
-    return all(k in d2 and d1[k] == d2[k] for k in d1) and all(
-        k in d1 and d1[k] == d2[k] for k in d2
+def dicts_equal(dictionary_one, dictionary_two):
+    """
+    Return True if all keys and values are the same between two dictionaries.
+    """
+    return all(
+        k in dictionary_two and dictionary_one[k] == dictionary_two[k]
+        for k in dictionary_one
+    ) and all(
+        k in dictionary_one and dictionary_one[k] == dictionary_two[k]
+        for k in dictionary_two
     )
+
+
+def get_cacheable_component(component):
+    """
+    Converts a component into something that is cacheable/pickleable.
+    """
+    component.request = None
+
+    if component.parent:
+        component.parent = get_cacheable_component(component.parent)
+
+    try:
+        pickle.dumps(component)
+    except TypeError as e:
+        raise UnicornCacheError(
+            "Cannot cache component because it is not picklable."
+        ) from e
+    except AttributeError as e:
+        raise UnicornCacheError(
+            "Cannot cache component because it is not picklable."
+        ) from e
+
+    return component

django_unicorn/views.py

@@ -21,7 +21,7 @@
 from .message import ComponentRequest, Return
 from .serializer import dumps, loads
 from .settings import get_cache_alias, get_serial_enabled, get_serial_timeout
-from .utils import generate_checksum
+from .utils import generate_checksum, get_cacheable_component
 
 
 logger = logging.getLogger(__name__)
@@ -508,6 +508,11 @@ def _process_component_request(
     rendered_component = component.render()
     component.rendered(rendered_component)
 
+    cache = caches[get_cache_alias()]
+    component_cache_key = f"unicorn:component:{component.component_id}"
+    cacheable_component = get_cacheable_component(component)
+    cache.set(component_cache_key, cacheable_component)
+
     partial_doms = []
 
     if partials and all(partials):
@@ -582,6 +587,7 @@ def _process_component_request(
     parent_component = component.parent
 
     if parent_component:
+        # TODO: Should parent_component.hydrate() be called?
         parent_frontend_context_variables = loads(
             parent_component.get_frontend_context_variables()
         )
@@ -596,6 +602,10 @@ def _process_component_request(
             parent_dom = parent_component.render()
             component.parent_rendered(parent_dom)
 
+            component_cache_key = f"unicorn:component:{parent_component.component_id}"
+            cacheable_component = get_cacheable_component(parent_component)
+            cache.set(component_cache_key, cacheable_component)
+
             parent.update(
                 {
                     "dom": parent_dom,

tests/call_method_parser/test_parse_call_method_name.py

@@ -22,6 +22,13 @@ def test_multiple_args():
     assert actual == expected
 
 
+def test_multiple_args_2():
+    expected = ("set_name", [1, 2], {})
+    actual = parse_call_method_name("set_name(1, 2)")
+
+    assert actual == expected
+
+
 def test_var_with_curly_braces():
     expected = ("set_name", ["{}",], {})
     actual = parse_call_method_name('set_name("{}")')
@@ -36,13 +43,6 @@ def test_one_arg():
     assert actual == expected
 
 
-def test_multiple_args():
-    expected = ("set_name", [1, 2], {})
-    actual = parse_call_method_name("set_name(1, 2)")
-
-    assert actual == expected
-
-
 def test_kwargs():
     expected = ("set_name", [], {"kwarg1": "wow"})
     actual = parse_call_method_name("set_name(kwarg1='wow')")

tests/views/message/test_call_method.py

@@ -3,28 +3,21 @@
 import orjson
 import shortuuid
 
+from django_unicorn.components import UnicornView, unicorn_view
 from django_unicorn.utils import generate_checksum
+from tests.views.message.utils import post_and_get_response
 
 
 def test_message_call_method(client):
     data = {"method_count": 0}
-    message = {
-        "actionQueue": [{"payload": {"name": "test_method"}, "type": "callMethod",}],
-        "data": data,
-        "checksum": generate_checksum(orjson.dumps(data)),
-        "id": shortuuid.uuid()[:8],
-        "epoch": time.time(),
-    }
-
-    response = client.post(
-        "/message/tests.views.fake_components.FakeComponent",
-        message,
-        content_type="application/json",
+    response = post_and_get_response(
+        client,
+        url="/message/tests.views.fake_components.FakeComponent",
+        data=data,
+        action_queue=[{"payload": {"name": "test_method"}, "type": "callMethod",}],
     )
 
-    body = orjson.loads(response.content)
-
-    assert body["data"].get("method_count") == 1
+    assert response["data"].get("method_count") == 1
 
 
 def test_message_call_method_redirect(client):
@@ -414,3 +407,94 @@ def test_message_call_method_refresh(client):
     # `data` should contain all data (not just the diffs) for refreshes
     assert body["data"].get("check") is not None
     assert body["data"].get("dictionary") is not None
+
+
+def test_message_call_method_caches_disabled(client, monkeypatch, settings):
+    monkeypatch.setattr(unicorn_view, "COMPONENTS_MODULE_CACHE_ENABLED", False)
+    settings.CACHES["default"][
+        "BACKEND"
+    ] = "django.core.cache.backends.dummy.DummyCache"
+
+    component_id = shortuuid.uuid()[:8]
+    response = post_and_get_response(
+        client,
+        url="/message/tests.views.fake_components.FakeComponent",
+        data={"method_count": 0},
+        action_queue=[{"payload": {"name": "test_method"}, "type": "callMethod",}],
+        component_id=component_id,
+    )
+
+    method_count = response["data"].get("method_count")
+
+    assert method_count == 1
+
+    # Get the component again
+    view = UnicornView.create(
+        component_name="tests.views.fake_components.FakeComponent",
+        component_id=component_id,
+        use_cache=True,
+    )
+
+    # Component is not retrieved from any caches
+    assert view.method_count == 0
+
+
+def test_message_call_method_module_cache_disabled(client, monkeypatch, settings):
+    monkeypatch.setattr(unicorn_view, "COMPONENTS_MODULE_CACHE_ENABLED", False)
+    settings.UNICORN["CACHE_ALIAS"] = "default"
+    settings.CACHES["default"][
+        "BACKEND"
+    ] = "django.core.cache.backends.locmem.LocMemCache"
+
+    component_id = shortuuid.uuid()[:8]
+    response = post_and_get_response(
+        client,
+        url="/message/tests.views.fake_components.FakeComponent",
+        data={"method_count": 0},
+        action_queue=[{"payload": {"name": "test_method"}, "type": "callMethod",}],
+        component_id=component_id,
+    )
+
+    method_count = response["data"].get("method_count")
+
+    assert method_count == 1
+
+    # Get the component again and it should be found in local memory cache
+    view = UnicornView.create(
+        component_name="tests.views.fake_components.FakeComponent",
+        component_id=component_id,
+        use_cache=True,
+    )
+
+    # Component is retrieved from the local memory cache
+    assert view.method_count == method_count
+
+
+def test_message_call_method_cache_backend_dummy(client, monkeypatch, settings):
+    monkeypatch.setattr(unicorn_view, "COMPONENTS_MODULE_CACHE_ENABLED", True)
+    settings.CACHES["default"][
+        "BACKEND"
+    ] = "django.core.cache.backends.dummy.DummyCache"
+
+    component_id = shortuuid.uuid()[:8]
+    response = post_and_get_response(
+        client,
+        url="/message/tests.views.fake_components.FakeComponent",
+        data={"method_count": 0},
+        action_queue=[{"payload": {"name": "test_method"}, "type": "callMethod",}],
+        component_id=component_id,
+    )
+
+    method_count = response["data"].get("method_count")
+
+    assert method_count == 1
+
+    # Get the component again and it should be found in local memory cache
+    view = UnicornView.create(
+        component_name="tests.views.fake_components.FakeComponent",
+        component_id=component_id,
+        use_cache=True,
+    )
+
+    # Component is retrieved from the module cache
+    assert view.method_count == method_count

tests/views/message/test_call_method_multiple.py

@@ -228,7 +228,6 @@ def test_message_second_request_not_queued_because_after_first(client, settings)
 
 
 @pytest.mark.slow
-@pytest.mark.skip
 def test_message_second_request_not_queued_because_serial_timeout(client, settings):
     _set_serial(settings, True, 0.1)
 
@@ -256,7 +255,6 @@ def test_message_second_request_not_queued_because_serial_timeout(client, settin
 
 
 @pytest.mark.slow
-@pytest.mark.skip
 def test_message_second_request_not_queued_because_serial_disabled(client, settings):
     _set_serial(settings, False, 5)