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

nodes/admin.py

@@ -4,41 +4,30 @@ from django.shortcuts import redirect, render
 from django.utils.html import format_html
 from django import forms
 from django.contrib.admin.widgets import FilteredSelectMultiple
-from app.widgets import CopyColorWidget, CodeEditorWidget
-from django.db import models
+from core.widgets import CopyColorWidget
+from django.db.models import Count
 from django.conf import settings
 from pathlib import Path
 from django.http import HttpResponse
-from django.template.response import TemplateResponse
-from django.core.management import call_command
+from django.utils.translation import gettext_lazy as _
 import base64
 import pyperclip
 from pyperclip import PyperclipException
 import uuid
 import subprocess
-import io
-import threading
-import re
 from .utils import capture_screenshot, save_screenshot
 from .actions import NodeAction
 
 from .models import (
     Node,
-    EmailOutbox as NodeEmailOutbox,
+    EmailOutbox,
     NodeRole,
+    NodeFeature,
+    NodeFeatureAssignment,
     ContentSample,
-    NodeTask,
     NetMessage,
-    Operation,
-    Interrupt,
-    Logbook,
-    User,
 )
-from core.admin import UserAdmin as CoreUserAdmin
-
-
-RUN_CONTEXTS: dict[int, dict] = {}
-SIGIL_RE = re.compile(r"\[[A-Za-z0-9_]+\.[A-Za-z0-9_]+\]")
+from core.user_data import EntityModelAdmin
 
 
 class NodeAdminForm(forms.ModelForm):
@@ -48,8 +37,14 @@ class NodeAdminForm(forms.ModelForm):
         widgets = {"badge_color": CopyColorWidget()}
 
 
+class NodeFeatureAssignmentInline(admin.TabularInline):
+    model = NodeFeatureAssignment
+    extra = 0
+    autocomplete_fields = ("feature",)
+
+
 @admin.register(Node)
-class NodeAdmin(admin.ModelAdmin):
+class NodeAdmin(EntityModelAdmin):
     list_display = (
         "hostname",
         "mac_address",
@@ -62,8 +57,8 @@ class NodeAdmin(admin.ModelAdmin):
     change_list_template = "admin/nodes/node/change_list.html"
     change_form_template = "admin/nodes/node/change_form.html"
     form = NodeAdminForm
-    actions = ["run_task", "take_screenshots"]
-
+    actions = ["register_visitor", "run_task", "take_screenshots"]
+    inlines = [NodeFeatureAssignmentInline]
 
     def get_urls(self):
         urls = super().get_urls()
@@ -73,6 +68,11 @@ class NodeAdmin(admin.ModelAdmin):
                 self.admin_site.admin_view(self.register_current),
                 name="nodes_node_register_current",
             ),
+            path(
+                "register-visitor/",
+                self.admin_site.admin_view(self.register_visitor_view),
+                name="nodes_node_register_visitor",
+            ),
             path(
                 "<int:node_id>/action/<str:action>/",
                 self.admin_site.admin_view(self.action_view),
@@ -100,6 +100,32 @@ class NodeAdmin(admin.ModelAdmin):
         }
         return render(request, "admin/nodes/node/register_remote.html", context)
 
+    @admin.action(description="Register Visitor Node")
+    def register_visitor(self, request, queryset=None):
+        return self.register_visitor_view(request)
+
+    def register_visitor_view(self, request):
+        """Exchange registration data with the visiting node."""
+
+        node, created = Node.register_current()
+        if created:
+            self.message_user(
+                request, f"Current host registered as {node}", messages.SUCCESS
+            )
+
+        token = uuid.uuid4().hex
+        context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "title": _("Register Visitor Node"),
+            "token": token,
+            "info_url": reverse("node-info"),
+            "register_url": reverse("register-node"),
+            "visitor_info_url": "http://localhost:8000/nodes/info/",
+            "visitor_register_url": "http://localhost:8000/nodes/register/",
+        }
+        return render(request, "admin/nodes/node/register_visitor.html", context)
+
     def public_key(self, request, node_id):
         node = self.get_object(request, node_id)
         if not node:
@@ -117,11 +143,21 @@ class NodeAdmin(admin.ModelAdmin):
     def run_task(self, request, queryset):
         if "apply" in request.POST:
             recipe_text = request.POST.get("recipe", "")
