arthexis 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

nodes/models.py

@@ -4,6 +4,7 @@ from collections.abc import Iterable
 from copy import deepcopy
 from dataclasses import dataclass
 from django.db import models
+from django.apps import apps
 from django.db.models import Q
 from django.db.utils import DatabaseError
 from django.db.models.signals import post_delete
@@ -29,6 +30,10 @@ from pathlib import Path
 from urllib.parse import urlparse, urlunsplit
 from utils import revision
 from core.notifications import notify_async
+from core.celery_utils import (
+    normalize_periodic_task_name,
+    periodic_task_name_variants,
+)
 from django.core.exceptions import ValidationError
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization, hashes
@@ -214,7 +219,7 @@ class Node(Entity):
     )
     address = models.GenericIPAddressField(blank=True, null=True)
     mac_address = models.CharField(max_length=17, unique=True, null=True, blank=True)
-    port = models.PositiveIntegerField(default=8000)
+    port = models.PositiveIntegerField(default=8888)
     message_queue_length = models.PositiveSmallIntegerField(
         default=10,
         help_text="Maximum queued NetMessages to retain for this peer.",
@@ -258,6 +263,7 @@ class Node(Entity):
     RPI_CAMERA_DEVICE = Path("/dev/video0")
     RPI_CAMERA_BINARIES = ("rpicam-hello", "rpicam-still", "rpicam-vid")
     AP_ROUTER_SSID = "gelectriic-ap"
+    AUDIO_CAPTURE_PCM_PATH = Path("/proc/asound/pcm")
     NMCLI_TIMEOUT = 5
     AUTO_MANAGED_FEATURES = set(FEATURE_LOCK_MAP.keys()) | {
         "gui-toast",
@@ -407,7 +413,7 @@ class Node(Entity):
         """Yield potential remote URLs for ``path`` on this node."""
 
         host_candidates = self.get_remote_host_candidates()
-        default_port = self.port or 8000
+        default_port = self.port or 8888
         normalized_path = path if path.startswith("/") else f"/{path}"
         seen: set[str] = set()
 
@@ -602,7 +608,7 @@ class Node(Entity):
         ipv6_address = cls._select_preferred_ip(ipv6_candidates)
 
         preferred_contact = ipv4_address or ipv6_address or direct_address or "127.0.0.1"
-        port = int(os.environ.get("PORT", 8000))
+        port = int(os.environ.get("PORT", 8888))
         base_path = str(settings.BASE_DIR)
         ver_path = Path(settings.BASE_DIR) / "VERSION"
         installed_version = ver_path.read_text().strip() if ver_path.exists() else ""
@@ -721,7 +727,7 @@ class Node(Entity):
         peers = Node.objects.exclude(pk=self.pk)
         for peer in peers:
             host_candidates = peer.get_remote_host_candidates()
-            port = peer.port or 8000
+            port = peer.port or 8888
             urls: list[str] = []
             for host in host_candidates:
                 host = host.strip()
@@ -839,7 +845,13 @@ class Node(Entity):
     @property
     def is_local(self):
         """Determine if this node represents the current host."""
-        return self.mac_address == self.get_current_mac()
+        current_mac = self.get_current_mac()
+        stored_mac = (self.mac_address or "").strip()
+        if stored_mac:
+            normalized_stored = stored_mac.replace("-", ":").lower()
+            normalized_current = current_mac.replace("-", ":").lower()
+            return normalized_stored == normalized_current
+        return self.current_relation == self.Relation.SELF
 
     @classmethod
     def _generate_unique_public_endpoint(
@@ -919,13 +931,41 @@ class Node(Entity):
         if self.public_endpoint != endpoint_value:
             self.public_endpoint = endpoint_value
             include_update_field("public_endpoint")
+        is_new = self.pk is None
         super().save(*args, **kwargs)
         if self.pk:
+            if is_new:
+                self._apply_role_manual_features()
             self.refresh_features()
 
     def has_feature(self, slug: str) -> bool:
         return self.features.filter(slug=slug).exists()
 
+    def _apply_role_manual_features(self) -> None:
+        """Enable manual features configured as defaults for this node's role."""
+
+        if not self.role_id:
+            return
+
+        role_features = self.role.features.filter(
+            slug__in=self.MANUAL_FEATURE_SLUGS
+        ).values_list("slug", flat=True)
+        desired = set(role_features)
+        if not desired:
+            return
+
+        existing = set(
+            self.features.filter(slug__in=desired).values_list("slug", flat=True)
+        )
+        missing = desired - existing
+        if not missing:
+            return
+
+        for feature in NodeFeature.objects.filter(slug__in=missing):
+            NodeFeatureAssignment.objects.update_or_create(
+                node=self, feature=feature
+            )
+
     @classmethod
     def _has_rpi_camera(cls) -> bool:
         """Return ``True`` when the Raspberry Pi camera stack is available."""
@@ -960,6 +1000,29 @@ class Node(Entity):
                 return False
         return True
 
+    @classmethod
+    def _has_audio_capture_device(cls) -> bool:
+        """Return ``True`` when an audio capture device is available."""
+
+        pcm_path = cls.AUDIO_CAPTURE_PCM_PATH
+        try:
+            contents = pcm_path.read_text(errors="ignore")
+        except OSError:
+            return False
+        for line in contents.splitlines():
+            candidate = line.strip()
+            if not candidate:
+                continue
+            lower_candidate = candidate.lower()
+            if "capture" not in lower_candidate:
+                continue
+            match = re.search(r"capture\s+(\d+)", lower_candidate)
+            if not match:
+                continue
+            if int(match.group(1)) > 0:
+                return True
+        return False
+
     @classmethod
     def _hosts_gelectriic_ap(cls) -> bool:
         """Return ``True`` when the node is hosting the gelectriic access point."""
@@ -1098,10 +1161,13 @@ class Node(Entity):
     def _sync_clipboard_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
 
-        task_name = f"poll_clipboard_node_{self.pk}"
+        raw_task_name = f"poll_clipboard_node_{self.pk}"
         if enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
-                every=5, period=IntervalSchedule.SECONDS
+                every=10, period=IntervalSchedule.SECONDS
+            )
+            task_name = normalize_periodic_task_name(
+                PeriodicTask.objects, raw_task_name
             )
             PeriodicTask.objects.update_or_create(
                 name=task_name,
@@ -1111,17 +1177,22 @@ class Node(Entity):
                 },
             )
         else:
-            PeriodicTask.objects.filter(name=task_name).delete()
+            PeriodicTask.objects.filter(
+                name__in=periodic_task_name_variants(raw_task_name)
+            ).delete()
 
     def _sync_screenshot_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
         import json
 
-        task_name = f"capture_screenshot_node_{self.pk}"
+        raw_task_name = f"capture_screenshot_node_{self.pk}"
         if enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
                 every=1, period=IntervalSchedule.MINUTES
             )
