proxsync 2.0.0__py3-none-any.whl

pve_sync_plugin/forms.py

@@ -0,0 +1,219 @@
+"""Forms for the PVE Sync plugin UI."""
+
+from django import forms
+
+from netbox.forms import NetBoxModelForm, NetBoxModelFilterSetForm
+from utilities.forms.fields import DynamicModelChoiceField
+
+from dcim.models import Site
+from virtualization.models import Cluster, ClusterType
+
+from .choices import (
+    BackupStatusChoices,
+    DriftTypeChoices,
+    SyncJobStatusChoices,
+    SyncJobTriggerChoices,
+    SyncScheduleChoices,
+    WebhookEventChoices,
+)
+from .models import PbsServerConfig, PveClusterConfig, PveDriftEvent, PvePluginSettings, PveSyncJob, PveWebhookEvent
+
+
+# ---------------------------------------------------------------------------
+# Model Forms (create / edit)
+# ---------------------------------------------------------------------------
+
+class PvePluginSettingsForm(NetBoxModelForm):
+    """Editable singleton settings for plugin-wide defaults."""
+
+    netbox_token = forms.CharField(
+        required=False,
+        widget=forms.PasswordInput(render_value=True),
+    )
+    telegram_bot_token = forms.CharField(
+        required=False,
+        widget=forms.PasswordInput(render_value=True),
+    )
+    webhook_secret = forms.CharField(
+        required=False,
+        widget=forms.PasswordInput(render_value=True),
+    )
+
+    class Meta:
+        model = PvePluginSettings
+        fields = (
+            "netbox_url",
+            "netbox_token",
+            "telegram_bot_token",
+            "telegram_chat_id",
+            "webhook_secret",
+            "default_cluster_name",
+            "default_netbox_cluster",
+            "default_site",
+            "default_cluster_type",
+            "default_node_role",
+            "default_node_type",
+            "state_db_path",
+            "enable_backup_sync",
+        )
+        help_texts = {
+            "netbox_url": "NetBox base URL (e.g. https://netbox.example.com)",
+            "netbox_token": "NetBox API token with write permissions",
+            "telegram_bot_token": "Telegram bot token for notifications (optional)",
+            "telegram_chat_id": (
+                "Telegram chat/group ID for notifications (optional). "
+                "For group chats, the ID must start with a minus sign, e.g. -1002581073501"
+            ),
+            "webhook_secret": "HMAC shared secret for PVE webhook signature verification",
+            "state_db_path": "Path to SQLite state database for incremental sync",
+        }
+
+    def save(self, *args, **kwargs):
+        instance = super().save(*args, **kwargs)
+        # Invalidate cached settings so new values take effect immediately
+        from .utils import clear_plugin_config_cache
+
+        clear_plugin_config_cache()
+        return instance
+
+
+class PveClusterConfigForm(NetBoxModelForm):
+    """Cluster configuration form using NetBox dynamic selectors."""
+
+    pve_secret = forms.CharField(widget=forms.PasswordInput(render_value=True))
+
+    netbox_site = DynamicModelChoiceField(
+        queryset=Site.objects.all(),
+        required=False,
+    )
+    netbox_cluster_type = DynamicModelChoiceField(
+        queryset=ClusterType.objects.all(),
+        required=False,
+    )
+    netbox_cluster = DynamicModelChoiceField(
+        queryset=Cluster.objects.all(),
+        required=False,
+    )
+
+    class Meta:
+        model = PveClusterConfig
+        fields = (
+            "name",
+            "description",
+            "pve_host",
+            "pve_user",
+            "pve_token",
+            "pve_secret",
+            "pve_verify_ssl",
+            "netbox_site",
+            "netbox_cluster_type",
+            "netbox_cluster",
+            "enabled",
+            "sync_schedule",
+            "notify_on_sync",
+        )
+        help_texts = {
+            "sync_schedule": (
+                "For reference only. Use a crontab or systemd timer calling "
+                "<code>manage.py pve_sync --cluster &lt;name&gt;</code> "
+                "at the desired interval."
+            ),
+        }
+
+
+# ---------------------------------------------------------------------------
+# Filter Forms (list view sidebar filters)
+# ---------------------------------------------------------------------------
+
+class PveSyncJobFilterForm(NetBoxModelFilterSetForm):
+    """Filter form displayed in the PveSyncJob list view sidebar."""
+
+    model = PveSyncJob
+
+    status = forms.MultipleChoiceField(
+        choices=SyncJobStatusChoices.choices,
+        required=False,
+    )
+    trigger = forms.MultipleChoiceField(
+        choices=SyncJobTriggerChoices.choices,
+        required=False,
+    )
+    cluster_name = forms.CharField(required=False)
+
+
+class PveWebhookEventFilterForm(NetBoxModelFilterSetForm):
+    """Filter form for webhook event list views."""
+
+    model = PveWebhookEvent
+
+    event_type = forms.MultipleChoiceField(
+        choices=WebhookEventChoices.choices,
+        required=False,
+    )
+    processed = forms.NullBooleanField(required=False)
+
+
+class PveClusterConfigFilterForm(NetBoxModelFilterSetForm):
+    """Filter form for cluster config list views."""
+
+    model = PveClusterConfig
+
+    enabled = forms.NullBooleanField(required=False)
+    sync_schedule = forms.MultipleChoiceField(
+        choices=SyncScheduleChoices.choices,
+        required=False,
+    )
+
+
+class PbsServerConfigForm(NetBoxModelForm):
+    """PBS server configuration form."""
+
+    pbs_token_secret = forms.CharField(
+        widget=forms.PasswordInput(render_value=True),
+    )
+    netbox_site = DynamicModelChoiceField(
+        queryset=Site.objects.all(),
+        required=False,
+    )
+
+    class Meta:
+        model = PbsServerConfig
+        fields = (
+            "name",
+            "description",
+            "pbs_host",
+            "pbs_token_name",
+            "pbs_token_secret",
+            "pbs_verify_ssl",
+            "pbs_node_name",
+            "netbox_site",
+            "enabled",
+            "sync_schedule",
+        )
+        help_texts = {
+            "sync_schedule": (
+                "For reference only. Use a crontab or systemd timer to run "
+                "PBS sync at the desired interval."
+            ),
+        }
+
+
+class PveDriftEventFilterForm(NetBoxModelFilterSetForm):
+    """Filter form for drift event list views."""
+
+    model = PveDriftEvent
+
+    drift_type = forms.MultipleChoiceField(
+        choices=DriftTypeChoices.choices,
+        required=False,
+    )
+    cluster_name = forms.CharField(required=False, label="叢集名稱")
+    notified_telegram = forms.NullBooleanField(required=False, label="已通知 Telegram")
+
+
+class PbsServerConfigFilterForm(NetBoxModelFilterSetForm):
+    """Filter form for PBS server config list views."""
+
+    model = PbsServerConfig
+
+    enabled = forms.NullBooleanField(required=False)

