| """ |
| FastAPI server for Bitcoin mining dashboard - Complete Integration |
| """ |
| from fastapi import FastAPI, HTTPException, BackgroundTasks |
| from fastapi.staticfiles import StaticFiles |
| from fastapi.responses import FileResponse, HTMLResponse |
| from fastapi.middleware.cors import CORSMiddleware |
| import uvicorn |
| import threading |
| import time |
| import json |
| import asyncio |
| from typing import Dict, Optional, List |
| import logging |
| import sys |
| import os |
|
|
| |
| sys.path.append(os.path.dirname(os.path.abspath(__file__))) |
|
|
| |
| logging.basicConfig( |
| level=logging.INFO, |
| format='%(asctime)s - %(levelname)s - %(message)s' |
| ) |
|
|
| app = FastAPI(title="Bitcoin Mining Dashboard", version="1.0.0") |
|
|
| |
| app.add_middleware( |
| CORSMiddleware, |
| allow_origins=["*"], |
| allow_credentials=True, |
| allow_methods=["*"], |
| allow_headers=["*"], |
| ) |
|
|
| |
| app.mount("/static", StaticFiles(directory="static"), name="static") |
|
|
| |
| class MiningState: |
| def __init__(self): |
| self.is_mining = False |
| self.miner_instance = None |
| self.mining_thread = None |
| self.stats = { |
| "status": "Stopped", |
| "hashrate": "0 H/s", |
| "total_hashes": "0", |
| "blocks_found": "0", |
| "best_hash": "None", |
| "difficulty": "0", |
| "network_difficulty": "0", |
| "block_alert": "Ready to start mining", |
| "mining_time": "0s", |
| "cores_active": "0", |
| "wallet_address": "1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf" |
| } |
| self.start_time = None |
|
|
| mining_state = MiningState() |
|
|
| @app.get("/", response_class=HTMLResponse) |
| async def get_index(): |
| """Serve the dashboard HTML""" |
| try: |
| return FileResponse("static/index.html") |
| except: |
| |
| return """ |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>Bitcoin Mining Dashboard</title> |
| <style> |
| body { font-family: Arial, sans-serif; margin: 40px; background: #f0f0f0; } |
| .container { max-width: 800px; margin: 0 auto; background: white; padding: 20px; border-radius: 10px; } |
| .stats { background: #2c3e50; color: white; padding: 20px; border-radius: 5px; margin: 10px 0; } |
| .alert { background: #e74c3c; color: white; padding: 15px; border-radius: 5px; margin: 10px 0; } |
| .success { background: #27ae60; } |
| .button { background: #3498db; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer; margin: 5px; } |
| .button:disabled { background: #95a5a6; } |
| </style> |
| </head> |
| <body> |
| <div class="container"> |
| <h1>⛏️ Bitcoin Mining Dashboard</h1> |
| <div id="blockAlert" class="alert">Ready to start mining</div> |
| <div class="stats"> |
| <h3>Mining Statistics</h3> |
| <div id="statsDisplay"></div> |
| </div> |
| <button class="button" onclick="startMining()" id="startBtn">Start Mining</button> |
| <button class="button" onclick="stopMining()" id="stopBtn" disabled>Stop Mining</button> |
| <script> |
| function updateStats(stats) { |
| document.getElementById('statsDisplay').innerHTML = ` |
| <p><strong>Status:</strong> ${stats.status}</p> |
| <p><strong>Hash Rate:</strong> ${stats.hashrate}</p> |
| <p><strong>Total Hashes:</strong> ${stats.total_hashes}</p> |
| <p><strong>Blocks Found:</strong> ${stats.blocks_found}</p> |
| <p><strong>Best Hash:</strong> ${stats.best_hash}</p> |
| <p><strong>Mining Time:</strong> ${stats.mining_time}</p> |
| <p><strong>Wallet:</strong> ${stats.wallet_address}</p> |
| `; |
| document.getElementById('blockAlert').textContent = stats.block_alert; |
| document.getElementById('blockAlert').className = stats.blocks_found > 0 ? 'alert success' : 'alert'; |
| |
| document.getElementById('startBtn').disabled = stats.status === 'Running'; |
| document.getElementById('stopBtn').disabled = stats.status !== 'Running'; |
| } |
| |
| async function startMining() { |
| const response = await fetch('/start_mining', { method: 'POST' }); |
| const result = await response.json(); |
| alert(result.message); |
| } |
| |
| async function stopMining() { |
| const response = await fetch('/stop_mining', { method: 'POST' }); |
| const result = await response.json(); |
| alert(result.message); |
| } |
| |
| // Poll for stats updates |
| setInterval(async () => { |
| const response = await fetch('/get_stats'); |
| const stats = await response.json(); |
| updateStats(stats); |
| }, 1000); |
| </script> |
| </div> |
| </body> |
| </html> |
| """ |
|
|
| def mining_worker(duration=None): |
| """Worker function to run mining in background thread""" |
| try: |
| |
| from parallel_miner_v3 import ParallelMiner |
| |
| mining_state.miner_instance = ParallelMiner( |
| num_cores=7, |
| wallet_address="1Ks4WtCEK96BaBF7HSuCGt3rEpVKPqcJKf" |
| ) |
| mining_state.start_time = time.time() |
| |
| |
| mining_state.miner_instance.start_mining(duration=duration) |
| |
| except Exception as e: |
| logging.error(f"Mining worker error: {e}") |
| finally: |
| mining_state.is_mining = False |
| mining_state.mining_thread = None |
|
|
| @app.post("/start_mining") |
| async def start_mining(background_tasks: BackgroundTasks): |
| """Start the mining process""" |
| global mining_state |
| |
| if mining_state.is_mining: |
| raise HTTPException(status_code=400, detail="Mining is already running") |
| |
| try: |
| mining_state.is_mining = True |
| mining_state.stats["status"] = "Starting..." |
| mining_state.stats["block_alert"] = "🔄 Starting mining process..." |
| |
| |
| mining_state.mining_thread = threading.Thread( |
| target=mining_worker, |
| kwargs={"duration": None} |
| ) |
| mining_state.mining_thread.daemon = True |
| mining_state.mining_thread.start() |
| |
| logging.info("✅ Mining started via API") |
| return {"message": "Mining started successfully", "status": "started"} |
| |
| except Exception as e: |
| mining_state.is_mining = False |
| logging.error(f"Error starting mining: {e}") |
| raise HTTPException(status_code=500, detail=str(e)) |
|
|
| @app.post("/stop_mining") |
| async def stop_mining(): |
| """Stop the mining process""" |
| global mining_state |
| |
| if not mining_state.is_mining: |
| raise HTTPException(status_code=400, detail="Mining is not running") |
| |
| try: |
| if mining_state.miner_instance: |
| mining_state.miner_instance.mining = False |
| mining_state.is_mining = False |
| |
| |
| if hasattr(mining_state.miner_instance, 'total_hashes'): |
| total_hashes = mining_state.miner_instance.total_hashes |
| blocks_found = mining_state.miner_instance.blocks_found |
| mining_time = time.time() - mining_state.start_time |
| |
| logging.info("\n" + "="*50) |
| logging.info("⛏️ FINAL MINING STATISTICS") |
| logging.info("="*50) |
| logging.info(f"⏱️ Total mining time: {mining_time:.2f} seconds") |
| logging.info(f"🔢 Total hashes: {total_hashes:,}") |
| logging.info(f"💰 Blocks found: {blocks_found}") |
| logging.info(f"⚡ Average hash rate: {total_hashes/max(mining_time,1)/1000:.2f} KH/s") |
| |
| if hasattr(mining_state.miner_instance, 'cores'): |
| for core_idx, core in enumerate(mining_state.miner_instance.cores): |
| logging.info(f"🔩 Core {core_idx}: {core.total_hashes:,} hashes") |
| logging.info("="*50) |
| |
| mining_state.stats["status"] = "Stopped" |
| mining_state.stats["block_alert"] = "🛑 Mining stopped" |
| |
| return {"message": "Mining stopped successfully", "status": "stopped"} |
| |
| raise HTTPException(status_code=400, detail="No active mining instance") |
| |
| except Exception as e: |
| logging.error(f"Error stopping mining: {e}") |
| raise HTTPException(status_code=500, detail=str(e)) |
|
|
| @app.get("/get_stats") |
| async def get_mining_stats(): |
| """Get current mining statistics""" |
| global mining_state |
| |
| if not mining_state.is_mining or not mining_state.miner_instance: |
| return mining_state.stats |
| |
| try: |
| miner = mining_state.miner_instance |
| |
| |
| mining_time = time.time() - mining_state.start_time |
| time_str = f"{int(mining_time//3600)}h {int((mining_time%3600)//60)}m {int(mining_time%60)}s" |
| |
| |
| if miner.blocks_found > 0: |
| block_alert = f"🎉 FOUND {miner.blocks_found} BLOCK(S)! 🎉" |
| if miner.best_hash: |
| block_alert += f" Hash: {miner.best_hash.hex()[:16]}..." |
| else: |
| progress = (miner.best_hash_difficulty / max(miner.network_difficulty, 1)) * 100 if miner.best_hash_difficulty else 0 |
| block_alert = f"⛏️ Mining... Progress: {progress:.8f}%" |
| |
| |
| mining_state.stats.update({ |
| "status": "Running", |
| "hashrate": f"{miner.current_hashrate/1000:.2f} KH/s", |
| "total_hashes": f"{miner.total_hashes:,}", |
| "blocks_found": str(miner.blocks_found), |
| "best_hash": miner.best_hash.hex()[:32] + "..." if miner.best_hash else "None", |
| "difficulty": f"{miner.best_hash_difficulty:.8f}" if miner.best_hash_difficulty else "0", |
| "network_difficulty": f"{miner.network_difficulty:,.2f}" if hasattr(miner, 'network_difficulty') else "0", |
| "block_alert": block_alert, |
| "mining_time": time_str, |
| "cores_active": f"{len(miner.cores)}" if hasattr(miner, 'cores') else "0" |
| }) |
| |
| return mining_state.stats |
| |
| except Exception as e: |
| logging.error(f"Error getting mining stats: {e}") |
| return { |
| "status": "Error", |
| "hashrate": "0 H/s", |
| "total_hashes": "0", |
| "blocks_found": "0", |
| "best_hash": "Error", |
| "difficulty": "0", |
| "block_alert": f"Error: {str(e)}", |
| "mining_time": "0s", |
| "cores_active": "0" |
| } |
|
|
| @app.get("/get_detailed_stats") |
| async def get_detailed_stats(): |
| """Get detailed mining statistics including per-core info""" |
| global mining_state |
| |
| if not mining_state.is_mining or not mining_state.miner_instance: |
| return {"error": "Mining not active"} |
| |
| try: |
| miner = mining_state.miner_instance |
| detailed_stats = { |
| "overview": { |
| "status": "Running", |
| "total_hashes": miner.total_hashes, |
| "blocks_found": miner.blocks_found, |
| "current_hashrate": miner.current_hashrate, |
| "best_hash_difficulty": miner.best_hash_difficulty, |
| "network_difficulty": miner.network_difficulty, |
| "mining_time": time.time() - mining_state.start_time |
| }, |
| "cores": [] |
| } |
| |
| if hasattr(miner, 'cores'): |
| for core in miner.cores: |
| core_info = { |
| "core_id": core.core_id, |
| "total_hashes": core.total_hashes, |
| "blocks_found": core.blocks_found, |
| "units": [] |
| } |
| |
| for unit in core.units: |
| core_info["units"].append({ |
| "unit_id": unit.unit_id, |
| "total_hashes": unit.total_hashes, |
| "blocks_found": unit.blocks_found |
| }) |
| |
| detailed_stats["cores"].append(core_info) |
| |
| return detailed_stats |
| |
| except Exception as e: |
| return {"error": str(e)} |
|
|
| @app.get("/health") |
| async def health_check(): |
| """Health check endpoint""" |
| return { |
| "status": "healthy", |
| "mining_active": mining_state.is_mining, |
| "timestamp": time.time() |
| } |
|
|
| |
| @app.on_event("startup") |
| async def startup_event(): |
| """Initialize on startup""" |
| logging.info("🚀 Bitcoin Mining Dashboard starting up...") |
|
|
| @app.on_event("shutdown") |
| async def shutdown_event(): |
| """Cleanup on shutdown""" |
| global mining_state |
| if mining_state.is_mining and mining_state.miner_instance: |
| mining_state.miner_instance.mining = False |
| mining_state.is_mining = False |
| logging.info("🛑 Bitcoin Mining Dashboard shutting down...") |
|
|
| if __name__ == "__main__": |
| uvicorn.run( |
| "app:app", |
| host="0.0.0.0", |
| port=7868, |
| reload=False, |
| log_level="info" |
| ) |