+            task_name = normalize_periodic_task_name(
+                PeriodicTask.objects, raw_task_name
+            )
             PeriodicTask.objects.update_or_create(
                 name=task_name,
                 defaults={
@@ -1137,7 +1208,9 @@ class Node(Entity):
                 },
             )
         else:
-            PeriodicTask.objects.filter(name=task_name).delete()
+            PeriodicTask.objects.filter(
+                name__in=periodic_task_name_variants(raw_task_name)
+            ).delete()
 
     def _sync_landing_lead_task(self, enabled: bool):
         if not self.is_local:
@@ -1145,7 +1218,10 @@ class Node(Entity):
 
         from django_celery_beat.models import CrontabSchedule, PeriodicTask
 
-        task_name = "pages_purge_landing_leads"
+        raw_task_name = "pages_purge_landing_leads"
+        task_name = normalize_periodic_task_name(
+            PeriodicTask.objects, raw_task_name
+        )
         if enabled:
             schedule, _ = CrontabSchedule.objects.get_or_create(
                 minute="0",
@@ -1164,19 +1240,26 @@ class Node(Entity):
                 },
             )
         else:
-            PeriodicTask.objects.filter(name=task_name).delete()
+            PeriodicTask.objects.filter(
+                name__in=periodic_task_name_variants(raw_task_name)
+            ).delete()
 
     def _sync_ocpp_session_report_task(self, celery_enabled: bool):
         from django_celery_beat.models import CrontabSchedule, PeriodicTask
         from django.db.utils import OperationalError, ProgrammingError
 
