arthexis 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

nodes/models.py

@@ -1,10 +1,10 @@
+from collections.abc import Iterable
 from django.db import models
+from django.db.models.signals import post_delete
+from django.dispatch import receiver
 from core.entity import Entity
-from core.fields import (
-    SigilShortAutoField,
-    SigilLongCheckField,
-    SigilLongAutoField,
-)
+from core.models import Profile
+from core.fields import SigilShortAutoField
 import re
 import json
 import base64
@@ -13,7 +13,10 @@ from django.conf import settings
 from django.contrib.sites.models import Site
 import uuid
 import os
+import shutil
 import socket
+import stat
+import subprocess
 from pathlib import Path
 from utils import revision
 from django.core.exceptions import ValidationError
@@ -21,7 +24,8 @@ from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.primitives import serialization, hashes
 from cryptography.hazmat.primitives.asymmetric import padding
 from django.contrib.auth import get_user_model
-from django.core.mail import get_connection, send_mail
+from django.core.mail import get_connection
+from core import mailer
 import logging
 
 
@@ -53,6 +57,60 @@ class NodeRole(Entity):
         return self.name
 
 
+class NodeFeatureManager(models.Manager):
+    def get_by_natural_key(self, slug: str):
+        return self.get(slug=slug)
+
+
+class NodeFeature(Entity):
+    """Feature that may be enabled on nodes and roles."""
+
+    slug = models.SlugField(max_length=50, unique=True)
+    display = models.CharField(max_length=50)
+    roles = models.ManyToManyField(NodeRole, blank=True, related_name="features")
+
+    objects = NodeFeatureManager()
+
+    class Meta:
+        ordering = ["display"]
+        verbose_name = "Node Feature"
+        verbose_name_plural = "Node Features"
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        return (self.slug,)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.display
+
+    @property
+    def is_enabled(self) -> bool:
+        from django.conf import settings
+        from pathlib import Path
+
+        node = Node.get_local()
+        if not node:
+            return False
+        if node.features.filter(pk=self.pk).exists():
+            return True
+        if self.slug == "gui-toast":
+            from core.notifications import supports_gui_toast
+
+            return supports_gui_toast()
+        if self.slug == "rpi-camera":
+            return Node._has_rpi_camera()
+        lock_map = {
+            "lcd-screen": "lcd_screen.lck",
+            "rfid-scanner": "rfid.lck",
+            "celery-queue": "celery.lck",
+            "nginx-server": "nginx_mode.lck",
+        }
+        lock = lock_map.get(self.slug)
+        if lock:
+            base_path = Path(node.base_path or settings.BASE_DIR)
+            return (base_path / "locks" / lock).exists()
+        return False
+
+
 def get_terminal_role():
     """Return the NodeRole representing a Terminal if it exists."""
     return NodeRole.objects.filter(name="Terminal").first()
@@ -63,9 +121,7 @@ class Node(Entity):
 
     hostname = models.CharField(max_length=100)
     address = models.GenericIPAddressField()
-    mac_address = models.CharField(
-        max_length=17, unique=True, null=True, blank=True
-    )
+    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")
     role = models.ForeignKey(NodeRole, on_delete=models.SET_NULL, null=True, blank=True)
@@ -75,8 +131,6 @@ class Node(Entity):
         verbose_name="enable public API",
     )
     public_endpoint = models.SlugField(blank=True, unique=True)
-    clipboard_polling = models.BooleanField(default=False)
-    screenshot_polling = models.BooleanField(default=False)
     uuid = models.UUIDField(
         default=uuid.uuid4,
         unique=True,
@@ -87,7 +141,31 @@ class Node(Entity):
     base_path = models.CharField(max_length=255, blank=True)
     installed_version = models.CharField(max_length=20, blank=True)
     installed_revision = models.CharField(max_length=40, blank=True)
-    has_lcd_screen = models.BooleanField(default=False)
+    features = models.ManyToManyField(
+        NodeFeature,
+        through="NodeFeatureAssignment",
+        related_name="nodes",
+        blank=True,
+    )
+
+    FEATURE_LOCK_MAP = {
+        "lcd-screen": "lcd_screen.lck",
+        "rfid-scanner": "rfid.lck",
+        "celery-queue": "celery.lck",
+        "nginx-server": "nginx_mode.lck",
+    }
+    RPI_CAMERA_DEVICE = Path("/dev/video0")
+    RPI_CAMERA_BINARIES = ("rpicam-hello", "rpicam-still", "rpicam-vid")
+    AP_ROUTER_SSID = "gelectriic-ap"
+    NMCLI_TIMEOUT = 5
+    AUTO_MANAGED_FEATURES = set(FEATURE_LOCK_MAP.keys()) | {
+        "gui-toast",
+        "rpi-camera",
+        "ap-router",
+        "ap-public-wifi",
+        "postgres-db",
+    }
+    MANUAL_FEATURE_SLUGS = {"clipboard-poll", "screenshot-poll"}
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.hostname}:{self.port}"
@@ -122,7 +200,6 @@ class Node(Entity):
         node = cls.objects.filter(mac_address=mac).first()
         if not node:
             node = cls.objects.filter(public_endpoint=slug).first()
