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

nodes/apps.py

@@ -31,6 +31,21 @@ def _startup_notification() -> None:
     rev_short = revision_value[-6:] if revision_value else ""
 
     body = version
+    if body:
+        normalized = body.lstrip("vV") or body
+        base_version = normalized.rstrip("+")
+        needs_marker = False
+        if base_version and revision_value:
+            try:  # pragma: no cover - defensive guard
+                from core.models import PackageRelease
+
+                needs_marker = not PackageRelease.matches_revision(
+                    base_version, revision_value
+                )
+            except Exception:
+                logger.debug("Startup release comparison failed", exc_info=True)
+        if needs_marker and not normalized.endswith("+"):
+            body = f"{body}+"
     if rev_short:
         body = f"{body} r{rev_short}" if body else f"r{rev_short}"
 

nodes/feature_checks.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterable, Optional
+
+from django.contrib import messages
+
+if False:  # pragma: no cover - typing imports only
+    from .models import Node, NodeFeature
+
+
+@dataclass(frozen=True)
+class FeatureCheckResult:
+    """Outcome of a feature validation."""
+
+    success: bool
+    message: str
+    level: int = messages.INFO
+
+
+FeatureCheck = Callable[["NodeFeature", Optional["Node"]], Any]
+
+
+class FeatureCheckRegistry:
+    """Registry for feature validation callbacks."""
+
+    def __init__(self) -> None:
+        self._checks: Dict[str, FeatureCheck] = {}
+        self._default_check: Optional[FeatureCheck] = None
+
+    def register(self, slug: str) -> Callable[[FeatureCheck], FeatureCheck]:
+        """Register ``func`` as the validator for ``slug``."""
+
+        def decorator(func: FeatureCheck) -> FeatureCheck:
+            self._checks[slug] = func
+            return func
+
+        return decorator
+
+    def register_default(self, func: FeatureCheck) -> FeatureCheck:
+        """Register ``func`` as the fallback validator."""
+
+        self._default_check = func
+        return func
+
+    def get(self, slug: str) -> Optional[FeatureCheck]:
+        return self._checks.get(slug)
+
+    def items(self) -> Iterable[tuple[str, FeatureCheck]]:
+        return self._checks.items()
+
+    def run(
+        self, feature: "NodeFeature", *, node: Optional["Node"] = None
+    ) -> Optional[FeatureCheckResult]:
+        check = self._checks.get(feature.slug)
+        if check is None:
+            check = self._default_check
+            if check is None:
+                return None
+        result = check(feature, node)
+        return self._normalize_result(feature, result)
+
+    def _normalize_result(
+        self, feature: "NodeFeature", result: Any
+    ) -> FeatureCheckResult:
+        if isinstance(result, FeatureCheckResult):
+            return result
+        if result is None:
+            return FeatureCheckResult(
+                True,
+                f"{feature.display} check completed successfully.",
+                messages.SUCCESS,
+            )
+        if isinstance(result, tuple) and len(result) >= 2:
+            success, message, *rest = result
+            level = rest[0] if rest else (
+                messages.SUCCESS if success else messages.ERROR
+            )
+            return FeatureCheckResult(bool(success), str(message), int(level))
+        if isinstance(result, bool):
+            message = (
+                f"{feature.display} check {'passed' if result else 'failed'}."
+            )
+            level = messages.SUCCESS if result else messages.ERROR
+            return FeatureCheckResult(result, message, level)
+        raise TypeError(
+            f"Unsupported feature check result type: {type(result)!r}"
+        )
+
+
+feature_checks = FeatureCheckRegistry()
+
+
+@feature_checks.register_default
+def _default_feature_check(
+    feature: "NodeFeature", node: Optional["Node"]
+) -> FeatureCheckResult:
+    from .models import Node
+
+    target: Optional["Node"] = node or Node.get_local()
+    if target is None:
+        return FeatureCheckResult(
+            False,
+            f"No local node is registered; cannot verify {feature.display}.",
+            messages.WARNING,
+        )
+    try:
+        enabled = feature.is_enabled
+    except Exception as exc:  # pragma: no cover - defensive
+        return FeatureCheckResult(
+            False,
+            f"{feature.display} check failed: {exc}",
+            messages.ERROR,
+        )
+    if enabled:
+        return FeatureCheckResult(
+            True,
+            f"{feature.display} is enabled on {target.hostname}.",
+            messages.SUCCESS,
+        )
+    return FeatureCheckResult(
+        False,
+        f"{feature.display} is not enabled on {target.hostname}.",
+        messages.WARNING,
+    )
+
+
+__all__ = [
+    "FeatureCheck",
+    "FeatureCheckRegistry",
+    "FeatureCheckResult",
+    "feature_checks",
+]

nodes/models.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
+from dataclasses import dataclass
 from django.db import models
 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
@@ -68,6 +69,12 @@ class NodeFeatureManager(models.Manager):
         return self.get(slug=slug)
 
 
+@dataclass(frozen=True)
+class NodeFeatureDefaultAction:
+    label: str
+    url_name: str
+
+
 class NodeFeature(Entity):
     """Feature that may be enabled on nodes and roles."""
 
@@ -77,6 +84,36 @@ class NodeFeature(Entity):
 
     objects = NodeFeatureManager()
 
