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

nodes/models.py

@@ -1,10 +1,14 @@
+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.fields import SigilShortAutoField
+from core.fields import SigilLongAutoField, SigilShortAutoField
 import re
 import json
 import base64
@@ -65,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."""
 
@@ -74,6 +84,24 @@ class NodeFeature(Entity):
 
     objects = NodeFeatureManager()
 
+    DEFAULT_ACTIONS = {
+        "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",
+        ),
+    }
+
     class Meta:
         ordering = ["display"]
         verbose_name = "Node Feature"
@@ -113,6 +141,11 @@ class NodeFeature(Entity):
             return (base_path / "locks" / lock).exists()
         return False
 
+    def get_default_action(self) -> NodeFeatureDefaultAction | None:
+        """Return the configured default action for this feature if any."""
+
+        return self.DEFAULT_ACTIONS.get(self.slug)
+
 
 def get_terminal_role():
     """Return the NodeRole representing a Terminal if it exists."""
@@ -122,12 +155,29 @@ 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"
+        PEER = "PEER", "Peer"
+        SELF = "SELF", "Self"
+
     hostname = models.CharField(max_length=100)
     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,
+        choices=Relation.choices,
+        default=Relation.PEER,
+    )
     last_seen = models.DateTimeField(auto_now=True)
     enable_public_api = models.BooleanField(
         default=False,
@@ -166,7 +216,6 @@ class Node(Entity):
         "rpi-camera",
         "ap-router",
         "ap-public-wifi",
-        "postgres-db",
     }
     MANUAL_FEATURE_SLUGS = {"clipboard-poll", "screenshot-poll"}
 
@@ -178,11 +227,35 @@ class Node(Entity):
         """Return the MAC address of the current host."""
         return ":".join(re.findall("..", f"{uuid.getnode():012x}"))
 
+    @classmethod
+    def normalize_relation(cls, value):
+        """Normalize ``value`` to a valid :class:`Relation`."""
+
+        if isinstance(value, cls.Relation):
+            return value
+        if value is None:
+            return cls.Relation.PEER
+        text = str(value).strip()
+        if not text:
+            return cls.Relation.PEER
+        for relation in cls.Relation:
+            if text.lower() == relation.label.lower():
+                return relation
+            if text.upper() == relation.name:
+                return relation
+            if text.lower() == relation.value.lower():
+                return relation
+        return cls.Relation.PEER
+
     @classmethod
     def get_local(cls):
         """Return the node representing the current host if it exists."""
         mac = cls.get_current_mac()
-        return cls.objects.filter(mac_address=mac).first()
+        try:
+            return cls.objects.filter(mac_address=mac).first()
+        except DatabaseError:
+            logger.debug("nodes.Node.get_local skipped: database unavailable", exc_info=True)
+            return None
 
     @classmethod
     def register_current(cls):
@@ -212,24 +285,29 @@ class Node(Entity):
             "installed_revision": installed_revision,
             "public_endpoint": slug,
             "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()
@@ -374,6 +452,29 @@ class Node(Entity):
         return self.mac_address == self.get_current_mac()
 
     def save(self, *args, **kwargs):
+        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
+            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)
+
         if self.mac_address:
             self.mac_address = self.mac_address.lower()
         if not self.public_endpoint:
@@ -486,13 +587,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
@@ -513,8 +607,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:
@@ -713,6 +805,243 @@ def _sync_tasks_on_assignment_delete(sender, instance, **kwargs):
         node.sync_feature_tasks()
 
 
+class NodeManager(Profile):
+    """Credentials for interacting with external DNS providers."""
+
+    class Provider(models.TextChoices):
+        GODADDY = "godaddy", "GoDaddy"
+
+    profile_fields = (
+        "provider",
+        "api_key",
+        "api_secret",
+        "customer_id",
+        "default_domain",
+    )
+
+    provider = models.CharField(
+        max_length=20,
+        choices=Provider.choices,
+        default=Provider.GODADDY,
+    )
+    api_key = SigilShortAutoField(
+        max_length=255,
+        help_text="API key issued by the DNS provider.",
+    )
+    api_secret = SigilShortAutoField(
+        max_length=255,
+        help_text="API secret issued by the DNS provider.",
+    )
+    customer_id = SigilShortAutoField(
+        max_length=100,
+        blank=True,
+        help_text="Optional GoDaddy customer identifier for the account.",
+    )
+    default_domain = SigilShortAutoField(
+        max_length=253,
+        blank=True,
+        help_text="Fallback domain when records omit one.",
+    )
+    use_sandbox = models.BooleanField(
+        default=False,
+        help_text="Use the GoDaddy OTE (test) environment.",
+    )
+    is_enabled = models.BooleanField(
+        default=True,
+        help_text="Disable to prevent deployments with this manager.",
+    )
+
+    class Meta:
+        verbose_name = "Node Manager"
+        verbose_name_plural = "Node Managers"
+
+    def __str__(self) -> str:
+        owner = self.owner_display()
+        provider = self.get_provider_display()
+        if owner:
+            return f"{provider} ({owner})"
+        return provider
+
+    def clean(self):
+        if self.user_id or self.group_id:
+            super().clean()
+        else:
+            super(Profile, self).clean()
+
+    def get_base_url(self) -> str:
+        if self.provider != self.Provider.GODADDY:
+            raise ValueError("Unsupported DNS provider")
+        if self.use_sandbox:
+            return "https://api.ote-godaddy.com"
+        return "https://api.godaddy.com"
+
+    def get_auth_header(self) -> str:
+        key = (self.resolve_sigils("api_key") or "").strip()
+        secret = (self.resolve_sigils("api_secret") or "").strip()
+        if not key or not secret:
+            raise ValueError("API credentials are required for DNS deployment")
+        return f"sso-key {key}:{secret}"
+
+    def get_customer_id(self) -> str:
+        return (self.resolve_sigils("customer_id") or "").strip()
+
+    def get_default_domain(self) -> str:
+        return (self.resolve_sigils("default_domain") or "").strip()
+
+    def publish_dns_records(self, records: Iterable["DNSRecord"]):
+        from . import dns as dns_utils
+
+        return dns_utils.deploy_records(self, records)
+
+
+class DNSRecord(Entity):
+    """Stored DNS configuration ready for deployment."""
+
+    class Type(models.TextChoices):
+        A = "A", "A"
+        AAAA = "AAAA", "AAAA"
+        CNAME = "CNAME", "CNAME"
+        MX = "MX", "MX"
+        NS = "NS", "NS"
+        SRV = "SRV", "SRV"
+        TXT = "TXT", "TXT"
+
+    class Provider(models.TextChoices):
+        GODADDY = "godaddy", "GoDaddy"
+
+    provider = models.CharField(
+        max_length=20,
+        choices=Provider.choices,
+        default=Provider.GODADDY,
+    )
+    node_manager = models.ForeignKey(
+        "NodeManager",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="dns_records",
+    )
+    domain = SigilShortAutoField(
+        max_length=253,
+        help_text="Base domain such as example.com.",
+    )
+    name = SigilShortAutoField(
+        max_length=253,
+        help_text="Record host. Use @ for the zone apex.",
+    )
+    record_type = models.CharField(
+        max_length=10,
+        choices=Type.choices,
+        default=Type.A,
+        verbose_name="Type",
+    )
+    data = SigilLongAutoField(
+        help_text="Record value such as an IP address or hostname.",
+    )
+    ttl = models.PositiveIntegerField(
+        default=600,
+        help_text="Time to live in seconds.",
+    )
+    priority = models.PositiveIntegerField(
+        null=True,
+        blank=True,
+        help_text="Priority for MX and SRV records.",
+    )
+    port = models.PositiveIntegerField(
+        null=True,
+        blank=True,
+        help_text="Port for SRV records.",
+    )
+    weight = models.PositiveIntegerField(
+        null=True,
+        blank=True,
+        help_text="Weight for SRV records.",
+    )
+    service = SigilShortAutoField(
+        max_length=50,
+        blank=True,
+        help_text="Service label for SRV records (for example _sip).",
+    )
+    protocol = SigilShortAutoField(
+        max_length=10,
+        blank=True,
+        help_text="Protocol label for SRV records (for example _tcp).",
+    )
+    last_synced_at = models.DateTimeField(null=True, blank=True)
+    last_verified_at = models.DateTimeField(null=True, blank=True)
+    last_error = models.TextField(blank=True)
+
+    class Meta:
+        verbose_name = "DNS Record"
+        verbose_name_plural = "DNS Records"
+
+    def __str__(self) -> str:
+        return f"{self.record_type} {self.fqdn()}"
+
+    def get_domain(self, manager: "NodeManager" | None = None) -> str:
+        domain = (self.resolve_sigils("domain") or "").strip()
+        if domain:
+            return domain.rstrip(".")
+        if manager:
+            fallback = manager.get_default_domain()
+            if fallback:
+                return fallback.rstrip(".")
+        return ""
+
+    def get_name(self) -> str:
+        name = (self.resolve_sigils("name") or "").strip()
+        return name or "@"
+
+    def fqdn(self, manager: "NodeManager" | None = None) -> str:
+        domain = self.get_domain(manager)
+        name = self.get_name()
+        if name in {"@", ""}:
+            return domain
+        if name.endswith("."):
+            return name.rstrip(".")
+        if domain:
+            return f"{name}.{domain}".rstrip(".")
+        return name.rstrip(".")
+
+    def to_godaddy_payload(self) -> dict[str, object]:
+        payload: dict[str, object] = {
+            "data": (self.resolve_sigils("data") or "").strip(),
+            "ttl": self.ttl,
+        }
+        if self.priority is not None:
+            payload["priority"] = self.priority
+        if self.port is not None:
+            payload["port"] = self.port
+        if self.weight is not None:
+            payload["weight"] = self.weight
+        service = (self.resolve_sigils("service") or "").strip()
+        if service:
+            payload["service"] = service
+        protocol = (self.resolve_sigils("protocol") or "").strip()
+        if protocol:
+            payload["protocol"] = protocol
+        return payload
+
+    def mark_deployed(self, manager: "NodeManager" | None = None, timestamp=None) -> None:
+        if timestamp is None:
+            timestamp = timezone.now()
+        update_fields = ["last_synced_at", "last_error"]
+        self.last_synced_at = timestamp
+        self.last_error = ""
+        if manager and self.node_manager_id != getattr(manager, "pk", None):
+            self.node_manager = manager
+            update_fields.append("node_manager")
+        self.save(update_fields=update_fields)
+
+    def mark_error(self, message: str, manager: "NodeManager" | None = None) -> None:
+        update_fields = ["last_error"]
+        self.last_error = message
+        if manager and self.node_manager_id != getattr(manager, "pk", None):
+            self.node_manager = manager
+            update_fields.append("node_manager")
+        self.save(update_fields=update_fields)
+
+
 class EmailOutbox(Profile):
     """SMTP credentials for sending mail."""
 
@@ -765,6 +1094,10 @@ class EmailOutbox(Profile):
         max_length=254,
         help_text="Default From address; usually the same as username",
     )
+    is_enabled = models.BooleanField(
+        default=True,
+        help_text="Disable to remove this outbox from automatic selection.",
+    )
 
     class Meta:
         verbose_name = "Email Outbox"
@@ -777,9 +1110,15 @@ class EmailOutbox(Profile):
 
         username = (self.username or "").strip()
         host = (self.host or "").strip()
-        if username and host:
-            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
@@ -849,7 +1188,6 @@ class NetMessage(Entity):
         on_delete=models.SET_NULL,
         null=True,
         blank=True,
-        default=get_terminal_role,
     )
     propagated_to = models.ManyToManyField(
         Node, blank=True, related_name="received_net_messages"
@@ -880,7 +1218,7 @@ class NetMessage(Entity):
         msg = cls.objects.create(
             subject=subject[:64],
             body=body[:256],
-            reach=role or get_terminal_role(),
+            reach=role,
             node_origin=origin,
         )
         msg.propagate(seen=seen or [])
@@ -951,7 +1289,7 @@ class NetMessage(Entity):
 
         target_limit = min(3, len(remaining))
 
-        reach_name = self.reach.name if self.reach else "Terminal"
+        reach_name = self.reach.name if self.reach else None
         role_map = {
             "Terminal": ["Terminal"],
             "Control": ["Control", "Terminal"],
@@ -963,10 +1301,15 @@ class NetMessage(Entity):
                 "Terminal",
             ],
         }
-        role_order = role_map.get(reach_name, ["Terminal"])
+        role_order = role_map.get(reach_name, [None])
         selected: list[Node] = []
         for role_name in role_order:
-            role_nodes = [n for n in remaining if n.role and n.role.name == role_name]
+            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)