Merge pull request #27 from bitcap-co/feat-dragonball

support dragonball miners

Author: MatthewWertman

resources/app/config.json.default

@@ -12,7 +12,8 @@
           "volcminer": false,
           "goldshell": false,
           "sealminer": false,
-          "elphapex": false
+          "elphapex": false,
+          "dragonball": false
         }
       }
     },

src/ipr.py

@@ -135,6 +135,7 @@ def __init__(self):
         self.listenerConfig.addButton(self.checkListenGoldshell, 5)
         self.listenerConfig.addButton(self.checkListenSealminer, 6)
         self.listenerConfig.addButton(self.checkListenElphapex, 7)
+        self.listenerConfig.addButton(self.checkListenDragonball, 8)
         self.listenerConfig.buttonClicked.connect(self.restart_listen)
         # listener signals
         self.actionIPRStart.clicked.connect(self.start_listen)
@@ -337,6 +338,9 @@ def read_settings(self):
            self.checkListenElphapex.setChecked(
                self.config["general"]["listenFor"]["additional"]["elphapex"]
            )
+           self.checkListenDragonball.setChecked(
+               self.config["general"]["listenFor"]["additional"]["dragonball"]
+           )
 
            # api
            self.lineBitmainPasswd.setText(
@@ -425,6 +429,7 @@ def update_settings(self):
                        "goldshell": self.checkListenGoldshell.isChecked(),
                        "sealminer": self.checkListenSealminer.isChecked(),
                        "elphapex": self.checkListenElphapex.isChecked(),
+                       "dragonball": self.checkListenDragonball.isChecked(),
                    },
                },
            },
@@ -793,7 +798,7 @@ def post_process_result(self, result: List[str]):
         ip, mac, type, sn = result
         logger.debug(f"process_result : got {ip},{mac},{sn},{type} from listener.")
         if type == "bitmain-common":
-            bitmain_common_miners = [self.checkListenAntminer, self.checkListenVolcminer]
+            bitmain_common_miners = [self.checkListenAntminer, self.checkListenVolcminer, self.checkListenDragonball]
             enabled_common_filter = [btn.text().lower() for btn in bitmain_common_miners if btn.isChecked()]
             for miner in bitmain_common_miners:
                 match miner.text().lower():
@@ -811,6 +816,13 @@ def post_process_result(self, result: List[str]):
                         type = "volcminer"
                         self.api_client.close_client()
                         break
+                    case "dragonball":
+                        self.api_client.create_dragonball_client(ip, None)
+                        if not self.api_client.client or not self.api_client.is_dragonball():
+                            continue
+                        type = "dragonball"
+                        self.api_client.close_client()
+                        break
             if type not in enabled_common_filter:
                 logger.warning(f"process_result : recieved miner type {type} outside of filter: {enabled_common_filter}. Ignoring...")
                 self.iprStatus.showMessage(f"Status :: Got miner type: {type.capitalize()} outside of listener configuration.", 8000)
@@ -879,6 +891,11 @@ def locate_miner(self, row: int, col: int):
                         "Status :: Failed to locate miner: VolcMiner is currently not supported.",
                         5000,
                     )
+                case "dragonball":
+                    return self.iprStatus.showMessage(
+                        "Status :: Failed to locate miner: Dragonball is currently not supported.",
+                        5000
+                    )
                 case "iceriver":
                     custom_auth = self.linePbfarmerKey.text()
                 case "whatsminer":

src/mod/api/client.py

@@ -14,6 +14,7 @@
 from mod.api.parser import Parser
 
 from .miners.bitmain import BitmainHTTPClient, BitmainParser
+from .miners.dragonball import DragonballHTTPClient, DragonballParser
 from .miners.elphapex import ElphapexHTTPClient, ElphapexParser
 from .miners.goldshell import GoldshellHTTPClient, GoldshellParser
 from .miners.iceriver import IceriverHTTPClient, IceriverParser
@@ -82,6 +83,12 @@ def create_elphapex_client(self, ip_addr: str, passwd: str) -> None:
         except (FailedConnectionError, AuthenticationError) as err:
             logger.error(err)
 
+    def create_dragonball_client(self, ip_addr: str, passwd: str) -> None:
+        try:
+            self.client = DragonballHTTPClient(ip_addr, passwd)
+        except (FailedConnectionError, AuthenticationError) as err:
+            logger.error(err)
+
     def create_client_from_type(
         self, miner_type: str, ip_addr: str, auth: str, custom_auth: str
     ) -> None:
@@ -100,6 +107,8 @@ def create_client_from_type(
                 self.create_sealminer_client(ip_addr, auth)
             case "elphapex":
                 self.create_elphapex_client(ip_addr, auth)
+            case "dragonball":
+                self.create_dragonball_client(ip_addr, auth)
 
     def locate_miner(self, miner_type: str) -> None:
         self.locate = QTimer(self.parent)
@@ -152,6 +161,12 @@ def is_volcminer(self) -> bool:
             return True
         return False
 
+    def is_dragonball(self) -> bool:
+        miner_type = self.get_common_miner_type()
+        if miner_type and miner_type == "miner":
+            return True
+        return False
+
     def get_target_info(self, parser: Parser) -> Dict[str, str]:
         result = parser.get_target()
         if not self.client:
@@ -186,6 +201,8 @@ def get_target_info(self, parser: Parser) -> Dict[str, str]:
             parser.parse_system_info(sys)
             info = self.client.get_miner_info()
             parser.parse_platform(info)
+        elif isinstance(parser, DragonballParser):
+            parser.parse_system_info(sys)
         return parser.get_target()
 
     def get_target_data_from_type(self, miner_type: str) -> Dict[str, str]:
@@ -204,6 +221,8 @@ def get_target_data_from_type(self, miner_type: str) -> Dict[str, str]:
                 return self.get_target_info(SealminerParser(self.target_info))
             case "elphapex":
                 return self.get_target_info(ElphapexParser(self.target_info))
+            case "dragonball":
+                return self.get_target_info(DragonballParser(self.target_info))
             case _:
                 return self.target_info
 

src/mod/api/miners/dragonball/__init__.py

@@ -0,0 +1,2 @@
+from .client import DragonballHTTPClient
+from .parser import DragonballParser

src/mod/api/miners/dragonball/client.py

@@ -0,0 +1,53 @@
+from string import Template
+from typing import Any, Dict, Optional
+
+import requests
+
+from mod.api import settings
+from mod.api.http import BaseHTTPClient
+
+
+class DragonballHTTPClient(BaseHTTPClient):
+    """Dragonball HTTP Client"""
+
+    def __init__(self, ip_addr: str, passwd: str, port: int = 16666):
+        super().__init__(ip_addr, port)
+        self.url = f"http://{self.ip}:{self.port}/"
+        self.passwds = [passwd, settings.get("default_dragonball_passwd")]
+        self.command_format = Template("cgi-bin/${cmd}.cgi")
+
+        self._initialize_session()
+
+    def _initialize_session(self) -> None:
+        return super()._initialize_session()
+
+    def _authenticate_session(self) -> None:
+        return super()._authenticate_session()
+
+    def run_command(
+        self,
+        method: str,
+        command: str,
+        params: Optional[Dict[str, str]] = None,
+        payload: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None
+    ) -> Any:
+        path = self.command_format.substitute(cmd=command)
+        res = self._do_http(method, path, params=params, payload=payload, data=data)
+        try:
+            resj = res.json()
+        except requests.exceptions.JSONDecodeError:
+            resj = {}
+        return resj
+
+    def get_mac_addr(self) -> str:
+        return super().get_mac_addr()
+
+    def get_system_info(self) -> dict:
+        return self.run_command("GET", "get_system_info")
+
+    def get_blink_status(self) -> bool:
+        return super().get_blink_status()
+
+    def blink(self, enabled: bool) -> None:
+        return super().blink(enabled)

src/mod/api/miners/dragonball/parser.py

@@ -0,0 +1,30 @@
+from typing import Dict, Any
+
+from ...parser import Parser
+
+class DragonballParser(Parser):
+    def __init__(self, target: Dict[str, str]):
+        super().__init__(target)
+
+    def parse_serial(self, obj: Dict[str, Any]) -> None:
+        if "number" in obj:
+            self.target["serial"] = obj["number"]
+
+    def parse_subtype(self, obj: Dict[str, Any]) -> None:
+        if "miner_model" in obj:
+            self.target["subtype"] = obj["miner_model"]
+
+    def parse_algorithm(self, obj: Dict[str, Any]) -> None:
+        return super().parse_algorithm(obj)
+
+    def parse_firmware(self, obj: Dict[str, Any]) -> None:
+        if "swv" in obj:
+            self.target["firmware"] = obj["swv"]
+
+    def parse_platform(self, obj: Dict[str, Any]) -> None:
+        return super().parse_platform(obj)
+
+    def parse_system_info(self, obj: Dict[str, Any]) -> None:
+        self.parse_serial(obj)
+        self.parse_subtype(obj)
+        self.parse_firmware(obj)

src/mod/api/settings/__init__.py

@@ -17,6 +17,7 @@
     "default_volcminer_passwd": "ltc@dog",
     "default_sealminer_passwd": "seal",
     "default_elphapex_passwd": "root",
+    "default_dragonball_passwd": "dragonball",
 }
 
 

src/mod/lm/listenermanager.py

@@ -28,7 +28,7 @@ def append_listener(self, port: int):
     def start_listeners(self, conf: QButtonGroup):
         for listenFor in conf.buttons():
             match conf.id(listenFor):
-                case 1 | 4:  # antminer | volcminer
+                case 1 | 4 | 8:  # antminer | volcminer / dragonball
                     if listenFor.isChecked():
                         self.append_listener(14235)
                 case 2:  # iceriver

src/ui/MainWindow.py

@@ -345,6 +345,12 @@ def setupUi(self, MainWindow):
 
         self.gridLayout.addWidget(self.checkListenSealminer, 0, 2, 1, 1)
 
+        self.checkListenDragonball = QCheckBox(self.groupAdditional)
+        self.checkListenDragonball.setObjectName(u"checkListenDragonball")
+        self.checkListenDragonball.setMaximumSize(QSize(100, 22))
+
+        self.gridLayout.addWidget(self.checkListenDragonball, 1, 1, 1, 1)
+
 
         self.verticalLayout_11.addWidget(self.groupAdditional)
 
@@ -926,6 +932,10 @@ def retranslateUi(self, MainWindow):
         self.checkListenSealminer.setToolTip(QCoreApplication.translate("MainWindow", u"Enable listening for Sealminers", None))
 #endif // QT_CONFIG(tooltip)
         self.checkListenSealminer.setText(QCoreApplication.translate("MainWindow", u"Sealminer", None))
+#if QT_CONFIG(tooltip)
+        self.checkListenDragonball.setToolTip(QCoreApplication.translate("MainWindow", u"Enable listening for Dragonball miners", None))
+#endif // QT_CONFIG(tooltip)
+        self.checkListenDragonball.setText(QCoreApplication.translate("MainWindow", u"Dragonball", None))
         self.configTabs.setTabText(self.configTabs.indexOf(self.tabGeneral), QCoreApplication.translate("MainWindow", u"General", None))
 #if QT_CONFIG(tooltip)
         self.configTabs.setTabToolTip(self.configTabs.indexOf(self.tabGeneral), QCoreApplication.translate("MainWindow", u"General Settings", None))

src/ui/forms/mainwindow.ui

@@ -773,6 +773,22 @@
                               </property>
                              </widget>
                             </item>
+                            <item row="1" column="1">
+                             <widget class="QCheckBox" name="checkListenDragonball">
+                              <property name="maximumSize">
+                               <size>
+                                <width>100</width>
+                                <height>22</height>
+                               </size>
+                              </property>
+                              <property name="toolTip">
+                               <string>Enable listening for Dragonball miners</string>
+                              </property>
+                              <property name="text">
+                               <string>Dragonball</string>
+                              </property>
+                             </widget>
+                            </item>
                            </layout>
                           </widget>
                          </item>