+    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",
+            ),
+        ),
+        "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",
+            ),
+            NodeFeatureDefaultAction(
+                label="View stream",
+                url_name="admin:nodes_nodefeature_view_stream",
+            ),
+        ),
+    }
+
     class Meta:
         ordering = ["display"]
         verbose_name = "Node Feature"
@@ -116,6 +153,20 @@ 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 first configured default action for this feature if any."""
+
+        actions = self.get_default_actions()
+        return actions[0] if actions else None
+
 
 def get_terminal_role():
     """Return the NodeRole representing a Terminal if it exists."""
@@ -125,6 +176,12 @@ def get_terminal_role():
 class Node(Entity):
     """Information about a running node in the network."""
 
+    DEFAULT_BADGE_COLOR = "#28a745"
+    ROLE_BADGE_COLORS = {
+        "Constellation": "#daa520",  # goldenrod
+        "Control": "#673ab7",  # deep purple
+    }
+
     class Relation(models.TextChoices):
         UPSTREAM = "UPSTREAM", "Upstream"
         DOWNSTREAM = "DOWNSTREAM", "Downstream"
@@ -135,7 +192,7 @@ class Node(Entity):
     address = models.GenericIPAddressField()
     mac_address = models.CharField(max_length=17, unique=True, null=True, blank=True)
     port = models.PositiveIntegerField(default=8000)
-    badge_color = models.CharField(max_length=7, default="#28a745")
+    badge_color = models.CharField(max_length=7, default=DEFAULT_BADGE_COLOR)
     role = models.ForeignKey(NodeRole, on_delete=models.SET_NULL, null=True, blank=True)
     current_relation = models.CharField(
         max_length=10,
@@ -180,7 +237,6 @@ class Node(Entity):
         "rpi-camera",
         "ap-router",
         "ap-public-wifi",
-        "postgres-db",
     }
     MANUAL_FEATURE_SLUGS = {"clipboard-poll", "screenshot-poll"}
 
@@ -252,23 +308,27 @@ class Node(Entity):
             "mac_address": mac,
             "current_relation": cls.Relation.SELF,
         }
+        role_lock = Path(settings.BASE_DIR) / "locks" / "role.lck"
+        role_name = role_lock.read_text().strip() if role_lock.exists() else "Terminal"
+        desired_role = NodeRole.objects.filter(name=role_name).first()
+
         if node:
+            update_fields = []
             for field, value in defaults.items():
-                setattr(node, field, value)
-            update_fields = list(defaults.keys())
-            node.save(update_fields=update_fields)
+                if getattr(node, field) != value:
+                    setattr(node, field, value)
+                    update_fields.append(field)
+            if desired_role and node.role_id != desired_role.id:
+                node.role = desired_role
+                update_fields.append("role")
+            if update_fields:
+                node.save(update_fields=update_fields)
             created = False
         else:
             node = cls.objects.create(**defaults)
             created = True
-            # assign role from installation lock file
-            role_lock = Path(settings.BASE_DIR) / "locks" / "role.lck"
-            role_name = (
-                role_lock.read_text().strip() if role_lock.exists() else "Terminal"
-            )
-            role = NodeRole.objects.filter(name=role_name).first()
-            if role:
-                node.role = role
+            if desired_role:
+                node.role = desired_role
                 node.save(update_fields=["role"])
         if created and node.role is None:
             terminal = NodeRole.objects.filter(name="Terminal").first()
@@ -412,11 +472,84 @@ 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):
+            role_name = role.name
+        elif self.role_id:
+            role_name = (
+                NodeRole.objects.filter(pk=self.role_id)
+                .values_list("name", flat=True)
+                .first()
+            )
+
+        role_color = self.ROLE_BADGE_COLORS.get(role_name)
+        if role_color and (
+            not self.badge_color or self.badge_color == self.DEFAULT_BADGE_COLOR
+        ):
+            self.badge_color = role_color
+            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()
@@ -525,13 +658,6 @@ class Node(Entity):
                 return True
         return False
 
-    @staticmethod
-    def _uses_postgres() -> bool:
-        """Return ``True`` when the default database uses PostgreSQL."""
-
-        engine = settings.DATABASES.get("default", {}).get("ENGINE", "")
-        return "postgresql" in engine.lower()
-
     def refresh_features(self):
         if not self.pk:
             return
@@ -552,8 +678,6 @@ class Node(Entity):
                 detected_slugs.add("ap-public-wifi")
             else:
                 detected_slugs.add("ap-router")
-        if self._uses_postgres():
-            detected_slugs.add("postgres-db")
         try:
             from core.notifications import supports_gui_toast
         except Exception:
@@ -681,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:])
@@ -1057,11 +1190,15 @@ class EmailOutbox(Profile):
 
         username = (self.username or "").strip()
         host = (self.host or "").strip()
-        if username and host:
-            if "@" in username:
-                return username
-            return f"{username}@{host}"
         if username:
+            local, sep, domain = username.partition("@")
+            if sep and domain:
+                return username
+            if host:
+                sanitized = username.rstrip("@")
+                if sanitized:
+                    return f"{sanitized}@{host}"
+                return host
             return username
         if host:
             return host
@@ -1126,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"
     )
@@ -1217,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"],
@@ -1244,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:
+                self.complete = True
+                self.save(update_fields=["complete"])
+                return
+        else:
+            if self.filter_node_role_id:
+                role_order = [reach_name]
             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)
+                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]
@@ -1275,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: