Upload 4 files

core/management/commands/restart_workers.py

@@ -0,0 +1,133 @@
+"""
+Management command to restart qcluster workers.
+
+This command signals the entrypoint script to restart the worker process.
+It's designed to be called from the web UI or manually.
+"""
+
+import os
+import signal
+import time
+import logging
+
+from django.core.management.base import BaseCommand, CommandError
+from django.utils import timezone
+
+from core.models import GlobalSettings
+
+logger = logging.getLogger(__name__)
+
+PID_FILE = "/tmp/qcluster.pid"
+
+
+class Command(BaseCommand):
+    help = "Restart the django-q2 worker process"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Force restart even if workers appear healthy",
+        )
+        parser.add_argument(
+            "--timeout",
+            type=int,
+            default=30,
+            help="Seconds to wait for workers to restart (default: 30)",
+        )
+
+    def handle(self, *args, **options):
+        timeout = options["timeout"]
+
+        # Check if PID file exists
+        if not os.path.exists(PID_FILE):
+            raise CommandError(
+                f"Worker PID file not found at {PID_FILE}. "
+                "Workers may not be running or not started via entrypoint.sh"
+            )
+
+        # Read current worker PID
+        try:
+            with open(PID_FILE, "r") as f:
+                old_pid = int(f.read().strip())
+        except (ValueError, IOError) as e:
+            raise CommandError(f"Failed to read PID file: {e}")
+
+        # Verify process exists
+        try:
+            os.kill(old_pid, 0)
+            self.stdout.write(f"Current worker PID: {old_pid}")
+        except OSError:
+            self.stdout.write(
+                self.style.WARNING(
+                    f"Worker process {old_pid} not found. May already be restarting."
+                )
+            )
+
+        # Record the restart request time
+        restart_requested_at = timezone.now()
+
+        # Try to send SIGUSR1 to PID 1 (entrypoint process in Docker)
+        restart_sent = False
+        try:
+            os.kill(1, signal.SIGUSR1)
+            self.stdout.write(self.style.SUCCESS("Restart signal sent to entrypoint"))
+            restart_sent = True
+        except OSError as e:
+            # Fallback: try to kill the worker directly (non-Docker case)
+            self.stdout.write(
+                self.style.WARNING(f"Could not signal PID 1: {e}")
+            )
+            self.stdout.write("Attempting direct worker termination...")
+            try:
+                os.kill(old_pid, signal.SIGTERM)
+                self.stdout.write(
+                    self.style.SUCCESS(f"SIGTERM sent to worker {old_pid}")
+                )
+                restart_sent = True
+            except OSError as e2:
+                raise CommandError(f"Failed to stop worker: {e2}")
+
+        if not restart_sent:
+            raise CommandError("Failed to send restart signal")
+
+        # Wait for restart to complete
+        self.stdout.write(f"Waiting up to {timeout}s for workers to restart...")
+
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            time.sleep(2)
+
+            # Check if PID changed (new worker started)
+            if os.path.exists(PID_FILE):
+                try:
+                    with open(PID_FILE, "r") as f:
+                        new_pid = int(f.read().strip())
+                    if new_pid != old_pid:
+                        self.stdout.write(
+                            self.style.SUCCESS(
+                                f"New worker started with PID {new_pid}"
+                            )
+                        )
+                        return
+                except (ValueError, IOError):
+                    pass
+
+            # Check if new heartbeat received after restart
+            settings = GlobalSettings.get_settings()
+            settings.refresh_from_db()
+            if (
+                settings.worker_heartbeat_at
+                and settings.worker_heartbeat_at > restart_requested_at
+            ):
+                self.stdout.write(
+                    self.style.SUCCESS("Workers restarted successfully!")
+                )
+                return
+
+        self.stdout.write(
+            self.style.WARNING(
+                f"Timeout waiting for restart confirmation. "
+                "Check worker logs for status."
+            )
+        )

core/management/commands/setup.py

@@ -0,0 +1,73 @@
+"""
+Management command for initial setup.
+
+This command is designed to be used as a Docker entrypoint or for
+scripted deployments where browser-based setup is not available.
+"""
+
+from django.core.management.base import BaseCommand
+
+from core.services.setup_service import SetupService
+
+
+class Command(BaseCommand):
+    help = "Run initial setup (migrations + default environment)"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--skip-env",
+            action="store_true",
+            help="Skip creating the default Python environment",
+        )
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Run setup even if already completed",
+        )
+
+    def handle(self, *args, **options):
+        skip_env = options["skip_env"]
+        force = options["force"]
+
+        self.stdout.write("Starting PyRunner setup...\n")
+
+        # ALWAYS run migrations (required for upgrades)
+        self.stdout.write("Running database migrations...")
+        success, message = SetupService.run_migrations()
+        if success:
+            self.stdout.write(self.style.SUCCESS("  Migrations complete"))
+        else:
+            self.stdout.write(self.style.ERROR(f"  Migration failed: {message}"))
+            return
+
+        # Check if full setup is needed (environment creation, etc.)
+        if not force and not SetupService.is_setup_needed():
+            self.stdout.write(
+                self.style.SUCCESS("Setup already completed.")
+            )
+            return
+
+        # Create default environment (only on initial setup)
+        if not skip_env:
+            self.stdout.write("Creating default Python environment...")
+            success, message = SetupService.create_default_environment()
+            if success:
+                self.stdout.write(self.style.SUCCESS(f"  {message}"))
+            else:
+                self.stdout.write(self.style.ERROR(f"  Failed: {message}"))
+                return
+        else:
+            self.stdout.write(
+                self.style.WARNING("  Skipping default environment (--skip-env)")
+            )
+
+        # Mark setup as complete
+        SetupService.complete_setup()
+
+        self.stdout.write("")
+        self.stdout.write(self.style.SUCCESS("Setup completed successfully!"))
+        self.stdout.write("")
+        self.stdout.write("Next steps:")
+        self.stdout.write("  1. Start the task worker: python manage.py qcluster")
+        self.stdout.write("  2. Start the web server: python manage.py runserver")
+        self.stdout.write("  3. Log in - the first user becomes the administrator")

core/management/commands/setup_default_env.py

@@ -0,0 +1,121 @@
+"""
+Management command to set up the default Python environment.
+
+Creates a virtual environment at data/environments/default/ and registers it
+in the database as the default environment for script execution.
+"""
+
+import os
+import subprocess
+import sys
+
+from django.conf import settings
+from django.core.management.base import BaseCommand, CommandError
+
+from core.models import Environment
+
+
+class Command(BaseCommand):
+    help = "Create and register the default Python environment"
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            "--force",
+            action="store_true",
+            help="Recreate the environment even if it already exists",
+        )
+
+    def handle(self, *args, **options):
+        force = options["force"]
+
+        # Check if default environment already exists in DB
+        existing = Environment.objects.filter(is_default=True).first()
+        if existing and not force:
+            self.stdout.write(
+                self.style.WARNING(
+                    f'Default environment already exists: "{existing.name}" '
+                    f"at {existing.get_full_path()}"
+                )
+            )
+            self.stdout.write("Use --force to recreate it.")
+            return
+
+        # Define paths
+        env_path = "default"
+        full_path = os.path.join(settings.ENVIRONMENTS_ROOT, env_path)
+
+        # Check if directory already exists
+        if os.path.exists(full_path):
+            if not force:
+                self.stdout.write(
+                    self.style.WARNING(
+                        f"Environment directory already exists: {full_path}"
+                    )
+                )
+                self.stdout.write("Use --force to recreate it.")
+                return
+            else:
+                self.stdout.write(f"Removing existing environment at {full_path}...")
+                import shutil
+
+                shutil.rmtree(full_path)
+
+        # Create the virtual environment
+        self.stdout.write(f"Creating virtual environment at {full_path}...")
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "venv", full_path],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            raise CommandError(f"Failed to create virtual environment: {e.stderr}")
+
+        # Get Python version from the new venv
+        if os.name == "nt":
+            python_path = os.path.join(full_path, "Scripts", "python.exe")
+        else:
+            python_path = os.path.join(full_path, "bin", "python")
+
+        try:
+            result = subprocess.run(
+                [python_path, "--version"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            python_version = result.stdout.strip().replace("Python ", "")
+        except subprocess.CalledProcessError:
+            python_version = "unknown"
+
+        # Create or update the Environment record
+        if existing and force:
+            # Update existing record
+            existing.path = env_path
+            existing.python_version = python_version
+            existing.save()
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f'Updated default environment "{existing.name}" '
+                    f"(Python {python_version})"
+                )
+            )
+        else:
+            # Create new record
+            Environment.objects.create(
+                name="Default Environment",
+                description="Auto-created default Python environment",
+                path=env_path,
+                python_version=python_version,
+                is_default=True,
+                is_active=True,
+            )
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"Created default environment (Python {python_version})"
+                )
+            )
+
+        self.stdout.write(f"Environment path: {full_path}")
+        self.stdout.write(f"Python executable: {python_path}")