-        lcd_lock = Path(settings.BASE_DIR) / "locks" / "lcd_screen.lck"
         defaults = {
             "hostname": hostname,
             "address": address,
@@ -132,14 +209,11 @@ class Node(Entity):
             "installed_revision": installed_revision,
             "public_endpoint": slug,
             "mac_address": mac,
-            "has_lcd_screen": lcd_lock.exists(),
         }
         if node:
             for field, value in defaults.items():
-                if field == "has_lcd_screen":
-                    continue
                 setattr(node, field, value)
-            update_fields = [k for k in defaults.keys() if k != "has_lcd_screen"]
+            update_fields = list(defaults.keys())
             node.save(update_fields=update_fields)
             created = False
         else:
@@ -169,9 +243,7 @@ class Node(Entity):
         priv_path = security_dir / f"{self.public_endpoint}"
         pub_path = security_dir / f"{self.public_endpoint}.pub"
         if not priv_path.exists() or not pub_path.exists():
-            private_key = rsa.generate_private_key(
-                public_exponent=65537, key_size=2048
-            )
+            private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
             private_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
                 format=serialization.PrivateFormat.TraditionalOpenSSL,
@@ -199,22 +271,196 @@ class Node(Entity):
             self.mac_address = self.mac_address.lower()
         if not self.public_endpoint:
             self.public_endpoint = slugify(self.hostname)
-        previous_clipboard = previous_screenshot = None
-        if self.pk:
-            previous = Node.objects.get(pk=self.pk)
-            previous_clipboard = previous.clipboard_polling
-            previous_screenshot = previous.screenshot_polling
         super().save(*args, **kwargs)