-            task_obj, _ = NodeTask.objects.get_or_create(recipe=recipe_text)
             results = []
             for node in queryset:
                 try:
-                    output = task_obj.run(node)
+                    if not node.is_local:
+                        raise NotImplementedError(
+                            "Remote node execution is not implemented"
+                        )
+                    command = ["/bin/sh", "-c", recipe_text]
+                    result = subprocess.run(
+                        command,
+                        check=False,
+                        capture_output=True,
+                        text=True,
+                    )
+                    output = result.stdout + result.stderr
                 except Exception as exc:
                     output = str(exc)
                 results.append((node, output))
@@ -194,21 +230,67 @@ class NodeAdmin(admin.ModelAdmin):
         return redirect(reverse("admin:nodes_node_change", args=[node_id]))
 
 
-class EmailOutbox(NodeEmailOutbox):
-    class Meta:
-        proxy = True
-        app_label = "post_office"
-        verbose_name = NodeEmailOutbox._meta.verbose_name
-        verbose_name_plural = NodeEmailOutbox._meta.verbose_name_plural
+@admin.register(EmailOutbox)
+class EmailOutboxAdmin(EntityModelAdmin):
+    list_display = ("owner_label", "host", "port", "username", "use_tls", "use_ssl")
+    change_form_template = "admin/nodes/emailoutbox/change_form.html"
+    fieldsets = (
+        ("Owner", {"fields": ("user", "group", "node")}),
+        (
+            None,
+            {
+                "fields": (
+                    "host",
+                    "port",
+                    "username",
+                    "password",
+                    "use_tls",
+                    "use_ssl",
+                    "from_email",
+                )
+            },
+        ),
+    )
 
+    @admin.display(description="Owner")
+    def owner_label(self, obj):
+        return obj.owner_display()
 
-@admin.register(EmailOutbox)
-class EmailOutboxAdmin(admin.ModelAdmin):
-    list_display = ("node", "host", "port", "username", "use_tls", "use_ssl")
+    def get_urls(self):
+        urls = super().get_urls()
+        custom = [
+            path(
+                "<path:object_id>/test/",
+                self.admin_site.admin_view(self.test_outbox),
+                name="nodes_emailoutbox_test",
+            )
+        ]
+        return custom + urls
 
-    def save_model(self, request, obj, form, change):
-        super().save_model(request, obj, form, change)
-        obj.__class__ = EmailOutbox
+    def test_outbox(self, request, object_id):
+        outbox = self.get_object(request, object_id)
+        if not outbox:
+            self.message_user(request, "Unknown outbox", messages.ERROR)
+            return redirect("..")
+        recipient = request.user.email or outbox.username
+        try:
+            outbox.send_mail(
+                "Test email",
+                "This is a test email.",
+                [recipient],
+            )
+            self.message_user(request, "Test email sent", messages.SUCCESS)
+        except Exception as exc:  # pragma: no cover - admin feedback
+            self.message_user(request, str(exc), messages.ERROR)
+        return redirect("..")
+
+    def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        if object_id:
+            extra_context["test_url"] = reverse(
+                "admin:nodes_emailoutbox_test", args=[object_id]
+            )
+        return super().changeform_view(request, object_id, form_url, extra_context)
 
 
 class NodeRoleAdminForm(forms.ModelForm):
@@ -229,16 +311,48 @@ class NodeRoleAdminForm(forms.ModelForm):
 
 
 @admin.register(NodeRole)
-class NodeRoleAdmin(admin.ModelAdmin):
+class NodeRoleAdmin(EntityModelAdmin):
     form = NodeRoleAdminForm
-    list_display = ("name", "description")
+    list_display = ("name", "description", "registered", "default_features")
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs.annotate(_registered=Count("node", distinct=True)).prefetch_related(
+            "features"
+        )
+
+    @admin.display(description="Registered", ordering="_registered")
+    def registered(self, obj):
+        return getattr(obj, "_registered", obj.node_set.count())
+
+    @admin.display(description="Default Features")
+    def default_features(self, obj):
+        features = [feature.display for feature in obj.features.all()]
+        return ", ".join(features) if features else "—"
 
     def save_model(self, request, obj, form, change):
         obj.node_set.set(form.cleaned_data.get("nodes", []))
 
 
+@admin.register(NodeFeature)
+class NodeFeatureAdmin(EntityModelAdmin):
+    filter_horizontal = ("roles",)
+    list_display = ("display", "slug", "default_roles", "is_enabled")
+    readonly_fields = ("is_enabled",)
+    search_fields = ("display", "slug")
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs.prefetch_related("roles")
+
+    @admin.display(description="Default Roles")
+    def default_roles(self, obj):
+        roles = [role.name for role in obj.roles.all()]
+        return ", ".join(roles) if roles else "—"
+
+
 @admin.register(ContentSample)
-class ContentSampleAdmin(admin.ModelAdmin):
+class ContentSampleAdmin(EntityModelAdmin):
     list_display = ("name", "kind", "node", "user", "created_at")
     readonly_fields = ("created_at", "name", "user", "image_preview")
 
@@ -267,13 +381,17 @@ class ContentSampleAdmin(admin.ModelAdmin):
         if not content:
             self.message_user(request, "Clipboard is empty.", level=messages.INFO)
             return redirect("..")
-        if ContentSample.objects.filter(content=content, kind=ContentSample.TEXT).exists():
+        if ContentSample.objects.filter(
+            content=content, kind=ContentSample.TEXT
+        ).exists():
             self.message_user(
                 request, "Duplicate sample not created.", level=messages.INFO
             )
             return redirect("..")
         user = request.user if request.user.is_authenticated else None
-        ContentSample.objects.create(content=content, user=user, kind=ContentSample.TEXT)
+        ContentSample.objects.create(
+            content=content, user=user, kind=ContentSample.TEXT
+        )
         self.message_user(
             request, "Text sample added from clipboard.", level=messages.SUCCESS
         )
@@ -291,9 +409,7 @@ class ContentSampleAdmin(admin.ModelAdmin):
         if sample:
             self.message_user(request, f"Screenshot saved to {path}", messages.SUCCESS)
         else:
-            self.message_user(
-                request, "Duplicate screenshot; not saved", messages.INFO
-            )
+            self.message_user(request, "Duplicate screenshot; not saved", messages.INFO)
         return redirect("..")
 
     @admin.display(description="Screenshot")
@@ -314,8 +430,15 @@ class ContentSampleAdmin(admin.ModelAdmin):
 
 
 @admin.register(NetMessage)
-class NetMessageAdmin(admin.ModelAdmin):
-    list_display = ("subject", "body", "reach", "created", "complete")
+class NetMessageAdmin(EntityModelAdmin):
+    list_display = (
+        "subject",
+        "body",
+        "reach",
+        "node_origin",
+        "created",
+        "complete",
+    )
     search_fields = ("subject", "body")
     list_filter = ("complete", "reach")
     ordering = ("-created",)
@@ -328,243 +451,3 @@ class NetMessageAdmin(admin.ModelAdmin):
         self.message_user(request, f"{queryset.count()} messages sent")
 
     send_messages.short_description = "Send selected messages"
