Update get_data to us get_some_data sub functions. (#27)
This commit is contained in:
UpstreamData
GitHub
@@ -12,193 +12,202 @@
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from typing import List, Optional
|
||||
|
||||
import asyncssh
|
||||
|
||||
from pyasic.data import HashBoard, MinerData
|
||||
from pyasic.miners._backends import Hiveon # noqa - Ignore access to _module
|
||||
from pyasic.miners._types import T9 # noqa - Ignore access to _module
|
||||
from pyasic.settings import PyasicSettings
|
||||
from pyasic.errors import APIError
|
||||
|
||||
|
||||
class HiveonT9(Hiveon, T9):
|
||||
def __init__(self, ip: str, api_ver: str = "1.0.0") -> None:
|
||||
def __init__(self, ip: str, api_ver: str = "0.0.0") -> None:
|
||||
super().__init__(ip, api_ver=api_ver)
|
||||
self.ip = ip
|
||||
self.pwd = "admin"
|
||||
|
||||
##################################################
|
||||
### DATA GATHERING FUNCTIONS (get_{some_data}) ###
|
||||
##################################################
|
||||
|
||||
async def get_mac(self):
|
||||
mac = (
|
||||
(await self.send_ssh_command("cat /sys/class/net/eth0/address"))
|
||||
.strip()
|
||||
.upper()
|
||||
)
|
||||
return mac
|
||||
try:
|
||||
mac = (
|
||||
(await self.send_ssh_command("cat /sys/class/net/eth0/address"))
|
||||
.strip()
|
||||
.upper()
|
||||
)
|
||||
return mac
|
||||
except (TypeError, ValueError, asyncssh.Error, OSError):
|
||||
pass
|
||||
|
||||
async def get_data(self, allow_warning: bool = False) -> MinerData:
|
||||
"""Get data from the miner.
|
||||
async def get_hashboards(self, api_stats: dict = None) -> List[HashBoard]:
|
||||
board_map = {
|
||||
0: [2, 9, 10],
|
||||
1: [3, 11, 12],
|
||||
2: [4, 13, 14],
|
||||
}
|
||||
hashboards = []
|
||||
|
||||
Returns:
|
||||
A [`MinerData`][pyasic.data.MinerData] instance containing the miners data.
|
||||
"""
|
||||
data = MinerData(
|
||||
ip=str(self.ip),
|
||||
ideal_chips=self.nominal_chips * self.ideal_hashboards,
|
||||
ideal_hashboards=self.ideal_hashboards,
|
||||
)
|
||||
for board in board_map:
|
||||
hashboard = HashBoard(slot=board, expected_chips=self.nominal_chips)
|
||||
hashrate = 0
|
||||
chips = 0
|
||||
for chipset in board_map[board]:
|
||||
if hashboard.chip_temp == -1:
|
||||
try:
|
||||
hashboard.board_temp = api_stats["STATS"][1][f"temp{chipset}"]
|
||||
hashboard.chip_temp = api_stats["STATS"][1][f"temp2_{chipset}"]
|
||||
hashrate += api_stats["STATS"][1][f"chain_rate{chipset}"]
|
||||
chips += api_stats["STATS"][1][f"chain_acn{chipset}"]
|
||||
except (KeyError, IndexError):
|
||||
pass
|
||||
else:
|
||||
hashboard.missing = False
|
||||
hashboard.hashrate = hashrate
|
||||
hashboard.chips = chips
|
||||
hashboards.append(hashboard)
|
||||
|
||||
fan_offset = -1
|
||||
return hashboards
|
||||
|
||||
model = await self.get_model()
|
||||
hostname = await self.get_hostname()
|
||||
mac = await self.get_mac()
|
||||
errors = await self.get_errors()
|
||||
async def get_wattage(self, api_stats: dict = None) -> Optional[int]:
|
||||
if not api_stats:
|
||||
try:
|
||||
api_stats = await self.api.stats()
|
||||
except APIError:
|
||||
pass
|
||||
|
||||
if model:
|
||||
data.model = model
|
||||
if api_stats:
|
||||
boards = api_stats.get("STATS")
|
||||
try:
|
||||
wattage_raw = boards[1]["chain_power"]
|
||||
except (KeyError, IndexError):
|
||||
pass
|
||||
else:
|
||||
# parse wattage position out of raw data
|
||||
return round(float(wattage_raw.split(" ")[0]))
|
||||
|
||||
if hostname:
|
||||
data.hostname = hostname
|
||||
async def get_env_temp(self, api_stats: dict = None) -> Optional[float]:
|
||||
env_temp_list = []
|
||||
board_map = {
|
||||
0: [2, 9, 10],
|
||||
1: [3, 11, 12],
|
||||
2: [4, 13, 14],
|
||||
}
|
||||
if not api_stats:
|
||||
try:
|
||||
api_stats = await self.api.stats()
|
||||
except APIError:
|
||||
pass
|
||||
if api_stats:
|
||||
for board in board_map.values():
|
||||
for chipset in board:
|
||||
try:
|
||||
env_temp = api_stats["STATS"][1][f"temp3_{chipset}"]
|
||||
if not env_temp == 0:
|
||||
env_temp_list.append(int(env_temp))
|
||||
except (KeyError, IndexError):
|
||||
pass
|
||||
|
||||
if mac:
|
||||
data.mac = mac
|
||||
|
||||
if errors:
|
||||
for error in errors:
|
||||
data.errors.append(error)
|
||||
|
||||
data.fault_light = await self.check_light()
|
||||
if not env_temp_list == []:
|
||||
return round(float(sum(env_temp_list) / len(env_temp_list)), 2)
|
||||
|
||||
async def _get_data(self, allow_warning: bool) -> dict:
|
||||
miner_data = None
|
||||
for i in range(PyasicSettings().miner_get_data_retries):
|
||||
miner_data = await self.api.multicommand(
|
||||
"summary", "pools", "stats", allow_warning=allow_warning
|
||||
)
|
||||
try:
|
||||
miner_data = await self.api.multicommand(
|
||||
"summary",
|
||||
"pools",
|
||||
"version",
|
||||
"devdetails",
|
||||
"stats",
|
||||
allow_warning=allow_warning,
|
||||
)
|
||||
except APIError:
|
||||
pass
|
||||
if miner_data:
|
||||
break
|
||||
if miner_data:
|
||||
summary = miner_data.get("summary")
|
||||
if summary:
|
||||
summary = summary[0]
|
||||
pools = miner_data.get("pools")
|
||||
if pools:
|
||||
pools = pools[0]
|
||||
version = miner_data.get("version")
|
||||
if version:
|
||||
version = version[0]
|
||||
devdetails = miner_data.get("devdetails")
|
||||
if devdetails:
|
||||
devdetails = devdetails[0]
|
||||
stats = miner_data.get("stats")
|
||||
if stats:
|
||||
stats = stats[0]
|
||||
else:
|
||||
summary, pools, devdetails, version, stats = (None for _ in range(5))
|
||||
|
||||
if not miner_data:
|
||||
return data
|
||||
data = { # noqa - Ignore dictionary could be re-written
|
||||
# ip - Done at start
|
||||
# datetime - Done auto
|
||||
"mac": await self.get_mac(),
|
||||
"model": await self.get_model(api_devdetails=devdetails),
|
||||
# make - Done at start
|
||||
"api_ver": None, # - Done at end
|
||||
"fw_ver": None, # - Done at end
|
||||
"hostname": await self.get_hostname(),
|
||||
"hashrate": await self.get_hashrate(api_summary=summary),
|
||||
"hashboards": await self.get_hashboards(api_stats=stats),
|
||||
# ideal_hashboards - Done at start
|
||||
"env_temp": await self.get_env_temp(api_stats=stats),
|
||||
"wattage": await self.get_wattage(api_stats=stats),
|
||||
"wattage_limit": await self.get_wattage_limit(),
|
||||
"fan_1": None, # - Done at end
|
||||
"fan_2": None, # - Done at end
|
||||
"fan_3": None, # - Done at end
|
||||
"fan_4": None, # - Done at end
|
||||
"fan_psu": None, # - Done at end
|
||||
# ideal_chips - Done at start
|
||||
"pool_split": None, # - Done at end
|
||||
"pool_1_url": None, # - Done at end
|
||||
"pool_1_user": None, # - Done at end
|
||||
"pool_2_url": None, # - Done at end
|
||||
"pool_2_user": None, # - Done at end
|
||||
"errors": await self.get_errors(),
|
||||
"fault_light": await self.get_fault_light(),
|
||||
}
|
||||
|
||||
summary = miner_data.get("summary")[0]
|
||||
pools = miner_data.get("pools")[0]
|
||||
stats = miner_data.get("stats")[0]
|
||||
data["api_ver"], data["fw_ver"] = await self.get_version(api_version=version)
|
||||
fan_data = await self.get_fans()
|
||||
|
||||
if summary:
|
||||
hr = summary.get("SUMMARY")
|
||||
if hr:
|
||||
if len(hr) > 0:
|
||||
hr = hr[0].get("GHS 1m")
|
||||
if hr:
|
||||
data.hashrate = round(hr / 1000, 2)
|
||||
if fan_data:
|
||||
data["fan_1"] = fan_data.fan_speeds.fan_1 # noqa
|
||||
data["fan_2"] = fan_data.fan_speeds.fan_2 # noqa
|
||||
data["fan_3"] = fan_data.fan_speeds.fan_3 # noqa
|
||||
data["fan_4"] = fan_data.fan_speeds.fan_4 # noqa
|
||||
|
||||
if stats:
|
||||
boards = stats.get("STATS")
|
||||
if boards:
|
||||
if len(boards) > 0:
|
||||
if "chain_power" in boards[1].keys():
|
||||
data.wattage = round(
|
||||
float(boards[1]["chain_power"].split(" ")[0])
|
||||
)
|
||||
data["fan_psu"] = fan_data.psu_fan_speeds.psu_fan # noqa
|
||||
|
||||
board_map = {
|
||||
0: [2, 9, 10],
|
||||
1: [3, 11, 12],
|
||||
2: [4, 13, 14],
|
||||
}
|
||||
pools_data = await self.get_pools(api_pools=pools)
|
||||
|
||||
env_temp_list = []
|
||||
|
||||
for board in board_map.keys():
|
||||
hashboard = HashBoard(
|
||||
slot=board, expected_chips=self.nominal_chips
|
||||
)
|
||||
chips = 0
|
||||
hashrate = 0
|
||||
chip_temp = 0
|
||||
board_temp = 0
|
||||
for chipset in board_map[board]:
|
||||
if chip_temp == 0:
|
||||
if f"temp{chipset}" in boards[1].keys():
|
||||
board_temp = boards[1][f"temp{chipset}"]
|
||||
chip_temp = boards[1][f"temp2_{chipset}"]
|
||||
if f"temp3_{chipset}" in boards[1].keys():
|
||||
env_temp = boards[1][f"temp3_{chipset}"]
|
||||
if not env_temp == 0:
|
||||
env_temp_list.append(int(env_temp))
|
||||
|
||||
hashrate += boards[1][f"chain_rate{chipset}"]
|
||||
chips += boards[1][f"chain_acn{chipset}"]
|
||||
hashboard.hashrate = hashrate
|
||||
hashboard.chips = chips
|
||||
hashboard.temp = board_temp
|
||||
hashboard.chip_temp = chip_temp
|
||||
hashboard.missing = True
|
||||
if chips and chips > 0:
|
||||
hashboard.missing = False
|
||||
data.hashboards.append(hashboard)
|
||||
|
||||
if not env_temp_list == []:
|
||||
data.env_temp = sum(env_temp_list) / len(env_temp_list)
|
||||
|
||||
if stats:
|
||||
temp = stats.get("STATS")
|
||||
if temp:
|
||||
if len(temp) > 1:
|
||||
for fan_num in range(1, 8, 4):
|
||||
for _f_num in range(4):
|
||||
f = temp[1].get(f"fan{fan_num + _f_num}")
|
||||
if f and not f == 0 and fan_offset == -1:
|
||||
fan_offset = fan_num
|
||||
if fan_offset == -1:
|
||||
fan_offset = 1
|
||||
for fan in range(self.fan_count):
|
||||
setattr(
|
||||
data, f"fan_{fan + 1}", temp[1].get(f"fan{fan_offset+fan}")
|
||||
)
|
||||
|
||||
if pools:
|
||||
pool_1 = None
|
||||
pool_2 = None
|
||||
pool_1_user = None
|
||||
pool_2_user = None
|
||||
pool_1_quota = 1
|
||||
pool_2_quota = 1
|
||||
quota = 0
|
||||
for pool in pools.get("POOLS"):
|
||||
if not pool.get("User") == "*":
|
||||
if not pool_1_user:
|
||||
pool_1_user = pool.get("User")
|
||||
pool_1 = pool["URL"]
|
||||
pool_1_quota = pool["Quota"]
|
||||
elif not pool_2_user:
|
||||
pool_2_user = pool.get("User")
|
||||
pool_2 = pool["URL"]
|
||||
pool_2_quota = pool["Quota"]
|
||||
if not pool.get("User") == pool_1_user:
|
||||
if not pool_2_user == pool.get("User"):
|
||||
pool_2_user = pool.get("User")
|
||||
pool_2 = pool["URL"]
|
||||
pool_2_quota = pool["Quota"]
|
||||
if pool_2_user and not pool_2_user == pool_1_user:
|
||||
quota = f"{pool_1_quota}/{pool_2_quota}"
|
||||
|
||||
if pool_1:
|
||||
pool_1 = pool_1.replace("stratum+tcp://", "").replace(
|
||||
"stratum2+tcp://", ""
|
||||
)
|
||||
data.pool_1_url = pool_1
|
||||
|
||||
if pool_1_user:
|
||||
data.pool_1_user = pool_1_user
|
||||
|
||||
if pool_2:
|
||||
pool_2 = pool_2.replace("stratum+tcp://", "").replace(
|
||||
"stratum2+tcp://", ""
|
||||
)
|
||||
data.pool_2_url = pool_2
|
||||
|
||||
if pool_2_user:
|
||||
data.pool_2_user = pool_2_user
|
||||
|
||||
if quota:
|
||||
data.pool_split = str(quota)
|
||||
if pools_data:
|
||||
data["pool_1_url"] = pools_data[0]["pool_1_url"]
|
||||
data["pool_1_user"] = pools_data[0]["pool_1_user"]
|
||||
if len(pools_data) > 1:
|
||||
data["pool_2_url"] = pools_data[1]["pool_2_url"]
|
||||
data["pool_2_user"] = pools_data[1]["pool_2_user"]
|
||||
data[
|
||||
"pool_split"
|
||||
] = f"{pools_data[0]['quota']}/{pools_data[1]['quota']}"
|
||||
else:
|
||||
try:
|
||||
data["pool_2_url"] = pools_data[0]["pool_2_url"]
|
||||
data["pool_2_user"] = pools_data[0]["pool_2_user"]
|
||||
data["quota"] = "0"
|
||||
except KeyError:
|
||||
pass
|
||||
|
||||
return data
|
||||
|
||||
Reference in New Issue
Block a user