pve_sync_plugin/management/__init__.py

@@ -0,0 +1 @@
+"""Management command package for the PVE Sync plugin."""

pve_sync_plugin/management/commands/__init__.py

@@ -0,0 +1 @@
+"""Django management commands for the PVE Sync plugin."""

pve_sync_plugin/management/commands/pve_sync.py

@@ -0,0 +1,182 @@
+"""Queue a PVE-NetBox sync through the NetBox plugin job path."""
+
+import json
+import time
+from argparse import ArgumentParser
+
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+
+
+class Command(BaseCommand):
+    """Headless equivalent of clicking Sync now in the plugin UI."""
+
+    help = "Queue a PVE-NetBox sync using the plugin's PveSyncJob model and RQ worker."
+
+    def add_arguments(self, parser: ArgumentParser):
+        parser.add_argument(
+            "--cluster",
+            default="default",
+            help="PVE cluster profile name to sync. Defaults to the plugin default profile.",
+        )
+        parser.add_argument(
+            "--user",
+            dest="username",
+            default=None,
+            help="Username to attribute the job to. Defaults to the oldest active superuser.",
+        )
+        parser.add_argument(
+            "--wait",
+            action="store_true",
+            help="Wait for the queued job to finish and mirror its success/failure.",
+        )
+        parser.add_argument(
+            "--timeout",
+            type=int,
+            default=7200,
+            help="Maximum seconds to wait when --wait is set.",
+        )
+        parser.add_argument(
+            "--poll-interval",
+            type=float,
+            default=2.0,
+            help="Seconds between status checks when --wait is set.",
+        )
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Skip duplicate-job check and force a new sync.",
+        )
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Print resolved configuration (with secrets redacted) and exit without syncing.",
+        )
+        parser.add_argument(
+            "--cleanup-stale",
+            action="store_true",
+            help="Mark stale jobs (>30 min in pending/running) as failed, then exit.",
+        )
+
+    def handle(self, *args, **options):
+        from pve_sync_plugin.models import PveClusterConfig, PveSyncJob
+        from pve_sync_plugin.tasks import cleanup_stale_jobs, enqueue_sync
+
+        # --cleanup-stale: housekeeping mode
+        if options["cleanup_stale"]:
+            count = cleanup_stale_jobs()
+            self.stdout.write(
+                self.style.SUCCESS(f"Cleaned up {count} stale job(s).")
+            )
+            return
+
+        cluster_name = options["cluster"]
+        if cluster_name != "default":
+            exists = PveClusterConfig.objects.filter(
+                name=cluster_name,
+                enabled=True,
+            ).exists()
+            if not exists:
+                raise CommandError(f"Enabled PVE cluster profile '{cluster_name}' was not found.")
+
+        # --dry-run: print config and exit
+        if options["dry_run"]:
+            self._handle_dry_run(cluster_name)
+            return
+
+        # Check for duplicate running jobs (unless --force)
+        if not options["force"]:
+            active = PveSyncJob.objects.filter(
+                cluster_name=cluster_name,
+                status__in=["pending", "running"],
+            ).exists()
+            if active:
+                raise CommandError(
+                    f"A sync job is already running for cluster '{cluster_name}'. "
+                    f"Use --force to bypass this check."
+                )
+
+        user = self._resolve_user(options.get("username"))
+        job = PveSyncJob.objects.create(
+            cluster_name=cluster_name,
+            status="pending",
+            trigger="scheduled",
+            triggered_by=user,
+            details={"source": "management_command"},
+        )
+
+        try:
+            rq_job_id = enqueue_sync(job)
+        except Exception as exc:
+            raise CommandError(f"Failed to enqueue PVE sync job: {exc}") from exc
+
+        self.stdout.write(
+            self.style.SUCCESS(
+                f"Queued PVE sync job #{job.pk} for cluster '{cluster_name}'"
+                f" on RQ job {rq_job_id}."
+            )
+        )
+
+        if options["wait"]:
+            self._wait_for_job(job.pk, options["timeout"], options["poll_interval"])
+
+    def _handle_dry_run(self, cluster_name):
+        """Print the resolved runtime config with secrets redacted."""
+        from pve_sync_plugin.sync.config_bridge import build_runtime_config_from_db
+
+        config = build_runtime_config_from_db(cluster_name)
+
+        # Redact sensitive values
+        for c in config.get("clusters", []):
+            pve = c.get("pve", {})
+            for secret_key in ("secret", "token"):
+                if pve.get(secret_key):
+                    pve[secret_key] = "***REDACTED***"
+            nb = c.get("netbox", {})
+            if nb.get("token"):
+                nb["token"] = "***REDACTED***"
+        tg = config.get("telegram", {})
+        if tg.get("bot_token"):
+            tg["bot_token"] = "***REDACTED***"
+
+        self.stdout.write(json.dumps(config, indent=2, ensure_ascii=False))
+        self.stdout.write(
+            self.style.WARNING("\nDry run — no sync was executed.")
+        )
+
+    def _resolve_user(self, username):
+        from django.contrib.auth import get_user_model
+
+        user_model = get_user_model()
+        if username:
+            user = user_model.objects.filter(username=username).first()
+            if user is None:
+                raise CommandError(f"User '{username}' does not exist.")
+            return user
+
+        return (
+            user_model.objects.filter(is_active=True, is_superuser=True)
+            .order_by("pk")
+            .first()
+        )
+
+    def _wait_for_job(self, job_id, timeout, poll_interval):
+        from pve_sync_plugin.models import PveSyncJob
+
+        deadline = timezone.now().timestamp() + timeout
+        while timezone.now().timestamp() < deadline:
+            job = PveSyncJob.objects.get(pk=job_id)
+            if job.status in {"success", "partial"}:
+                self.stdout.write(
+                    self.style.SUCCESS(
+                        f"PVE sync job #{job_id} finished: {job.status} — "
+                        f"{job.success_vms}/{job.total_vms} VMs synced."
+                    )
+                )
+                return
+            if job.status == "failed":
+                error = job.details.get("error") or job.details.get("queue_error") or "unknown error"
+                raise CommandError(f"PVE sync job #{job_id} failed: {error}")
+            time.sleep(poll_interval)
+
+        raise CommandError(f"Timed out waiting for PVE sync job #{job_id}.")

pve_sync_plugin/management/commands/run_scheduled_syncs.py

@@ -0,0 +1,109 @@
+"""Check all PVE/PBS configs with a sync schedule and trigger overdue ones."""
+
+import datetime
+import logging
+
+from django.core.management.base import BaseCommand
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+_SCHEDULE_INTERVALS = {
+    "hourly":   datetime.timedelta(hours=1),
+    "every_3h": datetime.timedelta(hours=3),
+    "every_6h": datetime.timedelta(hours=6),
+    "daily":    datetime.timedelta(hours=24),
+    "weekly":   datetime.timedelta(weeks=1),
+}
+
+
+class Command(BaseCommand):
+    help = "Trigger syncs for PVE clusters and PBS servers that are past their scheduled interval."
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--dry-run",
+            action="store_true",
+            help="Print what would run without actually doing it.",
+        )
+
+    def handle(self, *args, **options):
+        dry_run = options["dry_run"]
+        now = timezone.now()
+        triggered = 0
+
+        triggered += self._check_pve_clusters(now, dry_run)
+        triggered += self._check_pbs_servers(now, dry_run)
+
+        level = self.style.SUCCESS if triggered else self.style.WARNING
+        self.stdout.write(level(
+            f"{'[dry-run] ' if dry_run else ''}Triggered {triggered} scheduled sync(s)."
+        ))
+
+    def _is_due(self, last_sync, schedule, now):
+        interval = _SCHEDULE_INTERVALS.get(schedule)
+        if not interval:
+            return False
+        if last_sync is None:
+            return True
+        return (now - last_sync) >= interval
+
+    def _check_pve_clusters(self, now, dry_run):
+        from pve_sync_plugin.models import PveClusterConfig, PveSyncJob
+        from pve_sync_plugin.view_helpers import has_active_sync_job
+        from pve_sync_plugin.tasks import enqueue_sync
+
+        triggered = 0
+        clusters = PveClusterConfig.objects.filter(enabled=True).exclude(sync_schedule="disabled")
+        for cluster in clusters:
+            if not self._is_due(cluster.last_sync, cluster.sync_schedule, now):
+                logger.debug("PVE cluster '%s' not yet due (schedule=%s, last_sync=%s)",
+                             cluster.name, cluster.sync_schedule, cluster.last_sync)
+                continue
+
+            if has_active_sync_job(cluster.name):
+                self.stdout.write(f"  Skipping '{cluster.name}': sync already running.")
+                continue
+
+            self.stdout.write(f"  Triggering PVE sync for '{cluster.name}' (schedule={cluster.sync_schedule})")
+            if not dry_run:
+                job = PveSyncJob.objects.create(
+                    cluster_name=cluster.name,
+                    status="pending",
+                    trigger="scheduled",
+                    details={"source": "run_scheduled_syncs"},
+                )
+                enqueue_sync(job)
+            triggered += 1
+
+        return triggered
+
+    def _check_pbs_servers(self, now, dry_run):
+        from pve_sync_plugin.models import PbsServerConfig, PveSyncJob
+        from pve_sync_plugin.tasks import enqueue_pbs_sync
+        from pve_sync_plugin.view_helpers import has_active_sync_job
+
+        triggered = 0
+        servers = PbsServerConfig.objects.filter(enabled=True).exclude(sync_schedule="disabled")
+        for pbs in servers:
+            if not self._is_due(pbs.last_sync, pbs.sync_schedule, now):
+                logger.debug("PBS server '%s' not yet due (schedule=%s, last_sync=%s)",
+                             pbs.name, pbs.sync_schedule, pbs.last_sync)
+                continue
+
+            if has_active_sync_job(f"pbs:{pbs.name}"):
+                self.stdout.write(f"  Skipping PBS '{pbs.name}': sync already running.")
+                continue
+
+            self.stdout.write(f"  Triggering PBS sync for '{pbs.name}' (schedule={pbs.sync_schedule})")
+            if not dry_run:
+                job = PveSyncJob.objects.create(
+                    cluster_name=f"pbs:{pbs.name}",
+                    status="pending",
+                    trigger="scheduled",
+                    details={"source": "run_scheduled_syncs", "pbs_server_pk": pbs.pk},
+                )
+                enqueue_pbs_sync(job, pbs)
+            triggered += 1
+
+        return triggered