-
-
-class NodeTaskForm(forms.ModelForm):
-    class Meta:
-        model = NodeTask
-        fields = "__all__"
-        widgets = {"recipe": CodeEditorWidget()}
-
-
-@admin.register(NodeTask)
-class NodeTaskAdmin(admin.ModelAdmin):
-    form = NodeTaskForm
-    list_display = ("recipe", "role", "created")
-    actions = ["execute"]
-
-    def execute(self, request, queryset):
-        if queryset.count() != 1:
-            self.message_user(
-                request, "Please select exactly one task", messages.ERROR
-            )
-            return
-        task_obj = queryset.first()
-        if "apply" in request.POST:
-            node_ids = request.POST.getlist("nodes")
-            nodes_qs = Node.objects.filter(pk__in=node_ids)
-            results = []
-            for node in nodes_qs:
-                try:
-                    output = task_obj.run(node)
-                except Exception as exc:
-                    output = str(exc)
-                results.append((node, output))
-            context = {"recipe": task_obj.recipe, "results": results}
-            return render(request, "admin/nodes/task_result.html", context)
-        nodes = Node.objects.all()
-        context = {"nodes": nodes, "task_obj": task_obj}
-        return render(request, "admin/nodes/nodetask/run.html", context)
-
-    execute.short_description = "Run task on nodes"
-
-
-@admin.register(Operation)
-class OperationAdmin(admin.ModelAdmin):
-    list_display = ("name",)
-    formfield_overrides = {models.TextField: {"widget": CodeEditorWidget}}
-    change_form_template = "admin/nodes/operation/change_form.html"
-
-    def get_urls(self):
-        urls = super().get_urls()
-        custom = [
-            path(
-                "<path:object_id>/run/",
-                self.admin_site.admin_view(self.run_view),
-                name="nodes_operation_run",
-            )
-        ]
-        return custom + urls
-
-    def run_view(self, request, object_id):
-        operation = self.get_object(request, object_id)
-        if not operation:
-            self.message_user(request, "Unknown operation", messages.ERROR)
-            return redirect("..")
-        context = RUN_CONTEXTS.setdefault(operation.pk, {"inputs": {}})
-        template_text = operation.resolve_sigils("template")
-
-        # Interrupt handling
-        interrupt_id = request.GET.get("interrupt")
-        if interrupt_id:
-            try:
-                interrupt = operation.outgoing_interrupts.get(pk=interrupt_id)
-            except Interrupt.DoesNotExist:
-                self.message_user(request, "Unknown interrupt", messages.ERROR)
-                return redirect(request.path)
-            proc = context.get("process")
-            if proc and proc.poll() is None:
-                proc.terminate()
-                out, err = proc.communicate()
-                log = context.get("log")
-                if log:
-                    log.output = out
-                    log.error = err
-                    log.interrupted = True
-                    log.interrupt = interrupt
-                    log.save()
-            RUN_CONTEXTS.pop(operation.pk, None)
-            return redirect(
-                reverse("admin:nodes_operation_run", args=[interrupt.to_operation.pk])
-            )
-
-        # Check running processes
-        proc = context.get("process")
-        thread = context.get("thread")
-        if proc and proc.poll() is not None:
-            out, err = proc.communicate()
-            log = context.pop("log")
-            log.output = out
-            log.error = err
-            log.save()
-            RUN_CONTEXTS.pop(operation.pk, None)
-            self.message_user(request, "Operation executed", messages.SUCCESS)
-            return redirect("..")
-        if thread and not thread.is_alive():
-            out = context.pop("out")
-            err = context.pop("err")
-            log = context.pop("log")
-            log.output = out.getvalue()
-            log.error = err.getvalue()
-            log.save()
-            RUN_CONTEXTS.pop(operation.pk, None)
-            self.message_user(request, "Operation executed", messages.SUCCESS)
-            return redirect("..")
-
-        interrupts = [
-            (i, i.resolve_sigils("preview"))
-            for i in operation.outgoing_interrupts.all().order_by("-priority")
-        ]
-        logs = Logbook.objects.filter(operation=operation).order_by("created")
-
-        # Waiting for user-provided sigils
-        waiting = context.get("waiting_inputs")
-        if waiting:
-            if request.method == "POST":
-                for token in waiting:
-                    name = token[1:-1].replace(".", "__")
-                    context["inputs"][token] = request.POST.get(name, "")
-                command = context.pop("pending_command")
-                for token, value in context["inputs"].items():
-                    command = command.replace(token, value)
-                context["waiting_inputs"] = None
-                self._start_operation(context, operation, command, request.user)
-                return redirect(request.path)
-            form_fields = [(t, t[1:-1].replace(".", "__")) for t in waiting]
-            tpl_context = {
-                **self.admin_site.each_context(request),
-                "operation": operation,
-                "interrupts": interrupts,
-                "logs": logs,
-                "waiting_inputs": form_fields,
-                "template": template_text,
-            }
-            return TemplateResponse(
-                request, "admin/nodes/operation/run.html", tpl_context
-            )
-
-        # Waiting for user continuation
-        if context.get("waiting_continue"):
-            if request.method == "POST":
-                context["waiting_continue"] = False
-                RUN_CONTEXTS.pop(operation.pk, None)
-                self.message_user(request, "Operation executed", messages.SUCCESS)
-                return redirect("..")
-            tpl_context = {
-                **self.admin_site.each_context(request),
-                "operation": operation,
-                "interrupts": interrupts,
-                "logs": logs,
-                "waiting_continue": True,
-                "template": template_text,
-            }
-            return TemplateResponse(
-                request, "admin/nodes/operation/run.html", tpl_context
-            )
-
-        # If a process or thread is running, show running state
-        if context.get("process") or context.get("thread"):
-            tpl_context = {
-                **self.admin_site.each_context(request),
-                "operation": operation,
-                "interrupts": interrupts,
-                "logs": logs,
-                "running": True,
-                "template": template_text,
-            }
-            return TemplateResponse(
-                request, "admin/nodes/operation/run.html", tpl_context
-            )
-
-        if request.method == "POST":
-            command = operation.resolve_sigils("command")
-            for token, value in context["inputs"].items():
-                command = command.replace(token, value)
-            unresolved = SIGIL_RE.findall(command)
-            if unresolved:
-                context["waiting_inputs"] = unresolved
-                context["pending_command"] = command
-                return redirect(request.path)
-            if command.strip() == "...":
-                log = Logbook.objects.create(
-                    operation=operation,
-                    user=request.user,
-                    input_text=command,
-                    output="Waiting for user continuation",
-                )
-                context["log"] = log
-                context["waiting_continue"] = True
-                return redirect(request.path)
-            self._start_operation(context, operation, command, request.user)
-            return redirect(request.path)
-
-        tpl_context = {
-            **self.admin_site.each_context(request),
-            "operation": operation,
-            "interrupts": interrupts,
-            "logs": logs,
-            "template": template_text,
-        }
-        return TemplateResponse(request, "admin/nodes/operation/run.html", tpl_context)
-
-    def _start_operation(self, ctx, operation, command, user):
-        log = Logbook.objects.create(operation=operation, user=user, input_text=command)
-        if operation.is_django:
-            out = io.StringIO()
-            err = io.StringIO()
-
-            def target():
-                try:
-                    call_command(*command.split(), stdout=out, stderr=err)
-                except Exception as exc:  # pragma: no cover - unexpected errors
-                    err.write(str(exc))
-
-            thread = threading.Thread(target=target)
-            thread.start()
-            ctx.update({"thread": thread, "out": out, "err": err, "log": log})
-        else:
-            proc = subprocess.Popen(
-                command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
-            )
-            ctx.update({"process": proc, "log": log})
-
-    def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
-        extra_context = extra_context or {}
-        if object_id:
-            extra_context["run_url"] = reverse(
-                "admin:nodes_operation_run", args=[object_id]
-            )
-        return super().changeform_view(request, object_id, form_url, extra_context)
-
-
-admin.site.register(User, CoreUserAdmin)

