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

nodes/apps.py

@@ -1,70 +1,98 @@
-import logging
-import os
-import socket
-import threading
-import time
-from pathlib import Path
-
-from django.apps import AppConfig
-from django.conf import settings
-from django.db import connections
-from django.db.utils import OperationalError
-from utils import revision
-
-
-logger = logging.getLogger(__name__)
-
-
-def _startup_notification() -> None:
-    """Queue a Net Message with ``hostname:port`` and version info."""
-
-    host = socket.gethostname()
-
-    port = os.environ.get("PORT", "8000")
-
-    version = ""
-    ver_path = Path(settings.BASE_DIR) / "VERSION"
-    if ver_path.exists():
-        version = ver_path.read_text().strip()
-
-    revision_value = revision.get_revision()
-    rev_short = revision_value[-6:] if revision_value else ""
-
-    body = version
-    if rev_short:
-        body = f"{body} r{rev_short}" if body else f"r{rev_short}"
-
-    def _worker() -> None:  # pragma: no cover - background thread
-        # Allow the LCD a moment to become ready and retry a few times
-        for _ in range(5):
-            try:
-                from nodes.models import NetMessage
-
-                NetMessage.broadcast(subject=f"{host}:{port}", body=body)
-                break
-            except Exception:
-                time.sleep(1)
-
-    threading.Thread(target=_worker, name="startup-notify", daemon=True).start()
-
-
-def _trigger_startup_notification(**_: object) -> None:
-    """Attempt to send the startup notification in the background."""
-
-    try:
-        connections["default"].ensure_connection()
-    except OperationalError:
-        logger.exception("Startup notification skipped: database unavailable")
-        return
-    _startup_notification()
-
-
-class NodesConfig(AppConfig):
-    default_auto_field = "django.db.models.BigAutoField"
-    name = "nodes"
-    verbose_name = "4. Infrastructure"
-
-    def ready(self):  # pragma: no cover - exercised on app start
-        from django.db.models.signals import post_migrate
-
-        post_migrate.connect(_trigger_startup_notification, sender=self)
+import logging
+import os
+import socket
+import sys
+import threading
+import time
+from pathlib import Path
+
+from django.apps import AppConfig
+from django.conf import settings
+from django.db import connections
+from django.db.utils import OperationalError
+from utils import revision
+
+
+logger = logging.getLogger(__name__)
+
+
+def _startup_notification() -> None:
+    """Queue a Net Message with ``hostname:port`` and version info."""
+
+    host = socket.gethostname()
+
+    port = os.environ.get("PORT", "8000")
+
+    version = ""
+    ver_path = Path(settings.BASE_DIR) / "VERSION"
+    if ver_path.exists():
+        version = ver_path.read_text().strip()
+
+    revision_value = revision.get_revision()
+    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}"
+
+    def _worker() -> None:  # pragma: no cover - background thread
+        # Allow the LCD a moment to become ready and retry a few times
+        for _ in range(5):
+            try:
+                from nodes.models import NetMessage
+
+                NetMessage.broadcast(subject=f"{host}:{port}", body=body)
+                break
+            except Exception:
+                time.sleep(1)
+
+    threading.Thread(target=_worker, name="startup-notify", daemon=True).start()
+
+
+def _trigger_startup_notification(**_: object) -> None:
+    """Attempt to send the startup notification in the background."""
+
+    if _is_running_migration_command():
+        logger.debug("Startup notification skipped: running migration command")
+        return
+
+    try:
+        connections["default"].ensure_connection()
+    except OperationalError:
+        logger.exception("Startup notification skipped: database unavailable")
+        return
+    _startup_notification()
+
+
+def _is_running_migration_command() -> bool:
+    """Return ``True`` when Django's ``migrate`` command is executing."""
+
+    return len(sys.argv) > 1 and sys.argv[1] == "migrate"
+
+
+class NodesConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "nodes"
+    verbose_name = "4. Infrastructure"
+
+    def ready(self):  # pragma: no cover - exercised on app start
+        from django.db.models.signals import post_migrate
+
+        post_migrate.connect(_trigger_startup_notification, sender=self)
+        # Import signal handlers for content classifiers
+        from . import signals  # noqa: F401

nodes/backends.py

@@ -1,53 +1,160 @@
-from __future__ import annotations
-
-from django.core.mail.backends.base import BaseEmailBackend
-from django.core.mail import get_connection
-from django.conf import settings
-from django.db.models import Q
-
-from .models import EmailOutbox
-
-
-class OutboxEmailBackend(BaseEmailBackend):
-    """Email backend that selects an :class:`EmailOutbox` automatically.
-
-    If a matching outbox exists for the message's ``from_email`` (matching
-    either ``from_email`` or ``username``), that outbox's SMTP credentials are
-    used. Otherwise, the first available outbox is used. When no outboxes are
-    configured, the system falls back to Django's default SMTP settings.
-    """
-
-    def _select_outbox(self, from_email: str | None) -> EmailOutbox | None:
-        if from_email:
-            return (
-                EmailOutbox.objects.filter(
-                    Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
-                ).first()
-                or EmailOutbox.objects.first()
-            )
-        return EmailOutbox.objects.first()
-
-    def send_messages(self, email_messages):
-        sent = 0
-        for message in email_messages:
-            outbox = self._select_outbox(message.from_email)
-            if outbox:
-                connection = outbox.get_connection()
-                if not message.from_email:
-                    message.from_email = (
-                        outbox.from_email or settings.DEFAULT_FROM_EMAIL
-                    )
-            else:
-                connection = get_connection(
-                    "django.core.mail.backends.smtp.EmailBackend"
-                )
-                if not message.from_email:
-                    message.from_email = settings.DEFAULT_FROM_EMAIL
-            try:
-                sent += connection.send_messages([message]) or 0
-            finally:
-                try:
-                    connection.close()
-                except Exception:  # pragma: no cover - close errors shouldn't fail send
-                    pass
-        return sent
+from __future__ import annotations
+
+import random
+from collections import defaultdict
+
+from django.core.mail.backends.base import BaseEmailBackend
+from django.core.mail import get_connection
+from django.conf import settings
+from django.db.models import Q
+
+from .models import EmailOutbox
+
+
+class OutboxEmailBackend(BaseEmailBackend):
+    """Email backend that selects an :class:`EmailOutbox` automatically.
+
+    If a matching outbox exists for the message's ``from_email`` (matching
+    either ``from_email`` or ``username``), that outbox's SMTP credentials are
+    used. ``EmailOutbox`` associations to ``node``, ``user`` and ``group`` are
+    also considered and preferred when multiple criteria match. When no
+    outboxes are configured, the system falls back to Django's default SMTP
+    settings.
+    """
+
+    def _resolve_identifier(self, message, attr: str):
+        value = getattr(message, attr, None)
+        if value is None:
+            value = getattr(message, f"{attr}_id", None)
+        if value is None:
+            return None
+        return getattr(value, "pk", value)
+
+    def _select_outbox(
+        self, message
+    ) -> tuple[EmailOutbox | None, list[EmailOutbox]]:
+        from_email = getattr(message, "from_email", None)
+        node_id = self._resolve_identifier(message, "node")
+        user_id = self._resolve_identifier(message, "user")
+        group_id = self._resolve_identifier(message, "group")
+
+        enabled_outboxes = EmailOutbox.objects.filter(is_enabled=True)
+        match_sets: list[tuple[str, list[EmailOutbox]]] = []
+
+        if from_email:
+            email_matches = list(
+                enabled_outboxes.filter(
+                    Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
+                )
+            )
+            if email_matches:
+                match_sets.append(("from_email", email_matches))
+
+        if node_id:
+            node_matches = list(enabled_outboxes.filter(node_id=node_id))
+            if node_matches:
+                match_sets.append(("node", node_matches))
+
+        if user_id:
+            user_matches = list(enabled_outboxes.filter(user_id=user_id))
+            if user_matches:
+                match_sets.append(("user", user_matches))
+
+        if group_id:
+            group_matches = list(enabled_outboxes.filter(group_id=group_id))
+            if group_matches:
+                match_sets.append(("group", group_matches))
+
+        if not match_sets:
+            fallback = self._fallback_outbox(enabled_outboxes)
+            if fallback:
+                return fallback, []
+            return None, []
+
+        candidates: dict[int, EmailOutbox] = {}
+        scores: defaultdict[int, int] = defaultdict(int)
+
+        for _, matches in match_sets:
+            for outbox in matches:
+                candidates[outbox.pk] = outbox
+                scores[outbox.pk] += 1
+
+        if not candidates:
+            fallback = self._fallback_outbox(enabled_outboxes)
+            if fallback:
+                return fallback, []
+            return None, []
+
+        selected: EmailOutbox | None = None
+        fallbacks: list[EmailOutbox] = []
+
+        for score in sorted(set(scores.values()), reverse=True):
+            group = [candidates[pk] for pk, value in scores.items() if value == score]
+            if len(group) > 1:
+                random.shuffle(group)
+            if selected is None:
+                selected = group[0]
+                fallbacks.extend(group[1:])
+            else:
+                fallbacks.extend(group)
+
+        return selected, fallbacks
+
+    def _fallback_outbox(self, queryset):
+        ownerless = queryset.filter(
+            node__isnull=True, user__isnull=True, group__isnull=True
+        ).order_by("pk").first()
+        if ownerless:
+            return ownerless
+        return queryset.order_by("pk").first()
+
+    def send_messages(self, email_messages):
+        sent = 0
+        for message in email_messages:
+            original_from_email = message.from_email
+            outbox, fallbacks = self._select_outbox(message)
+            tried_outboxes = []
+            if outbox:
+                tried_outboxes.append(outbox)
+            tried_outboxes.extend(fallbacks)
+
+            last_error: Exception | None = None
+
+            if tried_outboxes:
+                for candidate in tried_outboxes:
+                    connection = candidate.get_connection()
+                    message.from_email = (
+                        original_from_email
+                        or candidate.from_email
+                        or settings.DEFAULT_FROM_EMAIL
+                    )
+                    try:
+                        sent += connection.send_messages([message]) or 0
+                        last_error = None
+                        break
+                    except Exception as exc:  # pragma: no cover - retry on error
+                        last_error = exc
+                    finally:
+                        try:
+                            connection.close()
+                        except Exception:  # pragma: no cover - close errors shouldn't fail send
+                            pass
+                if last_error is not None:
+                    message.from_email = original_from_email
+                    raise last_error
+            else:
+                connection = get_connection(
+                    "django.core.mail.backends.smtp.EmailBackend"
+                )
+                if not message.from_email:
+                    message.from_email = settings.DEFAULT_FROM_EMAIL
+                try:
+                    sent += connection.send_messages([message]) or 0
+                finally:
+                    try:
+                        connection.close()
+                    except Exception:  # pragma: no cover - close errors shouldn't fail send
+                        pass
+
+            message.from_email = original_from_email
+        return sent

nodes/dns.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Iterable, Mapping, MutableMapping, TYPE_CHECKING
+
+import requests
+from django.utils import timezone
+from dns import exception as dns_exception
+from dns import resolver as dns_resolver
+from requests import Response
+
+if TYPE_CHECKING:  # pragma: no cover - imported for type checking only
+    from .models import DNSRecord, NodeManager
+
+
+@dataclass
+class DeploymentResult:
+    deployed: list["DNSRecord"]
+    failures: MutableMapping["DNSRecord", str]
+    skipped: MutableMapping["DNSRecord", str]
+
+
+def _error_from_response(response: Response) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        payload = None
+
+    if isinstance(payload, dict):
+        for key in ("message", "detail", "error"):
+            message = payload.get(key)
+            if message:
+                return str(message)
+    elif isinstance(payload, list) and payload:
+        first = payload[0]
+        if isinstance(first, Mapping) and "message" in first:
+            return str(first["message"])
+        return str(first)
+
+    reason = response.reason or ""
+    return f"{response.status_code} {reason}".strip()
+
+
+def deploy_records(manager: "NodeManager", records: Iterable["DNSRecord"]) -> DeploymentResult:
+    filtered: list["DNSRecord"] = []
+    skipped: MutableMapping["DNSRecord", str] = {}
+    for record in records:
+        if record.provider != record.Provider.GODADDY:
+            skipped[record] = "Unsupported DNS provider"
+            continue
+        domain = record.get_domain(manager)
+        if not domain:
+            skipped[record] = "Domain is required for deployment"
+            continue
+        filtered.append(record)
+
+    if not filtered:
+        return DeploymentResult([], {}, skipped)
+
+    session = requests.Session()
+    session.headers.update(
+        {
+            "Authorization": manager.get_auth_header(),
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+    )
+    customer_id = manager.get_customer_id()
+    if customer_id:
+        session.headers["X-Shopper-Id"] = customer_id
+
+    grouped: MutableMapping[tuple[str, str, str], list["DNSRecord"]] = defaultdict(list)
+    for record in filtered:
+        key = (
+            record.get_domain(manager),
+            record.record_type,
+            record.get_name(),
+        )
+        grouped[key].append(record)
+
+    deployed: list["DNSRecord"] = []
+    failures: MutableMapping["DNSRecord", str] = {}
+    now = timezone.now()
+
+    base_url = manager.get_base_url()
+    for (domain, record_type, name), grouped_records in grouped.items():
+        payload = [record.to_godaddy_payload() for record in grouped_records]
+        url = f"{base_url}/v1/domains/{domain}/records/{record_type}/{name or '@'}"
+        try:
+            response = session.put(url, json=payload, timeout=30)
+        except requests.RequestException as exc:
+            message = str(exc)
+            for record in grouped_records:
+                record.mark_error(message, manager=manager)
+                failures[record] = message
+            continue
+
+        if response.status_code >= 400:
+            message = _error_from_response(response)
+            for record in grouped_records:
+                record.mark_error(message, manager=manager)
+                failures[record] = message
+            continue
+
+        for record in grouped_records:
+            record.mark_deployed(manager=manager, timestamp=now)
+            deployed.append(record)
+
+    return DeploymentResult(deployed, failures, skipped)
+
+
+def create_resolver() -> dns_resolver.Resolver:
+    return dns_resolver.Resolver()
+
+
+def _normalize_hostname(value: str) -> str:
+    return value.rstrip(".").lower()
+
+
+def _extract_txt(rdata) -> str:
+    strings = getattr(rdata, "strings", None)
+    if strings:
+        parts = []
+        for segment in strings:
+            if isinstance(segment, bytes):
+                parts.append(segment.decode("utf-8", "ignore"))
+            else:
+                parts.append(str(segment))
+        return "".join(parts)
+    return str(rdata).strip('"')
+
+
+def _matches_record(record: "DNSRecord", rdata) -> bool:
+    expected = (record.resolve_sigils("data") or "").strip()
+    rtype = record.record_type
+
+    if rtype == record.Type.A:
+        return getattr(rdata, "address", str(rdata)) == expected
+    if rtype == record.Type.AAAA:
+        return getattr(rdata, "address", str(rdata)) == expected
+    if rtype == record.Type.CNAME:
+        actual = getattr(rdata, "target", None)
+        if actual is None:
+            return False
+        return _normalize_hostname(actual.to_text()) == _normalize_hostname(expected)
+    if rtype == record.Type.NS:
+        actual = getattr(rdata, "target", None)
+        if actual is None:
+            return False
+        return _normalize_hostname(actual.to_text()) == _normalize_hostname(expected)
+    if rtype == record.Type.MX:
+        host = getattr(rdata, "exchange", None)
+        if host is None:
+            return False
+        host_match = _normalize_hostname(host.to_text()) == _normalize_hostname(expected)
+        priority = getattr(rdata, "preference", None)
+        priority_match = record.priority is None or priority == record.priority
+        return host_match and priority_match
+    if rtype == record.Type.SRV:
+        target = getattr(rdata, "target", None)
+        if target is None:
+            return False
+        target_match = _normalize_hostname(target.to_text()) == _normalize_hostname(expected)
+        priority_match = record.priority is None or getattr(rdata, "priority", None) == record.priority
+        weight_match = record.weight is None or getattr(rdata, "weight", None) == record.weight
+        port_match = record.port is None or getattr(rdata, "port", None) == record.port
+        return target_match and priority_match and weight_match and port_match
+    if rtype == record.Type.TXT:
+        actual = _extract_txt(rdata)
+        return actual == expected
+
+    return str(rdata).strip() == expected
+
+
+def validate_record(
+    record: "DNSRecord", resolver: dns_resolver.Resolver | None = None
+) -> tuple[bool, str]:
+    resolver = resolver or create_resolver()
+    fqdn = record.fqdn()
+    if not fqdn:
+        message = "Domain is required for validation"
+        record.mark_error(message)
+        return False, message
+
+    try:
+        answers = resolver.resolve(fqdn, record.record_type)
+    except (dns_exception.DNSException, OSError) as exc:
+        message = str(exc)
+        record.mark_error(message)
+        return False, message
+
+    for rdata in answers:
+        if _matches_record(record, rdata):
+            record.last_verified_at = timezone.now()
+            record.last_error = ""
+            record.save(update_fields=["last_verified_at", "last_error"])
+            return True, ""
+
+    message = "DNS record does not match expected value"
+    record.mark_error(message)
+    return False, message
+