fix: don't compute a bone in a not existing relation

If you have a compute bone in a skel, thats referenced by a
RelationalBone (e.g. OrderSkel -> CartNodeSkel in viur-shop) and the
referenced skel is deleted (e.g. CartNodeSkel) this skleton cannot
longer be `read` here:
```
cloned_skel = skeletonByKind(skel.kindName)()
cloned_skel.read(skel["key"])
```

But here's not handling if the `read` _fails_ and returns `None`,
therefore the skel has only the default values and the computing methods
fails if it expeect for example a not-`None` `key` in the skel.

Since I detected this on rebuild search index, this breaked the entire
task and even the default error logging of the skel failed, since it
coulnd't be unserialized.

Author: sveneberth

src/viur/core/bones/base.py

@@ -1500,8 +1500,10 @@ def _compute(self, skel: 'viur.core.skeleton.SkeletonInstance', bone_name: str):
 
             if issubclass(skel.skeletonCls, RefSkel):  # we have a ref skel we must load the complete skeleton
                 cloned_skel = skeletonByKind(skel.kindName)()
-                cloned_skel.read(skel["key"])
+                if not cloned_skel.read(skel["key"]):
+                    raise ValueError(f"{skel["key"]=} does no longer exist. Cannot compute a broken relation")
             else:
+                logging.debug(f"Cloning {skel["key"]=}")
                 cloned_skel = skel.clone()
             cloned_skel[bone_name] = None  # remove value form accessedValues to avoid endless recursion
             compute_fn_args["skel"] = cloned_skel
@@ -1512,6 +1514,7 @@ def _compute(self, skel: 'viur.core.skeleton.SkeletonInstance', bone_name: str):
         if "bone_name" in compute_fn_parameters:
             compute_fn_args["bone_name"] = bone_name
 
+        # logging.debug(f"{self.compute.fn=} | {compute_fn_args=} | {self=}")
         ret = self.compute.fn(**compute_fn_args)
 
         def unserialize_raw_value(raw_value: list[dict] | dict | None):

src/viur/core/bones/relational.py

@@ -1028,9 +1028,12 @@ def refresh(self, skel: "SkeletonInstance", name: str) -> None:
             return
 
         for _, _, value in self.iter_bone_value(skel, name):
+            # logging.debug(f"refresh {self=} {value=}")
             if value and value["dest"]:
                 try:
+                    # logging.debug(f"{value["dest"]=}")
                     target_skel = value["dest"].read()
+                    # logging.debug(f"{target_skel=}")
                 except ValueError:
                     logging.error(
                         f"{name}: The key {value['dest']['key']!r} ({value['dest'].get('name')!r}) seems to be gone"

src/viur/core/skeleton.py

@@ -180,7 +180,7 @@ def __init__(
         bone_map = bone_map or {}
 
         if bones:
-            names = ("key", ) + tuple(bones)
+            names = ("key",) + tuple(bones)
 
             # generate full keys sequence based on definition; keeps order of patterns!
             keys = []
@@ -1157,7 +1157,7 @@ def read(
         if db_res := db.Get(db_key):
             skel.setEntity(db_res)
             return skel
-        elif create in (False,  None):
+        elif create in (False, None):
             return None
         elif isinstance(create, dict):
             if create and not skel.fromClient(create, amend=True):
@@ -1381,7 +1381,7 @@ def __txn_write(write_skel):
             skel.dbEntity["viur"].setdefault("viurActiveSeoKeys", [])
             for language, seo_key in last_set_seo_keys.items():
                 if skel.dbEntity["viur"]["viurCurrentSeoKeys"][language] not in \
-                        skel.dbEntity["viur"]["viurActiveSeoKeys"]:
+                    skel.dbEntity["viur"]["viurActiveSeoKeys"]:
                     # Ensure the current, active seo key is in the list of all seo keys
                     skel.dbEntity["viur"]["viurActiveSeoKeys"].insert(0, seo_key)
             if str(skel.dbEntity.key.id_or_name) not in skel.dbEntity["viur"]["viurActiveSeoKeys"]:
@@ -2017,9 +2017,37 @@ def _run(module: str, notify: str):
 class RebuildSearchIndex(QueryIter):
     @classmethod
     def handleEntry(cls, skel: SkeletonInstance, customData: dict[str, str]):
+        print("\n" * 3)
+        print("----" * 10)
+        print("\n" * 3)
+        # logging.debug(f"{skel["key"]=}")
+        # logging.debug(f"{skel["key"]=!r}")
+        # logging.debug(f"{skel.dbEntity.get("cart")=!r}")
+        # logging.debug(f"{skel.dbEntity["cart"]=!r}")
+        # logging.debug(f"{skel.dbEntity["cart"]["dest"]=!r}")
+        # logging.debug(f"{skel.dbEntity["cart"]["dest"].key=!r}")
+        # logging.debug(f"{skel.dbEntity["cart"]["dest"].key=!s}")
+        # logging.debug(f"{skel.dbEntity["cart"].key=!r}")
+        # logging.debug(f"{skel.dbEntity["cart"].key=!s}")
+        # logging.debug(f"{skel=}")
+        logging.debug(f"{customData=}")
         skel.refresh()
         skel.write(update_relations=False)
 
+    @classmethod
+    def handleError(cls, skel, customData, exception) -> bool:
+        """
+            Handle a error occurred in handleEntry.
+            If this function returns True, the queryIter continues, otherwise it breaks and prints the current cursor.
+        """
+        logging.exception(f'{cls.__qualname__}.handleEntry failed on skel {skel["key"]=}: {exception}')
+        try:
+            logging.debug(f"{skel=!r}")
+        except Exception:  # noqa
+            logging.warning("Failed to dump skel")
+            logging.debug(f"{skel.dbEntity=}")
+        return True
+
     @classmethod
     def handleFinish(cls, totalCount: int, customData: dict[str, str]):
         QueryIter.handleFinish(totalCount, customData)

src/viur/core/tasks.py

@@ -800,13 +800,16 @@ def _qryStep(cls, qryDict: dict[str, t.Any]) -> None:
             qryIter = qry.run(5)
         for item in qryIter:
             try:
+                logging.debug(f"Attempt 1 @ {item["key"]} / {qryDict["totalCount"]}")
                 cls.handleEntry(item, qryDict["customData"])
             except:  # First exception - we'll try another time (probably/hopefully transaction collision)
                 time.sleep(5)
                 try:
+                    logging.debug(f"Attempt 2 @ {item["key"]} / {qryDict["totalCount"]}")
                     cls.handleEntry(item, qryDict["customData"])
                 except Exception as e:  # Second exception - call error_handler
                     try:
+                        logging.debug(f"Attempt 3 @ {item["key"]} / {qryDict["totalCount"]}")
                         doCont = cls.handleError(item, qryDict["customData"], e)
                     except Exception as e:
                         logging.error(f"handleError failed on {item} - bailing out")