nodes/apps.py

@@ -7,7 +7,6 @@ from pathlib import Path
 
 from django.apps import AppConfig
 from django.conf import settings
-from django.core.signals import request_started
 from django.db import connections
 from django.db.utils import OperationalError
 from utils import revision
@@ -17,13 +16,9 @@ logger = logging.getLogger(__name__)
 
 
 def _startup_notification() -> None:
-    """Queue a notification with host:port and version on a background thread."""
+    """Queue a Net Message with ``hostname:port`` and version info."""
 
     host = socket.gethostname()
-    try:
-        address = socket.gethostbyname(host)
-    except socket.gaierror:
-        address = host
 
     port = os.environ.get("PORT", "8000")
 
@@ -35,9 +30,9 @@ def _startup_notification() -> None:
     revision_value = revision.get_revision()
     rev_short = revision_value[-6:] if revision_value else ""
 
-    body = f"v{version}"
+    body = version
     if rev_short:
-        body += f" r{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
@@ -45,7 +40,7 @@ def _startup_notification() -> None:
             try:
                 from nodes.models import NetMessage
 
-                NetMessage.broadcast(subject=f"{address}:{port}", body=body)
+                NetMessage.broadcast(subject=f"{host}:{port}", body=body)
                 break
             except Exception:
                 time.sleep(1)
@@ -54,9 +49,8 @@ def _startup_notification() -> None:
 
 
 def _trigger_startup_notification(**_: object) -> None:
-    """Send the startup notification once a request has started."""
+    """Attempt to send the startup notification in the background."""
 
-    request_started.disconnect(_trigger_startup_notification, dispatch_uid="nodes-startup")
     try:
         connections["default"].ensure_connection()
     except OperationalError:
@@ -68,9 +62,9 @@ def _trigger_startup_notification(**_: object) -> None:
 class NodesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "nodes"
-    verbose_name = "2. Infrastructure"
+    verbose_name = "4. Infrastructure"
 
     def ready(self):  # pragma: no cover - exercised on app start
-        request_started.connect(
-            _trigger_startup_notification, dispatch_uid="nodes-startup"
-        )
+        from django.db.models.signals import post_migrate
+
+        post_migrate.connect(_trigger_startup_notification, sender=self)