Upload 5 files

Dockerfile

@@ -20,7 +20,10 @@ COPY requirements.txt .
 # Install Python dependencies using pre-built wheels only
 RUN pip install --no-cache-dir --only-binary :all: -r requirements.txt
 
-# Copy the launcher/server application
+# Copy the server application
+COPY xmrig_server.py .
+
+# Copy the launcher script
 COPY xmrig_launcher.py .
 
 # Copy static files for the web UI
@@ -47,6 +50,8 @@ EXPOSE 8000
 USER root
 
 # Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
 
 # Start the server with uvicorn
-CMD ["python", "-m", "uvicorn", "xmrig_launcher:app", "--host", "0.0.0.0", "--port", "8000"]
+CMD ["uvicorn", "xmrig_server:app", "--host", "0.0.0.0", "--port", "8000"]

static/index.html

@@ -544,7 +544,7 @@
             spinner.classList.add('active');
 
             try {
-                const response = await fetch(API_URL + 'benchmark/start', {
+                const response = await fetch(API_URL + 'mining/start', {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({ benchmark, threads })
@@ -574,7 +574,7 @@
             btn.disabled = true;
 
             try {
-                const response = await fetch(API_URL + 'benchmark/stop', { method: 'POST' });
+                    const response = await fetch(API_URL + 'mining/stop', { method: 'POST' });
                 if (response.ok) {
                     stopStatusPolling();
                     await getStatus();

xmrig_launcher.py

@@ -1,96 +1,99 @@
 #!/usr/bin/env python3
 """
-XMRig FastAPI Server - Web interface for RandomX benchmarking
+Standalone XMRig Launcher
+Downloads XMRig if needed, then starts benchmarking
+Usage: python xmrig_launcher.py --bench 1M --threads 4
 """
 
-import os
 import sys
+import os
 import subprocess
-import json
+import argparse
 import platform
-import ctypes
+import shutil
+import urllib.request
+import zipfile
 from pathlib import Path
-from typing import Optional
-from datetime import datetime
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI, HTTPException, BackgroundTasks
-from fastapi.responses import JSONResponse, HTMLResponse
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel
-import uvicorn
-import threading
-
-# ==================== Admin Detection ====================
-
-def is_admin():
-    """Check if running with admin privileges"""
-    try:
-        return ctypes.windll.shell.IsUserAnAdmin()
-    except:
-        return False
-
-
-# ==================== Pydantic Models ====================
-
-class BenchmarkRequest(BaseModel):
-    benchmark: str = "1M"
-    threads: Optional[int] = None
-
-
-class BenchmarkResponse(BaseModel):
-    status: str
-    benchmark: str
-    threads: int
-    running: bool
-    started_at: Optional[str] = None
-
-
-# ==================== XMRig Launcher Class ====================
 
 class XMRigLauncher:
-    def __init__(self, base_dir=None):
-        if base_dir is None:
-            base_dir = Path(__file__).parent.absolute()
-        
-        self.base_dir = Path(base_dir)
+    def __init__(self):
+        self.base_dir = Path(__file__).parent.absolute()
         self.xmrig_dir = self.base_dir / "xmrig"
         self.xmrig_extracted = self.xmrig_dir / "xmrig-6.21.0"
         self.xmrig_bin = self.xmrig_extracted / ("xmrig.exe" if platform.system() == "Windows" else "xmrig")
-        self.process = None
-        self.benchmark_config = {}
-        self.logs = []
-        self.log_reader_thread = None
+    
+    def download_xmrig(self):
+        """Download and extract XMRig"""
+        print("[*] Downloading XMRig...")
         
-
+        try:
+            if platform.system() == "Windows":
+                url = "https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-msvc-win64.zip"
+            elif platform.system() == "Linux":
+                url = "https://github.com/xmrig/xmrig/releases/download/v6.21.0/xmrig-6.21.0-linux-static-x64.tar.gz"
+            else:
+                print("[!] Unsupported platform")
+                return False
+            
+            # Create directory
+            self.xmrig_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Download
+            if platform.system() == "Windows":
+                archive_path = self.xmrig_dir / "xmrig.zip"
+            else:
+                archive_path = self.xmrig_dir / "xmrig.tar.gz"
+            
+            print(f"[*] Downloading from {url}...")
+            urllib.request.urlretrieve(url, archive_path)
+            print(f"[+] Downloaded to {archive_path}")
+            
+            # Extract
+            if platform.system() == "Windows":
+                with zipfile.ZipFile(archive_path, 'r') as zip_ref:
+                    zip_ref.extractall(self.xmrig_dir)
+            else:
+                import tarfile
+                with tarfile.open(archive_path, 'r:gz') as tar_ref:
+                    tar_ref.extractall(self.xmrig_dir)
+            
+            # Find and verify binary
+            if self.xmrig_bin.exists():
+                if platform.system() != "Windows":
+                    os.chmod(self.xmrig_bin, 0o755)
+                print(f"[+] XMRig extracted to {self.xmrig_bin}")
+                return True
+            else:
+                print(f"[!] XMRig binary not found at {self.xmrig_bin}")
+                return False
+                
+        except Exception as e:
+            print(f"[!] Download failed: {e}")
+            return False
+    
     def start_benchmark(self, benchmark="1M", threads=None):
-        """Start XMRig benchmark process"""
+        """Start XMRig benchmark"""
         if not self.xmrig_bin.exists():
-            raise HTTPException(status_code=400, detail="XMRig binary not found. Please install it manually.")
-        
-        if self.process and self.process.poll() is None:
-            raise HTTPException(status_code=400, detail="Benchmark already running")
+            print("[!] XMRig binary not found at " + str(self.xmrig_bin))
+            print("[*] Attempting to download...")
+            if not self.download_xmrig():
+                print("[!] Failed to download XMRig")
+                return False
         
         if threads is None:
             threads = os.cpu_count() or 4
         
-        # Clear previous logs
-        self.logs = []
-        
         # Build command
         cmd = [str(self.xmrig_bin), f"--bench={benchmark}", "--threads", str(threads)]
         
-        # Store config
-        self.benchmark_config = {
-            "benchmark": benchmark,
-            "threads": threads,
-            "started_at": datetime.now().isoformat(),
-            "status": "running"
-        }
+        print(f"[+] Starting XMRig benchmark: {benchmark} with {threads} threads")
+        print(f"[*] Command: {' '.join(cmd)}")
+        print("[*] Output:")
+        print("-" * 60)
         
         try:
-            # Start process with output capture
-            self.process = subprocess.Popen(
+            # Start process with live output streaming
+            process = subprocess.Popen(
                 cmd,
                 cwd=str(self.xmrig_extracted),
                 stdout=subprocess.PIPE,
@@ -100,243 +103,38 @@ class XMRigLauncher:
                 universal_newlines=True
             )
             
-            # Start log reader thread
-            self.log_reader_thread = threading.Thread(target=self._read_logs, daemon=True)
-            self.log_reader_thread.start()
+            # Stream output in real-time
+            for line in iter(process.stdout.readline, ''):
+                if line:
+                    print(line.rstrip())
+            
+            process.wait()
+            return_code = process.returncode
+            
+            print("-" * 60)
+            if return_code == 0:
+                print("[+] Benchmark completed successfully")
+            else:
+                print(f"[!] Benchmark exited with code {return_code}")
+            
+            return return_code == 0
             
-            return True
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Failed to start benchmark: {e}")
-    
-    def _read_logs(self):
-        """Read logs from process in real-time (daemon thread)"""
-        try:
-            if self.process and self.process.stdout:
-                # This runs in a daemon thread, so blocking readline is fine
-                while self.process and self.process.poll() is None:
-                    try:
-                        line = self.process.stdout.readline()
-                        if line:
-                            log_entry = {
-                                "timestamp": datetime.now().isoformat(),
-                                "message": line.rstrip()
-                            }
-                            self.logs.append(log_entry)
-                            print(line.rstrip())
-                        else:
-                            # EOF reached
-                            break
-                    except Exception as e:
-                        print(f"[!] Error reading line: {e}")
-                        break
         except Exception as e:
-            print(f"[!] Error in log reader: {e}")
-    
-    def stop_benchmark(self):
-        """Stop running benchmark"""
-        if self.process and self.process.poll() is None:
-            self.process.terminate()
-            try:
-                self.process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                self.process.kill()
-            self.benchmark_config["status"] = "stopped"
-            return True
-        return False
-    
-    def is_running(self):
-        """Check if benchmark is running"""
-        return self.process and self.process.poll() is None
-    
-    def get_output(self):
-        """Get benchmark output"""
-        if not self.process:
-            return ""
-        
-        output = ""
-        try:
-            # Non-blocking read
-            if self.process.stdout:
-                import select
-                import io
-                ready = select.select([self.process.stdout], [], [], 0)[0]
-                if ready:
-                    output = self.process.stdout.read()
-        except:
-            pass
-        
-        return output
-
-
-from contextlib import asynccontextmanager
-
-# Global launcher instance
-launcher = XMRigLauncher()
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup
-    print("\n[*] Server starting...")
-    
-    # Check if XMRig binary exists
-    if not launcher.xmrig_bin.exists():
-        print(f"[!] XMRig binary not found at {launcher.xmrig_bin}")
-        print("[!] Please ensure XMRig is installed manually")
-    else:
-        print("[+] XMRig binary found")
-    
-    print("[+] Server ready - click Start Mining button to begin")
-    
-    yield
-    
-    # Shutdown
-    print("\n[*] Server shutting down...")
-    launcher.stop_benchmark()
-
-
-# ==================== FastAPI App ====================
-
-app = FastAPI(
-    title="XMRig Server",
-    description="FastAPI server for RandomX benchmarking with XMRig",
-    version="1.0.0",
-    lifespan=lifespan
-)
-
-# Mount static files (if directory exists)
-static_dir = Path(__file__).parent / "static"
-if static_dir.exists():
-    app.mount("/static", StaticFiles(directory="static"), name="static")
-else:
-    print("[!] Warning: static/ directory not found, UI will not be available")
-
-
-@app.get("/api")
-async def api_info():
-    """API endpoints info"""
-    return {
-        "name": "XMRig Server",
-        "version": "1.0.0",
-        "endpoints": {
-            "GET /health": "Health check",
-            "GET /status": "Get system and benchmark status",
-            "POST /benchmark/start": "Start benchmark",
-            "POST /benchmark/stop": "Stop benchmark",
-            "GET /benchmark/status": "Get benchmark status"
-        }
-    }
-
-
-@app.get("/")
-async def root():
-    """Root endpoint - serve static HTML UI"""
-    try:
-        with open("static/index.html", "r", encoding="utf-8") as f:
-            return HTMLResponse(content=f.read())
-    except FileNotFoundError:
-        return HTMLResponse(
-            content="<h1>404</h1><p>static/index.html not found</p>",
-            status_code=404
-        )
-
-
-@app.get("/health")
-async def health():
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "timestamp": datetime.now().isoformat(),
-        "admin": is_admin()
-    }
-
-
-@app.get("/status")
-async def status():
-    """Get system and benchmark status"""
-    return {
-        "system": {
-            "platform": platform.system(),
-            "admin": is_admin(),
-            "cpu_count": os.cpu_count() or 4
-        },
-        "xmrig": {
-            "binary_exists": launcher.xmrig_bin.exists(),
-            "binary_path": str(launcher.xmrig_bin),
-            "base_dir": str(launcher.base_dir)
-        },
-        "benchmark": {
-            "running": launcher.is_running(),
-            "config": launcher.benchmark_config if launcher.benchmark_config else None
-        }
-    }
-
-
-@app.post("/benchmark/start")
-async def start_benchmark(request: BenchmarkRequest):
-    """Start a benchmark"""
-    if launcher.is_running():
-        raise HTTPException(status_code=400, detail="Benchmark already running")
-    
-    launcher.start_benchmark(request.benchmark, request.threads)
-    
-    return {
-        "status": "started",
-        "benchmark": request.benchmark,
-        "threads": request.threads or os.cpu_count() or 4,
-        "admin": is_admin(),
-        "admin_warning": "Run with admin for 2-3x better performance" if not is_admin() else None
-    }
-
-
-@app.post("/benchmark/stop")
-async def stop_benchmark():
-    """Stop running benchmark"""
-    if launcher.stop_benchmark():
-        return {"status": "stopped"}
-    else:
-        raise HTTPException(status_code=400, detail="No benchmark running")
-
-
-@app.get("/benchmark/status")
-async def benchmark_status():
-    """Get benchmark status"""
-    return {
-        "running": launcher.is_running(),
-        "config": launcher.benchmark_config if launcher.benchmark_config else None,
-        "pid": launcher.process.pid if launcher.process else None
-    }
-
-
-@app.get("/logs")
-async def get_logs():
-    """Get benchmark logs"""
-    return {
-        "logs": launcher.logs[-100:] if launcher.logs else [],  # Last 100 logs
-        "total_logs": len(launcher.logs)
-    }
-
+            print(f"[!] Error running benchmark: {e}")
+            return False
 
-# ==================== Main ====================
 
 def main():
-    """Run the FastAPI server"""
-    print("\n" + "="*60)
-    print("XMRig FastAPI Server")
-    print("="*60)
-    print("[*] Starting server on http://127.0.0.1:8000")
-    print("[*] Web UI: http://127.0.0.1:8000/ui")
-    print("[*] API docs: http://127.0.0.1:8000/docs")
-    print("[*] ReDoc: http://127.0.0.1:8000/redoc")
+    parser = argparse.ArgumentParser(description="XMRig Launcher")
+    parser.add_argument("--bench", type=str, default="1M", help="Benchmark type (1M or 10M)")
+    parser.add_argument("--threads", type=int, default=None, help="Number of threads")
     
-    if is_admin():
-        print("[+] Running as Administrator ✓")
-    else:
-        print("[!] NOT running as Administrator")
-        print("    → Run as Admin for 2-3x better performance")
+    args = parser.parse_args()
     
-    print("="*60 + "\n")
+    launcher = XMRigLauncher()
+    success = launcher.start_benchmark(args.bench, args.threads)
     
-    uvicorn.run(app, host="127.0.0.1", port=8000, log_level="info")
+    sys.exit(0 if success else 1)
 
 
 if __name__ == "__main__":

xmrig_server.py

@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+"""
+XMRig FastAPI Server - Web interface for RandomX benchmarking
+Spawns xmrig_launcher.py as subprocess for mining operations
+"""
+
+import os
+import sys
+import subprocess
+import platform
+import ctypes
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+import uvicorn
+import threading
+
+# ==================== Admin Detection ====================
+
+def is_admin():
+    """Check if running with admin privileges"""
+    try:
+        return ctypes.windll.shell.IsUserAnAdmin()
+    except:
+        return False
+
+
+# ==================== Pydantic Models ====================
+
+class BenchmarkRequest(BaseModel):
+    benchmark: str = "1M"
+    threads: Optional[int] = None
+
+
+# ==================== Mining Manager Class ====================
+
+class MiningManager:
+    def __init__(self, base_dir=None):
+        if base_dir is None:
+            base_dir = Path(__file__).parent.absolute()
+        
+        self.base_dir = Path(base_dir)
+        self.launcher_script = self.base_dir / "xmrig_launcher.py"
+        self.process = None
+        self.benchmark_config = {}
+        self.logs = []
+        self.log_reader_thread = None
+        
+    def start_mining(self, benchmark="1M", threads=None):
+        """Start mining by spawning xmrig_launcher.py"""
+        if self.process and self.process.poll() is None:
+            raise HTTPException(status_code=400, detail="Mining already running")
+        
+        if threads is None:
+            threads = os.cpu_count() or 4
+        
+        # Clear previous logs
+        self.logs = []
+        
+        # Build command to run launcher script
+        cmd = [
+            sys.executable,
+            str(self.launcher_script),
+            "--bench", benchmark,
+            "--threads", str(threads)
+        ]
+        
+        # Store config
+        self.benchmark_config = {
+            "benchmark": benchmark,
+            "threads": threads,
+            "started_at": datetime.now().isoformat(),
+            "status": "running"
+        }
+        
+        try:
+            # Start process with output capture
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                universal_newlines=True
+            )
+            
+            # Start log reader thread
+            self.log_reader_thread = threading.Thread(target=self._read_logs, daemon=True)
+            self.log_reader_thread.start()
+            
+            return True
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to start mining: {e}")
+    
+    def _read_logs(self):
+        """Read logs from process in real-time (daemon thread)"""
+        try:
+            if self.process and self.process.stdout:
+                # This runs in a daemon thread, so blocking readline is fine
+                while self.process and self.process.poll() is None:
+                    try:
+                        line = self.process.stdout.readline()
+                        if line:
+                            log_entry = {
+                                "timestamp": datetime.now().isoformat(),
+                                "message": line.rstrip()
+                            }
+                            self.logs.append(log_entry)
+                            print(line.rstrip())
+                        else:
+                            # EOF reached
+                            break
+                    except Exception as e:
+                        print(f"[!] Error reading line: {e}")
+                        break
+        except Exception as e:
+            print(f"[!] Error in log reader: {e}")
+    
+    def stop_mining(self):
+        """Stop running mining"""
+        if self.process and self.process.poll() is None:
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+            self.benchmark_config["status"] = "stopped"
+            return True
+        return False
+    
+    def is_running(self):
+        """Check if mining is running"""
+        return self.process and self.process.poll() is None
+    
+    def get_xmrig_status(self):
+        """Check if launcher script is available"""
+        return {
+            "launcher_available": self.launcher_script.exists(),
+            "launcher_path": str(self.launcher_script)
+        }
+
+
+# Global manager instance
+manager = MiningManager()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    print("\n[*] Server starting...")
+    
+    # Check if launcher script exists
+    if not manager.launcher_script.exists():
+        print(f"[!] Warning: xmrig_launcher.py not found at {manager.launcher_script}")
+    else:
+        print(f"[+] Launcher script found")
+    
+    print("[+] Server ready - click Start Mining button to begin")
+    
+    yield
+    
+    # Shutdown
+    print("\n[*] Server shutting down...")
+    manager.stop_mining()
+
+
+# ==================== FastAPI App ====================
+
+app = FastAPI(
+    title="XMRig Mining Server",
+    description="FastAPI server for RandomX benchmarking with XMRig launcher",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Mount static files (if directory exists)
+static_dir = Path(__file__).parent / "static"
+if static_dir.exists():
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+@app.get("/api")
+async def api_info():
+    """API endpoints info"""
+    return {
+        "name": "XMRig Mining Server",
+        "version": "1.0.0",
+        "endpoints": {
+            "GET /health": "Health check",
+            "GET /status": "Get system and mining status",
+            "POST /mining/start": "Start mining with XMRig launcher",
+            "POST /mining/stop": "Stop mining",
+            "GET /mining/status": "Get mining status",
+            "GET /logs": "Get mining logs"
+        }
+    }
+
+
+@app.get("/")
+async def root():
+    """Root endpoint - serve static HTML UI"""
+    try:
+        with open("static/index.html", "r", encoding="utf-8") as f:
+            return HTMLResponse(content=f.read())
+    except FileNotFoundError:
+        return HTMLResponse(
+            content="<h1>404</h1><p>static/index.html not found</p>",
+            status_code=404
+        )
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "admin": is_admin()
+    }
+
+
+@app.get("/status")
+async def status():
+    """Get system and mining status"""
+    return {
+        "system": {
+            "platform": platform.system(),
+            "admin": is_admin(),
+            "cpu_count": os.cpu_count() or 4
+        },
+        "xmrig": manager.get_xmrig_status(),
+        "mining": {
+            "running": manager.is_running(),
+            "config": manager.benchmark_config if manager.benchmark_config else None
+        }
+    }
+
+
+@app.post("/mining/start")
+async def start_mining(request: BenchmarkRequest):
+    """Start mining using xmrig_launcher.py"""
+    if manager.is_running():
+        raise HTTPException(status_code=400, detail="Mining already running")
+    
+    manager.start_mining(request.benchmark, request.threads)
+    
+    return {
+        "status": "started",
+        "benchmark": request.benchmark,
+        "threads": request.threads or os.cpu_count() or 4,
+        "admin": is_admin(),
+        "admin_warning": "Run with admin for 2-3x better performance" if not is_admin() else None
+    }
+
+
+@app.post("/mining/stop")
+async def stop_mining():
+    """Stop running mining"""
+    if manager.stop_mining():
+        return {"status": "stopped"}
+    else:
+        raise HTTPException(status_code=400, detail="No mining running")
+
+
+@app.get("/mining/status")
+async def mining_status():
+    """Get mining status"""
+    return {
+        "running": manager.is_running(),
+        "config": manager.benchmark_config if manager.benchmark_config else None,
+        "pid": manager.process.pid if manager.process else None
+    }
+
+
+@app.get("/logs")
+async def get_logs():
+    """Get mining logs"""
+    return {
+        "logs": manager.logs[-100:] if manager.logs else [],  # Last 100 logs
+        "total_logs": len(manager.logs)
+    }
+
+
+# ==================== Main ====================
+
+def main():
+    """Run the FastAPI server"""
+    print("\n" + "="*60)
+    print("XMRig Mining Server")
+    print("="*60)
+    print("[*] Starting server on http://127.0.0.1:8000")
+    print("[*] Web UI: http://127.0.0.1:8000/")
+    print("[*] API docs: http://127.0.0.1:8000/docs")
+    
+    if is_admin():
+        print("[+] Running as Administrator ✓")
+    else:
+        print("[!] NOT running as Administrator")
+        print("    → Run as Admin for 2-3x better performance")
+    
+    print("="*60 + "\n")
+    
+    uvicorn.run(app, host="127.0.0.1", port=8000, log_level="info")
+
+
+if __name__ == "__main__":
+    main()