-        task_name = "ocpp_send_daily_session_report"
+        raw_task_name = "ocpp_send_daily_session_report"
+        task_name = normalize_periodic_task_name(
+            PeriodicTask.objects, raw_task_name
+        )
 
         if not self.is_local:
             return
 
         if not celery_enabled or not mailer.can_send_email():
-            PeriodicTask.objects.filter(name=task_name).delete()
+            PeriodicTask.objects.filter(
+                name__in=periodic_task_name_variants(raw_task_name)
+            ).delete()
             return
 
         try:
@@ -1205,10 +1288,13 @@ class Node(Entity):
 
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
 
-        task_name = "nodes_poll_upstream_messages"
+        raw_task_name = "nodes_poll_upstream_messages"
+        task_name = normalize_periodic_task_name(
+            PeriodicTask.objects, raw_task_name
+        )
         if celery_enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
-                every=1, period=IntervalSchedule.MINUTES
+                every=5, period=IntervalSchedule.MINUTES
             )
             PeriodicTask.objects.update_or_create(
                 name=task_name,
@@ -1219,7 +1305,9 @@ class Node(Entity):
                 },
             )
         else:
-            PeriodicTask.objects.filter(name=task_name).delete()
+            PeriodicTask.objects.filter(
+                name__in=periodic_task_name_variants(raw_task_name)
+            ).delete()
 
     def send_mail(
         self,
@@ -1246,6 +1334,10 @@ class Node(Entity):
             **kwargs,
         )
 
+    class Meta:
+        verbose_name = "Node"
+        verbose_name_plural = "Nodes"
+
 
 node_information_updated = Signal()
 
@@ -1698,7 +1790,6 @@ class EmailOutbox(Profile):
             return owner
         return str(self.node) if self.node_id else ""
 
-
 class NetMessage(Entity):
     """Message propagated across nodes."""
 
@@ -1808,9 +1899,44 @@ class NetMessage(Entity):
         )
         if normalized_attachments:
             msg.apply_attachments(normalized_attachments)
+        msg.notify_slack()
         msg.propagate(seen=seen or [])
         return msg
 
+    def notify_slack(self):
+        """Send this Net Message to any Slack chatbots owned by the origin node."""
+
+        try:
+            SlackBotProfile = apps.get_model("teams", "SlackBotProfile")
+        except (LookupError, ValueError):
+            return
+        if SlackBotProfile is None:
+            return
+
+        origin = self.node_origin
+        if origin is None:
+            origin = Node.get_local()
+        if not origin:
+            return
+
+        try:
+            bots = SlackBotProfile.objects.filter(node=origin, is_enabled=True)
+        except Exception:  # pragma: no cover - database errors surfaced in logs
+            logger.exception(
+                "Failed to load Slack chatbots for node %s", getattr(origin, "pk", None)
+            )
+            return
+
+        for bot in bots:
+            try:
+                bot.broadcast_net_message(self)
+            except Exception:  # pragma: no cover - network errors logged for diagnosis
+                logger.exception(
+                    "Slack bot %s failed to broadcast NetMessage %s",
+                    getattr(bot, "pk", None),
+                    getattr(self, "pk", None),
+                )
+
     @staticmethod
     def normalize_attachments(
         attachments: object,
@@ -2251,6 +2377,8 @@ class PendingNetMessage(models.Model):
     class Meta:
         unique_together = ("node", "message")
         ordering = ("queued_at",)
+        verbose_name = "Pending Net Message"
+        verbose_name_plural = "Pending Net Messages"
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.message_id} → {self.node_id}"

nodes/tasks.py

@@ -36,7 +36,7 @@ def sample_clipboard() -> None:
 
 @shared_task
 def capture_node_screenshot(
-    url: str | None = None, port: int = 8000, method: str = "TASK"
+    url: str | None = None, port: int = 8888, method: str = "TASK"
 ) -> str:
     """Capture a screenshot of ``url`` and record it as a :class:`ContentSample`."""
     if url is None: