Deeploy chainstore response peers (#427)

* docs: update chainstore response mixin comments

* fix: restrict deeploy response reset peers

* refactor: delegate deeploy response resets to mixin

* chore: increment version

* test: resolve deeploy chainstore mixin source path

* test: load renamed deeploy chainstore mixin

* chore: increment version

Author: toderian

extensions/business/container_apps/container_utils.py

@@ -145,14 +145,14 @@ def _get_chainstore_response_data(self):
     Returns:
         dict: Response data including container details, ports, and timing info.
     """
-    # Start with base plugin data (from _ChainstoreResponseMixin)
-    # Note: Since this mixin is used alongside _ChainstoreResponseMixin,
+    # Start with base plugin data (from _DeeployChainstoreResponseMixin)
+    # Note: Since this mixin is used alongside _DeeployChainstoreResponseMixin,
     # we should check if super() provides base data
     try:
-      # Try to get base data if _ChainstoreResponseMixin is in the MRO
+      # Try to get base data if _DeeployChainstoreResponseMixin is in the MRO
       data = super()._get_chainstore_response_data()
     except (AttributeError, TypeError):
-      # Fallback if _ChainstoreResponseMixin is not in the inheritance chain
+      # Fallback if _DeeployChainstoreResponseMixin is not in the inheritance chain
       data = {
         'plugin_signature': self.__class__.__name__,
         'instance_id': getattr(self, 'cfg_instance_id', None),

extensions/business/deeploy/deeploy_mixin.py

@@ -1547,13 +1547,10 @@ def _reset_chainstore_response_keys(self, response_keys, context: str = "pipelin
       return normalized_keys
 
     self.P(f"Resetting response keys in chainstore before dispatching {context}...")
+    reset_kwargs = self._get_chainstore_response_local_reset_write_kwargs()
     for _, node_response_keys in normalized_keys.items():
       for response_key in node_response_keys:
-        try:
-          self.chainstore_set(response_key, None)
-        except Exception as e:
-          self.P(f"Error resetting response key {response_key} in chainstore: {e}", color='r')
-        # end try
+        self._reset_chainstore_response_key(response_key, write_kwargs=reset_kwargs)
       # end for
     # end for
 
@@ -2830,13 +2827,11 @@ def scale_up_job(self, new_nodes, update_nodes, job_id, owner, running_apps_for_
     self.P(f"Prepared chainstore response keys: {self.json_dumps(chainstore_response_keys)}")
 
     # RESET chainstore_response_keys here
-    try:
-      self.P(f"Resetting chainstore keys: {self.json_dumps(chainstore_response_keys)}")
-      for node_addr, response_keys in chainstore_response_keys.items():
-        for response_key in response_keys:
-          self.chainstore_set(response_key, None)
-    except Exception as e:
-      self.P(f"Error resetting chainstore keys: {e}", color='r')
+    self.P(f"Resetting chainstore keys: {self.json_dumps(chainstore_response_keys)}")
+    self._reset_chainstore_response_keys(
+      chainstore_response_keys,
+      context=f"scale up job {job_id}",
+    )
 
     # Start pipelines on nodes.
     self._start_create_update_pipelines(create_pipelines=create_pipelines,

extensions/business/deeploy/tests/support.py

@@ -1,4 +1,6 @@
 import copy
+import importlib.util
+from pathlib import Path
 import sys
 import types
 from types import SimpleNamespace
@@ -13,6 +15,83 @@
 from extensions.business.deeploy.deeploy_mixin import _DeeployMixin
 
 
+def _load_deeploy_chainstore_response_mixin():
+  """
+  Load only the chainstore-response mixin module for lightweight Deeploy tests.
+
+  Importing `naeural_core.business.mixins_base` executes package-level imports
+  that require optional runtime dependencies such as cv2, which are unrelated
+  to these focused tests.
+  """
+  checked_paths = []
+  for module_path in _iter_deeploy_chainstore_response_mixin_paths():
+    if module_path in checked_paths:
+      continue
+    checked_paths.append(module_path)
+    if not module_path.is_file():
+      continue
+    spec = importlib.util.spec_from_file_location(
+      "deeploy_chainstore_response_mixin_for_tests",
+      module_path,
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    if hasattr(module, "_DeeployChainstoreResponseMixin"):
+      return module._DeeployChainstoreResponseMixin
+
+  formatted_paths = "\n".join(f"- {path}" for path in checked_paths)
+  raise FileNotFoundError(
+    "Could not locate _DeeployChainstoreResponseMixin for Deeploy tests. "
+    f"Checked:\n{formatted_paths}"
+  )
+
+
+def _iter_deeploy_chainstore_response_mixin_paths():
+  """
+  Yield likely source paths for the installed, nested, or sibling naeural_core.
+  """
+  constants_file = getattr(ct, "__file__", None)
+  if constants_file:
+    yield (
+      Path(constants_file).resolve().parent
+      / "business"
+      / "mixins_base"
+      / "deeploy_chainstore_response_mixin.py"
+    )
+
+  edge_root = Path(__file__).resolve().parents[4]
+  yield (
+    edge_root
+    / "naeural_core"
+    / "naeural_core"
+    / "business"
+    / "mixins_base"
+    / "deeploy_chainstore_response_mixin.py"
+  )
+  yield (
+    edge_root.parent
+    / "naeural_core"
+    / "naeural_core"
+    / "business"
+    / "mixins_base"
+    / "deeploy_chainstore_response_mixin.py"
+  )
+
+  for entry in sys.path:
+    if not entry:
+      continue
+    yield (
+      Path(entry).resolve()
+      / "naeural_core"
+      / "business"
+      / "mixins_base"
+      / "deeploy_chainstore_response_mixin.py"
+    )
+
+
+_DeeployChainstoreResponseMixin = _load_deeploy_chainstore_response_mixin()
+
+
 class InputsStub(dict):
   def __getattr__(self, item):
     try:
@@ -21,7 +100,7 @@ def __getattr__(self, item):
       raise AttributeError(item) from exc
 
 
-class _TestDeeployPlugin(_DeeployMixin):
+class _TestDeeployPlugin(_DeeployMixin, _DeeployChainstoreResponseMixin):
   pass
 
 

extensions/business/deeploy/tests/test_chainstore_response_resets.py

@@ -0,0 +1,74 @@
+import unittest
+
+from extensions.business.deeploy.tests.support import make_deeploy_plugin
+
+
+class DeeployChainstoreResponseResetTests(unittest.TestCase):
+
+  def _make_plugin(self, seed_nodes=None, selected_seed=None):
+    plugin = make_deeploy_plugin()
+    plugin.ee_addr = "initiating-oracle"
+    plugin.seed_nodes = seed_nodes or ["seed-oracle-1", "seed-oracle-2"]
+    plugin.selected_seed = selected_seed or plugin.seed_nodes[0]
+    plugin.chainstore_calls = []
+    plugin._get_chainstore_response_seed_nodes = lambda: plugin.seed_nodes
+
+    def select_seed(seed_peers):
+      plugin.seed_selection_input = list(seed_peers)
+      if plugin.selected_seed in seed_peers:
+        return plugin.selected_seed
+      return seed_peers[0] if seed_peers else None
+
+    def chainstore_set(*args, **kwargs):
+      plugin.chainstore_calls.append((args, kwargs))
+      return True
+
+    plugin._select_chainstore_response_seed_peer = select_seed
+    plugin.chainstore_set = chainstore_set
+    return plugin
+
+  def test_reset_chainstore_response_keys_targets_one_seed_oracle_only(self):
+    plugin = self._make_plugin(selected_seed="seed-oracle-2")
+
+    result = plugin._reset_chainstore_response_keys({
+      "target-chainstore-peer": ["response-key-1", "response-key-2"],
+    })
+
+    self.assertEqual(result, {
+      "target-chainstore-peer": ["response-key-1", "response-key-2"],
+    })
+    self.assertEqual(len(plugin.chainstore_calls), 2)
+    for args, kwargs in plugin.chainstore_calls:
+      self.assertEqual(args[1], None)
+      self.assertEqual(kwargs["extra_peers"], ["seed-oracle-2"])
+      self.assertEqual(kwargs["include_default_peers"], False)
+      self.assertEqual(kwargs["include_configured_peers"], False)
+      self.assertEqual(kwargs["debug"], True)
+
+  def test_reset_peer_selection_excludes_current_oracle_when_possible(self):
+    plugin = self._make_plugin(
+      seed_nodes=["initiating-oracle", "seed-oracle-2"],
+      selected_seed="seed-oracle-2",
+    )
+
+    peers = plugin._get_chainstore_response_local_reset_peers()
+
+    self.assertEqual(peers, ["seed-oracle-2"])
+    self.assertEqual(plugin.seed_selection_input, ["seed-oracle-2"])
+
+  def test_reset_chainstore_response_keys_does_not_use_chainstore_peer_addresses(self):
+    plugin = self._make_plugin(selected_seed="seed-oracle-1")
+
+    plugin._reset_chainstore_response_keys({
+      "app-chainstore-peer-1": ["response-key-1"],
+      "app-chainstore-peer-2": ["response-key-2"],
+    })
+
+    for _, kwargs in plugin.chainstore_calls:
+      self.assertEqual(kwargs["extra_peers"], ["seed-oracle-1"])
+      self.assertNotIn("app-chainstore-peer-1", kwargs["extra_peers"])
+      self.assertNotIn("app-chainstore-peer-2", kwargs["extra_peers"])
+
+
+if __name__ == "__main__":
+  unittest.main()

ver.py

@@ -1 +1 @@
-__VER__ = '2.10.283'
+__VER__ = '2.10.284'