Merge pull request #7 from CESNET/fix/defer-db-queries-to-first-request

Fix DB queries during app initialization (#4)

Author: Kani999

netbox_custom_objects_tab/views/__init__.py

@@ -1,4 +1,5 @@
 import logging
+import threading
 
 from django.apps import apps
 from netbox.plugins import get_plugin_config
@@ -9,6 +10,18 @@
 
 logger = logging.getLogger("netbox_custom_objects_tab")
 
+# ── Deferred initialisation (avoids DB queries during ready()) ───────────
+# Typed-tab registration queries CustomObjectTypeField and ContentType.
+# Running those queries in AppConfig.ready() triggers warnings from Django
+# ("Accessing the database during app initialization is discouraged") and
+# from netbox_branching ("Routing database query … before branching support
+# is initialized").  We defer that work to the first HTTP request via
+# Django's request_started signal.  See GitHub issue #4.
+
+_deferred_init_lock = threading.Lock()
+_deferred_init_done = False
+_deferred_config = {}  # populated in register_tabs(), consumed in _deferred_typed_init()
+
 
 def _resolve_dynamic_custom_object_models():
     """
@@ -162,10 +175,52 @@ def _deduplicate_registry():
                 model_map[model_name] = deduped
 
 
+def _deferred_typed_init(sender=None, **kwargs):
+    """
+    One-shot ``request_started`` handler that performs DB-dependent initialisation.
+
+    Registers typed tabs, injects CO URL patterns, and deduplicates the view
+    registry.  Runs exactly once on the first HTTP request, then disconnects
+    itself so subsequent requests pay no overhead.
+    """
+    global _deferred_init_done
+    with _deferred_init_lock:
+        if _deferred_init_done:
+            return
+        _deferred_init_done = True
+
+    from django.core.signals import request_started
+
+    request_started.disconnect(_deferred_typed_init, dispatch_uid="netbox_custom_objects_tab_deferred")
+
+    config = _deferred_config
+    combined_models = config.get("combined_models", [])
+    typed_labels = config.get("typed_labels", [])
+    typed_weight = config.get("typed_weight", 2100)
+
+    typed_models = []
+    if typed_labels:
+        typed_models = _resolve_model_labels(typed_labels)
+        register_typed_tabs(typed_models, typed_weight)
+
+    # Inject URL patterns for CO dynamic models (combined + typed).
+    if any(m._meta.app_label == _CUSTOM_OBJECTS_APP for m in combined_models + typed_models):
+        _inject_co_urls()
+
+    # Deduplicate the registry — netbox_custom_objects re-registers journal/changelog
+    # on every get_model() cache miss, producing duplicate tabs.
+    _deduplicate_registry()
+
+
 def register_tabs():
     """
     Read plugin config and register both combined and typed tabs.
     Called from AppConfig.ready().
+
+    Combined tabs are registered immediately (no DB queries needed).
+    Typed tabs and other DB-dependent work are deferred to the first HTTP
+    request via the ``request_started`` signal to avoid DB access during
+    app initialisation (GitHub issue #4).
     """
     try:
         combined_labels = get_plugin_config("netbox_custom_objects_tab", "combined_models")
@@ -177,21 +232,22 @@ def register_tabs():
         logger.exception("Could not read netbox_custom_objects_tab plugin config")
         return
 
+    # Phase 1 — immediate: combined tabs do not query the database.
     combined_models = []
     if combined_labels:
         combined_models = _resolve_model_labels(combined_labels)
         register_combined_tabs(combined_models, combined_label, combined_weight)
 
-    typed_models = []
-    if typed_labels:
-        typed_models = _resolve_model_labels(typed_labels)
-        register_typed_tabs(typed_models, typed_weight)
+    # Phase 2 — deferred: typed tabs, CO URL injection, and registry dedup
+    # all require DB access and must wait until the first request.
+    _deferred_config.update(
+        {
+            "combined_models": combined_models,
+            "typed_labels": typed_labels,
+            "typed_weight": typed_weight,
+        }
+    )
 
-    # For any CO dynamic models we registered tabs for, inject URL patterns into
-    # netbox_custom_objects.urls so that tab URL reversal works.
-    if any(m._meta.app_label == _CUSTOM_OBJECTS_APP for m in combined_models + typed_models):
-        _inject_co_urls()
+    from django.core.signals import request_started
 
-    # Deduplicate the registry — netbox_custom_objects re-registers journal/changelog
-    # on every get_model() cache miss, producing duplicate tabs.
-    _deduplicate_registry()
+    request_started.connect(_deferred_typed_init, dispatch_uid="netbox_custom_objects_tab_deferred")

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "netbox-custom-objects-tab"
-version = "2.1.0"
+version = "2.1.1"
 description = "NetBox plugin that adds a Custom Objects tab to object detail pages"
 readme = "README.md"
 requires-python = ">=3.12"

tests/test_views_init.py

@@ -54,11 +54,11 @@ def test_unknown_specific_model_logs_warning_no_exception(self, caplog):
 
 
 class TestRegisterTabs:
-    def test_dispatches_combined_and_typed_tabs(self):
+    def test_dispatches_combined_tabs_immediately_and_defers_typed(self):
+        """register_tabs() registers combined tabs in ready() and defers typed tabs."""
         from netbox_custom_objects_tab import views
 
         combined_models = [MagicMock()]
-        typed_models = [MagicMock()]
 
         config_map = {
             "combined_models": ["dcim.device"],
@@ -70,14 +70,52 @@ def test_dispatches_combined_and_typed_tabs(self):
 
         with (
             patch.object(views, "get_plugin_config", side_effect=lambda _plugin, key: config_map[key]),
-            patch.object(views, "_resolve_model_labels", side_effect=[combined_models, typed_models]),
+            patch.object(views, "_resolve_model_labels", return_value=combined_models),
             patch.object(views, "register_combined_tabs") as register_combined,
             patch.object(views, "register_typed_tabs") as register_typed,
+            patch("django.core.signals.request_started") as mock_signal,
         ):
             views.register_tabs()
 
+        # Combined tabs registered immediately
         register_combined.assert_called_once_with(combined_models, "Custom Objects", 2000)
-        register_typed.assert_called_once_with(typed_models, 2100)
+        # Typed tabs NOT called during register_tabs() — deferred to first request
+        register_typed.assert_not_called()
+        # Signal handler connected for deferred init
+        mock_signal.connect.assert_called_once()
+
+    def test_deferred_init_dispatches_typed_tabs(self):
+        """_deferred_typed_init() resolves labels and registers typed tabs."""
+        from netbox_custom_objects_tab import views
+
+        typed_models = [MagicMock()]
+        typed_models[0]._meta.app_label = "ipam"
+
+        # Reset the deferred state so the handler can run
+        views._deferred_init_done = False
+        views._deferred_config.update(
+            {
+                "combined_models": [],
+                "typed_labels": ["ipam.prefix"],
+                "typed_weight": 2100,
+            }
+        )
+
+        try:
+            with (
+                patch.object(views, "_resolve_model_labels", return_value=typed_models),
+                patch.object(views, "register_typed_tabs") as register_typed,
+                patch.object(views, "_inject_co_urls"),
+                patch.object(views, "_deduplicate_registry"),
+                patch("django.core.signals.request_started"),
+            ):
+                views._deferred_typed_init()
+
+            register_typed.assert_called_once_with(typed_models, 2100)
+        finally:
+            # Clean up global state
+            views._deferred_init_done = False
+            views._deferred_config.clear()
 
     def test_skips_dispatch_when_configured_model_lists_are_empty(self):
         from netbox_custom_objects_tab import views
@@ -94,25 +132,22 @@ def test_skips_dispatch_when_configured_model_lists_are_empty(self):
             patch.object(views, "get_plugin_config", side_effect=lambda _plugin, key: config_map[key]),
             patch.object(views, "_resolve_model_labels") as resolve_labels,
             patch.object(views, "register_combined_tabs") as register_combined,
-            patch.object(views, "register_typed_tabs") as register_typed,
+            patch("django.core.signals.request_started"),
         ):
             views.register_tabs()
 
         resolve_labels.assert_not_called()
         register_combined.assert_not_called()
-        register_typed.assert_not_called()
 
     def test_config_exception_is_handled(self, caplog):
         from netbox_custom_objects_tab import views
 
         with (
             patch.object(views, "get_plugin_config", side_effect=RuntimeError("boom")),
             patch.object(views, "register_combined_tabs") as register_combined,
-            patch.object(views, "register_typed_tabs") as register_typed,
         ):
             with caplog.at_level(logging.ERROR, logger="netbox_custom_objects_tab"):
                 views.register_tabs()
 
         register_combined.assert_not_called()
-        register_typed.assert_not_called()
         assert any("Could not read netbox_custom_objects_tab plugin config" in r.message for r in caplog.records)