arthexis 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

nodes/models.py

@@ -7,7 +7,7 @@ from django.db.utils import DatabaseError
 from django.db.models.signals import post_delete
 from django.dispatch import Signal, receiver
 from core.entity import Entity
-from core.models import Profile
+from core.models import PackageRelease, Profile
 from core.fields import SigilLongAutoField, SigilShortAutoField
 import re
 import json
@@ -84,21 +84,33 @@ class NodeFeature(Entity):
 
     objects = NodeFeatureManager()
 
-    DEFAULT_ACTIONS = {
-        "rfid-scanner": NodeFeatureDefaultAction(
-            label="Scan RFIDs", url_name="admin:core_rfid_scan"
+    DEFAULT_ACTIONS: dict[str, tuple[NodeFeatureDefaultAction, ...]] = {
+        "rfid-scanner": (
+            NodeFeatureDefaultAction(
+                label="Scan RFIDs", url_name="admin:core_rfid_scan"
+            ),
         ),
-        "celery-queue": NodeFeatureDefaultAction(
-            label="Celery Report",
-            url_name="admin:nodes_nodefeature_celery_report",
+        "celery-queue": (
+            NodeFeatureDefaultAction(
+                label="Celery Report",
+                url_name="admin:nodes_nodefeature_celery_report",
+            ),
         ),
-        "screenshot-poll": NodeFeatureDefaultAction(
-            label="Take Screenshot",
-            url_name="admin:nodes_nodefeature_take_screenshot",
+        "screenshot-poll": (
+            NodeFeatureDefaultAction(
+                label="Take Screenshot",
+                url_name="admin:nodes_nodefeature_take_screenshot",
+            ),
         ),
-        "rpi-camera": NodeFeatureDefaultAction(
-            label="Take a Snapshot",
-            url_name="admin:nodes_nodefeature_take_snapshot",
+        "rpi-camera": (
+            NodeFeatureDefaultAction(
+                label="Take a Snapshot",
+                url_name="admin:nodes_nodefeature_take_snapshot",
+            ),
+            NodeFeatureDefaultAction(
+                label="View stream",
+                url_name="admin:nodes_nodefeature_view_stream",
+            ),
         ),
     }
 
@@ -141,10 +153,19 @@ class NodeFeature(Entity):
             return (base_path / "locks" / lock).exists()
         return False
 
+    def get_default_actions(self) -> tuple[NodeFeatureDefaultAction, ...]:
+        """Return the configured default actions for this feature."""
+
+        actions = self.DEFAULT_ACTIONS.get(self.slug, ())
+        if isinstance(actions, NodeFeatureDefaultAction):  # pragma: no cover - legacy
+            return (actions,)
+        return actions
+
     def get_default_action(self) -> NodeFeatureDefaultAction | None:
-        """Return the configured default action for this feature if any."""
+        """Return the first configured default action for this feature if any."""
 
-        return self.DEFAULT_ACTIONS.get(self.slug)
+        actions = self.get_default_actions()
+        return actions[0] if actions else None
 
 
 def get_terminal_role():
@@ -451,7 +472,46 @@ class Node(Entity):
         """Determine if this node represents the current host."""
         return self.mac_address == self.get_current_mac()
 
+    @classmethod
+    def _generate_unique_public_endpoint(
+        cls, value: str | None, *, exclude_pk: int | None = None
+    ) -> str:
+        """Return a unique public endpoint slug for ``value``."""
+
+        field = cls._meta.get_field("public_endpoint")
+        max_length = getattr(field, "max_length", None) or 50
+        base_slug = slugify(value or "") or "node"
+        if len(base_slug) > max_length:
+            base_slug = base_slug[:max_length]
+        slug = base_slug
+        queryset = cls.objects.all()
+        if exclude_pk is not None:
+            queryset = queryset.exclude(pk=exclude_pk)
+        counter = 2
+        while queryset.filter(public_endpoint=slug).exists():
+            suffix = f"-{counter}"
+            available = max_length - len(suffix)
+            if available <= 0:
+                slug = suffix[-max_length:]
+            else:
+                slug = f"{base_slug[:available]}{suffix}"
+            counter += 1
+        return slug
+
     def save(self, *args, **kwargs):
+        update_fields = kwargs.get("update_fields")
+
+        def include_update_field(field: str):
+            nonlocal update_fields
+            if update_fields is None:
+                return
+            fields = set(update_fields)
+            if field in fields:
+                return
+            fields.add(field)
+            update_fields = tuple(fields)
+            kwargs["update_fields"] = update_fields
+
         role_name = None
         role = getattr(self, "role", None)
         if role and getattr(role, "name", None):
@@ -468,17 +528,28 @@ class Node(Entity):
             not self.badge_color or self.badge_color == self.DEFAULT_BADGE_COLOR
         ):
             self.badge_color = role_color
-            update_fields = kwargs.get("update_fields")
-            if update_fields:
-                fields = set(update_fields)
-                if "badge_color" not in fields:
-                    fields.add("badge_color")
-                    kwargs["update_fields"] = tuple(fields)
+            include_update_field("badge_color")
 
         if self.mac_address:
             self.mac_address = self.mac_address.lower()
-        if not self.public_endpoint:
-            self.public_endpoint = slugify(self.hostname)
+        endpoint_value = slugify(self.public_endpoint or "")
+        if not endpoint_value:
+            endpoint_value = self._generate_unique_public_endpoint(
+                self.hostname, exclude_pk=self.pk
+            )
+        else:
+            queryset = (
+                self.__class__.objects.exclude(pk=self.pk)
+                if self.pk
+                else self.__class__.objects.all()
+            )
+            if queryset.filter(public_endpoint=endpoint_value).exists():
+                endpoint_value = self._generate_unique_public_endpoint(
+                    self.hostname or endpoint_value, exclude_pk=self.pk
+                )
+        if self.public_endpoint != endpoint_value:
+            self.public_endpoint = endpoint_value
+            include_update_field("public_endpoint")
         super().save(*args, **kwargs)
         if self.pk:
             self.refresh_features()
@@ -734,7 +805,16 @@ def _format_upgrade_body(version: str, revision: str) -> str:
     parts: list[str] = []
     if version:
         normalized = version.lstrip("vV") or version
-        parts.append(f"v{normalized}")
+        base_version = normalized.rstrip("+")
+        display_version = normalized
+        if (
+            base_version
+            and revision
+            and not PackageRelease.matches_revision(base_version, revision)
+            and not normalized.endswith("+")
+        ):
+            display_version = f"{display_version}+"
+        parts.append(f"v{display_version}")
     if revision:
         rev_clean = re.sub(r"[^0-9A-Za-z]", "", revision)
         rev_short = (rev_clean[-6:] if rev_clean else revision[-6:])
@@ -1183,12 +1263,57 @@ class NetMessage(Entity):
     )
     subject = models.CharField(max_length=64, blank=True)
     body = models.CharField(max_length=256, blank=True)
+    filter_node = models.ForeignKey(
+        "Node",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="filtered_net_messages",
+        verbose_name="Node",
+    )
+    filter_node_feature = models.ForeignKey(
+        "NodeFeature",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        verbose_name="Node feature",
+    )
+    filter_node_role = models.ForeignKey(
+        NodeRole,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="filtered_net_messages",
+        verbose_name="Node role",
+    )
+    filter_current_relation = models.CharField(
+        max_length=10,
+        blank=True,
+        choices=Node.Relation.choices,
+        verbose_name="Current relation",
+    )
+    filter_installed_version = models.CharField(
+        max_length=20,
+        blank=True,
+        verbose_name="Installed version",
+    )
+    filter_installed_revision = models.CharField(
+        max_length=40,
+        blank=True,
+        verbose_name="Installed revision",
+    )
     reach = models.ForeignKey(
         NodeRole,
         on_delete=models.SET_NULL,
         null=True,
         blank=True,
     )
+    target_limit = models.PositiveSmallIntegerField(
+        default=6,
+        blank=True,
+        null=True,
+        help_text="Maximum number of peers to contact when propagating.",
+    )
     propagated_to = models.ManyToManyField(
         Node, blank=True, related_name="received_net_messages"
     )
@@ -1274,22 +1399,49 @@ class NetMessage(Entity):
             if node and (not local or node.pk != local.pk):
                 self.propagated_to.add(node)
 
-        all_nodes = Node.objects.all()
+        filtered_nodes = Node.objects.all()
+        if self.filter_node_id:
+            filtered_nodes = filtered_nodes.filter(pk=self.filter_node_id)
+        if self.filter_node_feature_id:
+            filtered_nodes = filtered_nodes.filter(
+                features__pk=self.filter_node_feature_id
+            )
+        if self.filter_node_role_id:
+            filtered_nodes = filtered_nodes.filter(role_id=self.filter_node_role_id)
+        if self.filter_current_relation:
+            filtered_nodes = filtered_nodes.filter(
+                current_relation=self.filter_current_relation
+            )
+        if self.filter_installed_version:
+            filtered_nodes = filtered_nodes.filter(
+                installed_version=self.filter_installed_version
+            )
+        if self.filter_installed_revision:
+            filtered_nodes = filtered_nodes.filter(
+                installed_revision=self.filter_installed_revision
+            )
+
+        filtered_nodes = filtered_nodes.distinct()
+
         if local:
-            all_nodes = all_nodes.exclude(pk=local.pk)
-        total_known = all_nodes.count()
+            filtered_nodes = filtered_nodes.exclude(pk=local.pk)
+        total_known = filtered_nodes.count()
 
         remaining = list(
-            all_nodes.exclude(pk__in=self.propagated_to.values_list("pk", flat=True))
+            filtered_nodes.exclude(
+                pk__in=self.propagated_to.values_list("pk", flat=True)
+            )
         )
         if not remaining:
             self.complete = True
             self.save(update_fields=["complete"])
             return
 
-        target_limit = min(3, len(remaining))
+        limit = self.target_limit or 6
+        target_limit = min(limit, len(remaining))
 
-        reach_name = self.reach.name if self.reach else None
+        reach_source = self.filter_node_role or self.reach
+        reach_name = reach_source.name if reach_source else None
         role_map = {
             "Terminal": ["Terminal"],
             "Control": ["Control", "Terminal"],
@@ -1301,23 +1453,40 @@ class NetMessage(Entity):
                 "Terminal",
             ],
         }
-        role_order = role_map.get(reach_name, [None])
         selected: list[Node] = []
-        for role_name in role_order:
-            if role_name is None:
-                role_nodes = remaining[:]
+        if self.filter_node_id:
+            target = next((n for n in remaining if n.pk == self.filter_node_id), None)
+            if target:
+                selected = [target]
             else:
-                role_nodes = [
-                    n for n in remaining if n.role and n.role.name == role_name
-                ]
-            random.shuffle(role_nodes)
-            for n in role_nodes:
-                selected.append(n)
-                remaining.remove(n)
+                self.complete = True
+                self.save(update_fields=["complete"])
+                return
+        else:
+            if self.filter_node_role_id:
+                role_order = [reach_name]
+            else:
+                role_order = role_map.get(reach_name, [None])
+            for role_name in role_order:
+                if role_name is None:
+                    role_nodes = remaining[:]
+                else:
+                    role_nodes = [
+                        n for n in remaining if n.role and n.role.name == role_name
+                    ]
+                random.shuffle(role_nodes)
+                for n in role_nodes:
+                    selected.append(n)
+                    remaining.remove(n)
+                    if len(selected) >= target_limit:
+                        break
                 if len(selected) >= target_limit:
                     break
-            if len(selected) >= target_limit:
-                break
+
+        if not selected:
+            self.complete = True
+            self.save(update_fields=["complete"])
+            return
 
         seen_list = seen.copy()
         selected_ids = [str(n.uuid) for n in selected]
@@ -1332,6 +1501,18 @@ class NetMessage(Entity):
                 "sender": local_id,
                 "origin": origin_uuid,
             }
+            if self.filter_node:
+                payload["filter_node"] = str(self.filter_node.uuid)
+            if self.filter_node_feature:
+                payload["filter_node_feature"] = self.filter_node_feature.slug
+            if self.filter_node_role:
+                payload["filter_node_role"] = self.filter_node_role.name
+            if self.filter_current_relation:
+                payload["filter_current_relation"] = self.filter_current_relation
+            if self.filter_installed_version:
+                payload["filter_installed_version"] = self.filter_installed_version
+            if self.filter_installed_revision:
+                payload["filter_installed_revision"] = self.filter_installed_revision
             payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
             headers = {"Content-Type": "application/json"}
             if private_key: