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

nodes/admin.py

@@ -26,7 +26,10 @@ from .models import (
     NodeFeatureAssignment,
     ContentSample,
     NetMessage,
+    NodeManager,
+    DNSRecord,
 )
+from . import dns as dns_utils
 from core.user_data import EntityModelAdmin
 
 
@@ -43,6 +46,129 @@ class NodeFeatureAssignmentInline(admin.TabularInline):
     autocomplete_fields = ("feature",)
 
 
+class DeployDNSRecordsForm(forms.Form):
+    manager = forms.ModelChoiceField(
+        label="Node Manager",
+        queryset=NodeManager.objects.none(),
+        help_text="Credentials used to authenticate with the DNS provider.",
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["manager"].queryset = NodeManager.objects.filter(
+            provider=NodeManager.Provider.GODADDY, is_enabled=True
+        )
+
+
+@admin.register(NodeManager)
+class NodeManagerAdmin(EntityModelAdmin):
+    list_display = ("__str__", "provider", "is_enabled", "default_domain")
+    list_filter = ("provider", "is_enabled")
+    search_fields = (
+        "default_domain",
+        "user__username",
+        "group__name",
+    )
+
+
+@admin.register(DNSRecord)
+class DNSRecordAdmin(EntityModelAdmin):
+    list_display = (
+        "record_type",
+        "fqdn",
+        "data",
+        "ttl",
+        "node_manager",
+        "last_synced_at",
+        "last_verified_at",
+    )
+    list_filter = ("record_type", "provider", "node_manager")
+    search_fields = ("domain", "name", "data")
+    autocomplete_fields = ("node_manager",)
+    actions = ["deploy_selected_records", "validate_selected_records"]
+
+    def _default_manager_for_queryset(self, queryset):
+        manager_ids = list(
+            queryset.exclude(node_manager__isnull=True)
+            .values_list("node_manager_id", flat=True)
+            .distinct()
+        )
+        if len(manager_ids) == 1:
+            return manager_ids[0]
+        available = list(
+            NodeManager.objects.filter(
+                provider=NodeManager.Provider.GODADDY, is_enabled=True
+            ).values_list("pk", flat=True)
+        )
+        if len(available) == 1:
+            return available[0]
+        return None
+
+    @admin.action(description="Deploy Selected records")
+    def deploy_selected_records(self, request, queryset):
+        unsupported = queryset.exclude(provider=DNSRecord.Provider.GODADDY)
+        for record in unsupported:
+            self.message_user(
+                request,
+                f"{record} uses unsupported provider {record.get_provider_display()}",
+                messages.WARNING,
+            )
+        queryset = queryset.filter(provider=DNSRecord.Provider.GODADDY)
+        if not queryset:
+            self.message_user(request, "No GoDaddy records selected.", messages.WARNING)
+            return None
+
+        if "apply" in request.POST:
+            form = DeployDNSRecordsForm(request.POST)
+            if form.is_valid():
+                manager = form.cleaned_data["manager"]
+                result = manager.publish_dns_records(list(queryset))
+                for record, reason in result.skipped.items():
+                    self.message_user(request, f"{record}: {reason}", messages.WARNING)
+                for record, reason in result.failures.items():
+                    self.message_user(request, f"{record}: {reason}", messages.ERROR)
+                if result.deployed:
+                    self.message_user(
+                        request,
+                        f"Deployed {len(result.deployed)} DNS record(s) via {manager}.",
+                        messages.SUCCESS,
+                    )
+                return None
+        else:
+            initial_manager = self._default_manager_for_queryset(queryset)
+            form = DeployDNSRecordsForm(initial={"manager": initial_manager})
+
+        context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "form": form,
+            "queryset": queryset,
+            "title": "Deploy DNS records",
+        }
+        return render(
+            request,
+            "admin/nodes/dnsrecord/deploy_records.html",
+            context,
+        )
+
+    @admin.action(description="Validate Selected records")
+    def validate_selected_records(self, request, queryset):
+        resolver = dns_utils.create_resolver()
+        successes = 0
+        for record in queryset:
+            ok, message = dns_utils.validate_record(record, resolver=resolver)
+            if ok:
+                successes += 1
+            else:
+                self.message_user(request, f"{record}: {message}", messages.WARNING)
+        if successes:
+            self.message_user(
+                request,
+                f"Validated {successes} DNS record(s).",
+                messages.SUCCESS,
+            )
+
+
 @admin.register(Node)
 class NodeAdmin(EntityModelAdmin):
     list_display = (
@@ -232,12 +358,20 @@ class NodeAdmin(EntityModelAdmin):
 
 @admin.register(EmailOutbox)
 class EmailOutboxAdmin(EntityModelAdmin):
-    list_display = ("owner_label", "host", "port", "username", "use_tls", "use_ssl")
+    list_display = (
+        "owner_label",
+        "host",
+        "port",
+        "username",
+        "use_tls",
+        "use_ssl",
+        "is_enabled",
+    )
     change_form_template = "admin/nodes/emailoutbox/change_form.html"
     fieldsets = (
         ("Owner", {"fields": ("user", "group", "node")}),
         (
-            None,
+            "Configuration",
             {
                 "fields": (
                     "host",
@@ -247,6 +381,7 @@ class EmailOutboxAdmin(EntityModelAdmin):
                     "use_tls",
                     "use_ssl",
                     "from_email",
+                    "is_enabled",
                 )
             },
         ),

nodes/backends.py

@@ -38,11 +38,12 @@ class OutboxEmailBackend(BaseEmailBackend):
         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(
-                EmailOutbox.objects.filter(
+                enabled_outboxes.filter(
                     Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
                 )
             )
@@ -50,22 +51,25 @@ class OutboxEmailBackend(BaseEmailBackend):
                 match_sets.append(("from_email", email_matches))
 
         if node_id:
-            node_matches = list(EmailOutbox.objects.filter(node_id=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(EmailOutbox.objects.filter(user_id=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(EmailOutbox.objects.filter(group_id=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:
-            return EmailOutbox.objects.first(), []
+            fallback = self._fallback_outbox(enabled_outboxes)
+            if fallback:
+                return fallback, []
+            return None, []
 
         candidates: dict[int, EmailOutbox] = {}
         scores: defaultdict[int, int] = defaultdict(int)
@@ -76,7 +80,10 @@ class OutboxEmailBackend(BaseEmailBackend):
                 scores[outbox.pk] += 1
 
         if not candidates:
-            return EmailOutbox.objects.first(), []
+            fallback = self._fallback_outbox(enabled_outboxes)
+            if fallback:
+                return fallback, []
+            return None, []
 
         selected: EmailOutbox | None = None
         fallbacks: list[EmailOutbox] = []
@@ -93,6 +100,14 @@ class OutboxEmailBackend(BaseEmailBackend):
 
         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:

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
+