reformatted file structure and reformatted for phones, as well as fixed web sockets for remote devices

tools/web_monitor/miner/__init__.py

@@ -0,0 +1,23 @@
+from fastapi import Request, APIRouter
+
+from tools.web_monitor.template import templates
+from tools.web_monitor.func import get_current_miner_list
+
+from .ws import router as ws_router
+
+router = APIRouter()
+router.include_router(ws_router)
+
+
+@router.get("/")
+def miner(_request: Request, _miner_ip):
+    return get_miner
+
+
+@router.get("/{miner_ip}")
+def get_miner(request: Request, miner_ip):
+    return templates.TemplateResponse("miner.html", {
+        "request": request,
+        "cur_miners": get_current_miner_list(),
+        "miner": miner_ip
+    })

tools/web_monitor/miner/remove.py

@@ -0,0 +1,16 @@
+from fastapi import Request
+from fastapi.responses import RedirectResponse
+
+from tools.web_monitor.app import app
+from tools.web_monitor.func import get_current_miner_list
+
+
+@app.get("/{miner_ip}/remove")
+def get_miner(request: Request, miner_ip):
+    miners = get_current_miner_list()
+    miners.remove(miner_ip)
+    with open("miner_list.txt", "w") as file:
+        for miner_ip in miners:
+            file.write(miner_ip + "\n")
+
+    return RedirectResponse(request.url_for('dashboard'))

tools/web_monitor/miner/ws.py

@@ -0,0 +1,103 @@
+import asyncio
+import datetime
+
+import websockets.exceptions
+from fastapi import WebSocket, WebSocketDisconnect, APIRouter
+
+from tools.web_monitor.miner_factory import miner_factory
+from tools.web_monitor.settings.func import get_current_settings
+
+
+router = APIRouter()
+
+
+@router.websocket("/{miner_ip}/ws")
+async def miner_websocket(websocket: WebSocket, miner_ip):
+    await websocket.accept()
+    settings = get_current_settings()
+    miner_identify_timeout = settings["miner_identify_timeout"]
+    miner_data_timeout = settings["miner_data_timeout"]
+
+    try:
+        while True:
+            try:
+                cur_miner = await asyncio.wait_for(
+                    miner_factory.get_miner(str(miner_ip)),
+                    miner_identify_timeout
+                )
+
+                data = await asyncio.wait_for(
+                    cur_miner.api.multicommand("summary", "fans", "stats"),
+                    miner_data_timeout
+                )
+                print(data)
+                miner_model = await cur_miner.get_model()
+
+                miner_summary = None
+                miner_fans = None
+                if "summary" in data.keys():
+                    miner_summary = data["summary"][0]
+                elif "SUMMARY" in data.keys():
+                    miner_summary = data
+                    miner_fans = {"FANS": []}
+                    for item in ["Fan Speed In", "Fan Speed Out"]:
+                        if item in miner_summary["SUMMARY"][0].keys():
+                            miner_fans["FANS"].append(
+                                {"RPM": miner_summary["SUMMARY"][0][item]})
+
+                if "fans" in data.keys():
+                    miner_fans = data["fans"][0]
+
+                if "stats" in data.keys() and not miner_fans:
+                    miner_stats = data["stats"][0]
+                    miner_fans = {"FANS": []}
+                    for item in ["fan1", "fan2", "fan3", "fan4"]:
+                        if item in miner_stats["STATS"][1].keys():
+                            miner_fans["FANS"].append(
+                                {"RPM": miner_stats["STATS"][1][item]})
+
+                if miner_summary:
+                    if 'MHS av' in miner_summary['SUMMARY'][0].keys():
+                        hashrate = float(format(
+                            round(
+                                miner_summary['SUMMARY'][0]['MHS av'] / 1000000,
+                                2), ".2f"))
+                    elif 'GHS av' in miner_summary['SUMMARY'][0].keys():
+                        hashrate = float(format(
+                            round(miner_summary['SUMMARY'][0]['GHS av'] / 1000,
+                                  2),
+                            ".2f"))
+                    else:
+                        hashrate = 0
+                else:
+                    hashrate = 0
+
+                fan_speeds = []
+                if miner_fans:
+                    for fan in miner_fans["FANS"]:
+                        fan_speeds.append(fan["RPM"])
+
+                while len(fan_speeds) < 4:
+                    fan_speeds.append(0)
+
+                data = {"hashrate": hashrate,
+                        "fans": fan_speeds,
+                        "datetime": datetime.datetime.now().isoformat(),
+                        "model": miner_model}
+                await websocket.send_json(data)
+                print(data)
+                await asyncio.sleep(settings["graph_data_sleep_time"])
+            except asyncio.exceptions.TimeoutError:
+                data = {"error": "The miner is not responding."}
+                await websocket.send_json(data)
+                await asyncio.sleep(.5)
+            except KeyError as e:
+                print(e)
+                data = {
+                    "error": "The miner returned unusable/unsupported data."}
+                await websocket.send_json(data)
+                await asyncio.sleep(.5)
+    except WebSocketDisconnect:
+        print("Websocket disconnected.")
+    except websockets.exceptions.ConnectionClosedOK:
+        pass