-        if previous_clipboard != self.clipboard_polling:
-            self._sync_clipboard_task()
-        if previous_screenshot != self.screenshot_polling:
-            self._sync_screenshot_task()
+        if self.pk:
+            self.refresh_features()
+
+    def has_feature(self, slug: str) -> bool:
+        return self.features.filter(slug=slug).exists()
+
+    @classmethod
+    def _has_rpi_camera(cls) -> bool:
+        """Return ``True`` when the Raspberry Pi camera stack is available."""
+
+        device = cls.RPI_CAMERA_DEVICE
+        if not device.exists():
+            return False
+        device_path = str(device)
+        try:
+            mode = os.stat(device_path).st_mode
+        except OSError:
+            return False
+        if not stat.S_ISCHR(mode):
+            return False
+        if not os.access(device_path, os.R_OK | os.W_OK):
+            return False
+        for binary in cls.RPI_CAMERA_BINARIES:
+            tool_path = shutil.which(binary)
+            if not tool_path:
+                return False
+            try:
+                result = subprocess.run(
+                    [tool_path, "--help"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=5,
+                )
+            except Exception:
+                return False
+            if result.returncode != 0:
+                return False
+        return True
+
+    @classmethod
+    def _hosts_gelectriic_ap(cls) -> bool:
+        """Return ``True`` when the node is hosting the gelectriic access point."""
+
+        nmcli_path = shutil.which("nmcli")
+        if not nmcli_path:
+            return False
+        try:
+            result = subprocess.run(
+                [
+                    nmcli_path,
+                    "-t",
+                    "-f",
+                    "NAME,DEVICE,TYPE",
+                    "connection",
+                    "show",
+                    "--active",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=cls.NMCLI_TIMEOUT,
+            )
+        except Exception:
+            return False
+        if result.returncode != 0:
+            return False
+        for line in result.stdout.splitlines():
+            if not line:
+                continue
+            parts = line.split(":", 2)
+            if not parts:
+                continue
+            name = parts[0]
+            conn_type = ""
+            if len(parts) == 3:
+                conn_type = parts[2]
+            elif len(parts) > 1:
+                conn_type = parts[1]
+            if name != cls.AP_ROUTER_SSID:
+                continue
+            conn_type_normalized = conn_type.strip().lower()
+            if conn_type_normalized not in {"wifi", "802-11-wireless"}:
+                continue
+            try:
+                mode_result = subprocess.run(
+                    [
+                        nmcli_path,
+                        "-g",
+                        "802-11-wireless.mode",
+                        "connection",
+                        "show",
+                        name,
+                    ],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                    timeout=cls.NMCLI_TIMEOUT,
+                )
+            except Exception:
+                continue
+            if mode_result.returncode != 0:
+                continue
+            if mode_result.stdout.strip() == "ap":
+                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
+        if not self.is_local:
+            self.sync_feature_tasks()
+            return
+        detected_slugs = set()
+        base_path = Path(self.base_path or settings.BASE_DIR)
+        locks_dir = base_path / "locks"
+        for slug, filename in self.FEATURE_LOCK_MAP.items():
+            if (locks_dir / filename).exists():
+                detected_slugs.add(slug)
+        if self._has_rpi_camera():
+            detected_slugs.add("rpi-camera")
+        public_mode_lock = locks_dir / "public_wifi_mode.lck"
+        if self._hosts_gelectriic_ap():
+            if public_mode_lock.exists():
+                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:
+            pass
+        else:
+            try:
+                if supports_gui_toast():
+                    detected_slugs.add("gui-toast")
+            except Exception:
+                pass
+        current_slugs = set(
+            self.features.filter(slug__in=self.AUTO_MANAGED_FEATURES).values_list(
+                "slug", flat=True
+            )
+        )
+        add_slugs = detected_slugs - current_slugs
+        if add_slugs:
+            for feature in NodeFeature.objects.filter(slug__in=add_slugs):
+                NodeFeatureAssignment.objects.update_or_create(
+                    node=self, feature=feature
+                )
+        remove_slugs = current_slugs - detected_slugs
+        if remove_slugs:
+            NodeFeatureAssignment.objects.filter(
+                node=self, feature__slug__in=remove_slugs
+            ).delete()
+        self.sync_feature_tasks()
+
+    def update_manual_features(self, slugs: Iterable[str]):
+        desired = {slug for slug in slugs if slug in self.MANUAL_FEATURE_SLUGS}
+        remove_slugs = self.MANUAL_FEATURE_SLUGS - desired
+        if remove_slugs:
+            NodeFeatureAssignment.objects.filter(
+                node=self, feature__slug__in=remove_slugs
+            ).delete()
+        if desired:
+            for feature in NodeFeature.objects.filter(slug__in=desired):
+                NodeFeatureAssignment.objects.update_or_create(
+                    node=self, feature=feature
+                )
+        self.sync_feature_tasks()
 
-    def _sync_clipboard_task(self):
+    def sync_feature_tasks(self):
+        clipboard_enabled = self.has_feature("clipboard-poll")
+        screenshot_enabled = self.has_feature("screenshot-poll")
+        self._sync_clipboard_task(clipboard_enabled)
+        self._sync_screenshot_task(screenshot_enabled)
+
+    def _sync_clipboard_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
 
         task_name = f"poll_clipboard_node_{self.pk}"
-        if self.clipboard_polling:
+        if enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
                 every=5, period=IntervalSchedule.SECONDS
             )
@@ -228,12 +474,12 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
-    def _sync_screenshot_task(self):
+    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}"
-        if self.screenshot_polling:
+        if enabled:
             schedule, _ = IntervalSchedule.objects.get_or_create(
                 every=1, period=IntervalSchedule.MINUTES
             )
@@ -254,45 +500,93 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
-
-    def send_mail(self, subject: str, message: str, recipient_list: list[str], from_email: str | None = None, **kwargs):
+    def send_mail(
+        self,
+        subject: str,
+        message: str,
+        recipient_list: list[str],
+        from_email: str | None = None,
+        **kwargs,
+    ):
         """Send an email using this node's configured outbox if available."""
         outbox = getattr(self, "email_outbox", None)
         logger.info(
-            "Node %s sending email to %s using %s backend",
+            "Node %s queueing email to %s using %s backend",
             self.pk,
             recipient_list,
             "outbox" if outbox else "default",
         )
-        if outbox:
-            result = outbox.send_mail(subject, message, recipient_list, from_email, **kwargs)
-            logger.info("Outbox send_mail result: %s", result)
-            return result
-        from_email = from_email or settings.DEFAULT_FROM_EMAIL
-        result = send_mail(subject, message, from_email, recipient_list, **kwargs)
-        logger.info("Default send_mail result: %s", result)
-        return result
+        return mailer.send(
+            subject,
+            message,
+            recipient_list,
+            from_email,
+            outbox=outbox,
+            **kwargs,
+        )
+
 
+class NodeFeatureAssignment(Entity):
+    """Bridge between :class:`Node` and :class:`NodeFeature`."""
 
-class EmailOutbox(Entity):
-    """SMTP credentials for sending mail from a node."""
+    node = models.ForeignKey(
+        Node, on_delete=models.CASCADE, related_name="feature_assignments"
+    )
+    feature = models.ForeignKey(
+        NodeFeature, on_delete=models.CASCADE, related_name="node_assignments"
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        unique_together = ("node", "feature")
+        verbose_name = "Node Feature Assignment"
+        verbose_name_plural = "Node Feature Assignments"
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.node} -> {self.feature}"
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        self.node.sync_feature_tasks()
+
+
+@receiver(post_delete, sender=NodeFeatureAssignment)
+def _sync_tasks_on_assignment_delete(sender, instance, **kwargs):
+    node_id = getattr(instance, "node_id", None)
+    if not node_id:
+        return
+    node = Node.objects.filter(pk=node_id).first()
+    if node:
+        node.sync_feature_tasks()
+
+
+class EmailOutbox(Profile):
+    """SMTP credentials for sending mail."""
+
+    profile_fields = (
+        "host",
+        "port",
+        "username",
+        "password",
+        "use_tls",
+        "use_ssl",
+        "from_email",
+    )
 
     node = models.OneToOneField(
-        Node, on_delete=models.CASCADE, related_name="email_outbox"
+        Node,
+        on_delete=models.CASCADE,
+        related_name="email_outbox",
+        null=True,
+        blank=True,
     )
     host = SigilShortAutoField(
         max_length=100,
-        help_text=(
-            "Gmail: smtp.gmail.com. "
-            "GoDaddy: smtpout.secureserver.net"
-        ),
+        help_text=("Gmail: smtp.gmail.com. " "GoDaddy: smtpout.secureserver.net"),
     )
     port = models.PositiveIntegerField(
         default=587,
-        help_text=(
-            "Gmail: 587 (TLS). "
-            "GoDaddy: 587 (TLS) or 465 (SSL)"
-        ),
+        help_text=("Gmail: 587 (TLS). " "GoDaddy: 587 (TLS) or 465 (SSL)"),
     )
     username = SigilShortAutoField(
         max_length=100,
@@ -323,12 +617,15 @@ class EmailOutbox(Entity):
         verbose_name = "Email Outbox"
         verbose_name_plural = "Email Outboxes"
 
-    class Meta:
-        verbose_name = "Email Outbox"
-        verbose_name_plural = "Email Outboxes"
+    def clean(self):
+        if self.user_id or self.group_id:
+            super().clean()
+        else:
+            super(Profile, self).clean()
 
     def get_connection(self):
         return get_connection(
+            "django.core.mail.backends.smtp.EmailBackend",
             host=self.host,
             port=self.port,
             username=self.username or None,
@@ -338,17 +635,23 @@ class EmailOutbox(Entity):
         )
 
     def send_mail(self, subject, message, recipient_list, from_email=None, **kwargs):
-        connection = self.get_connection()
         from_email = from_email or self.from_email or settings.DEFAULT_FROM_EMAIL
-        return send_mail(
+        logger.info("EmailOutbox %s queueing email to %s", self.pk, recipient_list)
+        return mailer.send(
             subject,
             message,
-            from_email,
             recipient_list,
-            connection=connection,
+            from_email,
+            outbox=self,
             **kwargs,
         )
 
+    def owner_display(self):
+        owner = super().owner_display()
+        if owner:
+            return owner
+        return str(self.node) if self.node_id else ""
+
 
 class NetMessage(Entity):
     """Message propagated across nodes."""
@@ -448,12 +751,15 @@ class NetMessage(Entity):
 
         reach_name = self.reach.name if self.reach else "Terminal"
         role_map = {
-            "Particle": ["Particle"],
-            "Terminal": ["Terminal", "Particle"],
-            "Control": ["Control", "Terminal", "Particle"],
-            "Satellite": ["Satellite", "Control", "Terminal", "Particle"],
-            "Constellation": ["Constellation", "Satellite", "Control", "Terminal", "Particle"],
-            "Virtual": ["Virtual", "Constellation", "Satellite", "Control", "Terminal", "Particle"],
+            "Terminal": ["Terminal"],
+            "Control": ["Control", "Terminal"],
+            "Satellite": ["Satellite", "Control", "Terminal"],
+            "Constellation": [
+                "Constellation",
+                "Satellite",
+                "Control",
+                "Terminal",
+            ],
         }
         role_order = role_map.get(reach_name, ["Terminal"])
         selected: list[Node] = []
@@ -527,9 +833,7 @@ class ContentSample(Entity):
         db_index=True,
         verbose_name="transaction UUID",
     )
-    node = models.ForeignKey(
-        Node, on_delete=models.SET_NULL, null=True, blank=True
-    )
+    node = models.ForeignKey(Node, on_delete=models.SET_NULL, null=True, blank=True)
     user = models.ForeignKey(
         settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, null=True, blank=True
     )
@@ -555,109 +859,6 @@ class ContentSample(Entity):
         return str(self.name)
 
 
-class NodeTask(Entity):
-    """Script that can be executed on nodes."""
-
-    recipe = models.TextField()
-    role = models.ForeignKey(NodeRole, on_delete=models.SET_NULL, null=True, blank=True)
-    created = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        ordering = ["-created"]
-        verbose_name = "Node Task"
-        verbose_name_plural = "Node Tasks"
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.recipe
-
-    def run(self, node: Node):
-        """Execute this script on ``node`` and return its output."""
-        if not node.is_local:
-            raise NotImplementedError("Remote node execution is not implemented")
-        import subprocess
-
-        result = subprocess.run(
-            self.recipe, shell=True, capture_output=True, text=True
-        )
-        return result.stdout + result.stderr
-
-
-class Operation(Entity):
-    """Action that can change node or constellation state."""
-
-    name = models.SlugField(unique=True)
-    template = SigilLongCheckField(blank=True)
-    command = SigilLongAutoField(blank=True)
-    is_django = models.BooleanField(default=False)
-    next_operations = models.ManyToManyField(
-        "self",
-        through="Interrupt",
-        through_fields=("from_operation", "to_operation"),
-        symmetrical=False,
-        related_name="previous_operations",
-    )
-
-    class Meta:
-        ordering = ["name"]
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.name
-
-
-class Interrupt(Entity):
-    """Intermediate transition between operations."""
-
-    name = models.CharField(max_length=100)
-    preview = SigilLongAutoField(blank=True)
-    priority = models.PositiveIntegerField(default=0)
-    from_operation = models.ForeignKey(
-        Operation,
-        on_delete=models.CASCADE,
-        related_name="outgoing_interrupts",
-    )
-    to_operation = models.ForeignKey(
-        Operation,
-        on_delete=models.CASCADE,
-        related_name="incoming_interrupts",
-    )
-
-    class Meta:
-        ordering = ["-priority"]
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.name
- 
-
-class Logbook(Entity):
-    """Record of executed operations."""
-
-    operation = models.ForeignKey(
-        Operation, on_delete=models.CASCADE, related_name="logs"
-    )
-    user = models.ForeignKey(
-        settings.AUTH_USER_MODEL,
-        null=True,
-        blank=True,
-        on_delete=models.SET_NULL,
-    )
-    input_text = models.TextField(blank=True)
-    output = models.TextField(blank=True)
-    error = models.TextField(blank=True)
-    interrupted = models.BooleanField(default=False)
-    interrupt = models.ForeignKey(
-        Interrupt, null=True, blank=True, on_delete=models.SET_NULL
-    )
-    created = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        ordering = ["-created"]
-        verbose_name = "Logbook Entry"
-        verbose_name_plural = "Logbook"
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return f"{self.operation} @ {self.created:%Y-%m-%d %H:%M:%S}"
-
-
 UserModel = get_user_model()
 
 
@@ -667,7 +868,3 @@ class User(UserModel):
         app_label = "nodes"
         verbose_name = UserModel._meta.verbose_name
         verbose_name_plural = UserModel._meta.verbose_name_plural
-
-
-
-