def get_num_of_all_rigs(panel_name=None):
"""Get number of all available rigs
if poll_name is not give will count for all polls
"""
all_rigs = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
all_rigs += 1
return all_rigs
def get_num_of_alive_rigs(panel_name=None):
"""Get number of all rigs using APP_SETTINGS_PERIOD_TO_LIVE to define aliveness=)
if poll_name is notFd= give will count for all polls
"""
alive_rigs = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'hash': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if all_min_from_td(dif) <= int(Config.APP_SETTINGS_PERIOD_TO_LIVE) and days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
total_hash = re.findall(r"[-+]?\d*\.\d+|\d+", dict_res['hash'])
if total_hash:
if float(total_hash[0]) != 0.0:
alive_rigs += 1
a = 2
return alive_rigs
def get_num_and_list_of_alive_panels():
"""Get alive """
alive_pools = 0
list_of_alive_polls = []
all_coll_names = mongo.db.collection_names()
is_found_for_this_pool = {}
for host in all_coll_names:
is_found_for_this_pool[str(host)] = False
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
if not is_found_for_this_pool[str(collection_name)]:
cursor = collection.find({'hostname': str(host)}, {'hash': 1, 'received_at': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days <= int(Config.APP_SETTINGS_PERIOD_TO_HIDE_PANEL):
alive_pools += 1
list_of_alive_polls.append(str(collection_name))
is_found_for_this_pool[str(collection_name)] = True
return alive_pools, list_of_alive_polls
def get_dict_of_bioses(panel_name=None):
dict_of_bioses = {}
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct(
'hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'bioses': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res.get("bioses"):
bioses_info = dict_res.get("bioses")
bioses_list = bioses_info.strip().split(' ')
for bios in bioses_list:
if bios not in dict_of_bioses:
dict_of_bioses[bios] = 1
else:
dict_of_bioses[bios] += 1
return dict_of_bioses
def get_num_of_gpus(panel_name=None):
"""Number of GPUs
if poll_name is not give will count for all polls
"""
all_gpus = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'gpus': 1, 'received_at': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
gpus_string = dict_res['gpus']
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
res_list = [int(s) for s in re.findall(r'\d+', gpus_string)]
if res_list:
num_of_gpus = res_list[0]
all_gpus += num_of_gpus
return all_gpus
def get_num_of_rigs_under_attack(panel_name=None):
num_of_rigs_under_attack = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'hash': 1, "rx_kbps": 1, "tx_kbps": 1}) \
.sort('received _at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
rx_kbps = re.findall(r"[-+]?\d*\.\d+|\d+", dict_res['rx_kbps'])
tx_kbps = re.findall(r"[-+]?\d*\.\d+|\d+", dict_res['tx_kbps'])
if rx_kbps:
if float(rx_kbps[0]) >= Config.APP_RX_BAD_VALUE or float(tx_kbps[0]) >= Config.APP_TX_BAD_VALUE:
num_of_rigs_under_attack += 1
return num_of_rigs_under_attack
def get_list_of_hostnames_with_crashed_gpus(panel_name):
hosts_list = []
all_coll_names = mongo.db.collection_names()
if panel_name in all_coll_names:
collection = mongo.db[str(panel_name)]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'gpus': 1, 'received_at': 1, 'miner_hashes': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if all_min_from_td(dif) <= int(Config.APP_SETTINGS_PERIOD_TO_LIVE) and days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res['miner_hashes'] and dict_res['miner_hashes'] is not None:
hashes = dict_res['miner_hashes']
stripped = hashes.strip().split(' ')
if len(stripped) == 0:
gpu_hash = float(hashes)
if gpu_hash == 0.0:
hosts_list.append(host)
elif len(stripped) >= 2:
for _hash in stripped:
if (float(_hash)) == 0.0:
hosts_list.append(host)
return hosts_list
def get_list_of_offline_rigs(panel_name):
offline_rigs_list = []
all_coll_names = mongo.db.collection_names()
if panel_name in all_coll_names:
collection = mongo.db[str(panel_name)]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'hash': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if all_min_from_td(dif) > int(Config.APP_SETTINGS_PERIOD_TO_LIVE) and days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
offline_rigs_list.append(host)
total_hash = re.findall(r"[-+]?\d*\.\d+|\d+", dict_res['hash'])
if total_hash:
if float(total_hash[0]) == 0.0:
if host not in offline_rigs_list:
offline_rigs_list.append(host)
a = 2
return offline_rigs_list
def get_total_hashrate(panel_name=None):
"""Get total hashrate
if poll_name is not given will count for all polls
"""
total_hashrate = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'hash': 1, 'received_at': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if all_min_from_td(dif) <= int(Config.APP_SETTINGS_PERIOD_TO_LIVE) and days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res['hash'] and dict_res['hash'] is not None:
total_hashrate += float(dict_res['hash'])
total_hashrate = round(total_hashrate, 3)
return total_hashrate
def get_list_of_not_hidden_rigs(panel_name):
"""Get list of all rigs using APP_SETTINGS_PERIOD_TO_LIVE to define aliveness=)
if poll_name is not give will count for all polls
"""
alive_rigs_list = []
all_coll_names = mongo.db.collection_names()
if panel_name in all_coll_names:
collection = mongo.db[str(panel_name)]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
alive_rigs_list.append(host)
return alive_rigs_list
def get_dict_of_ip_info_all():
dict_of_ip_info = {'Working local configuration': []}
all_coll_names = mongo.db.collection_names()
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname')
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'send_remote': 1, "config_status": 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
config_status = dict_res.get('config_status')
send_remote = dict_res.get('send_remote')
if not send_remote and config_status == 'singlerig':
dict_of_ip_info['Working local configuration'].append(
host)
else:
if not dict_of_ip_info.get(send_remote):
dict_of_ip_info[send_remote] = []
dict_of_ip_info[send_remote].append(host)
else:
dict_of_ip_info[send_remote].append(host)
return dict_of_ip_info
def get_dual_miners_list(panel_name=None):
dual_miners_rigs = []
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'dualminer_status': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(
Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res.get("dualminer_status"):
dual_miner_status = dict_res.get("dualminer_status")
if dual_miner_status == "enabled":
dual_miners_rigs.append(host)
return dual_miners_rigs
def get_unique_poll_info_list(panel_name=None):
ret_list = []
unique_pool_info_fields = []
dict_of_rigs_with_unique_pool_info = {}
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname')
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'pool_info': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res.get("pool_info"):
pool_info_str = dict_res.get("pool_info")
if dict_of_rigs_with_unique_pool_info.get(
pool_info_str) is None:
dict_of_rigs_with_unique_pool_info[
pool_info_str] = []
dict_of_rigs_with_unique_pool_info[
pool_info_str].append(host)
else:
dict_of_rigs_with_unique_pool_info[
pool_info_str].append(host)
if pool_info_str not in unique_pool_info_fields:
unique_pool_info_fields.append(pool_info_str)
# pool_info_str_split = pool_info_str.strip().split('\n')
try:
if unique_pool_info_fields:
for pool_info_string in unique_pool_info_fields:
pool_info_str_split = pool_info_string.strip().split('\n')
res_dict = {}
if dict_of_rigs_with_unique_pool_info.get(pool_info_string):
res_dict["hosts"] = dict_of_rigs_with_unique_pool_info[
pool_info_string]
res_dict["amount"] = len(
dict_of_rigs_with_unique_pool_info[pool_info_string])
for _str in pool_info_str_split:
two_str = _str.strip().split(' ')
res_dict[two_str[0]] = two_str[1]
ret_list.append(res_dict)
except Exception as e:
print(e)
print("Exception get_list_of_dict_pool_info")
return []
return ret_list
def get_dict_of_drive_names(panel_name=None):
dict_of_drives = {}
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct(
'hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'received_at': 1, 'drive_name': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res.get("drive_name"):
mobo_str = dict_res.get("drive_name")
if "INTEL" in mobo_str:
mobo_list = mobo_str.strip().split(' ')
if len(mobo_list) >= 3:
mobo_str = "SSD"
if "ADATA" in mobo_str:
mobo_str = "SSD"
if "SAMSUNG" in mobo_str:
mobo_str = "SSD"
if "SanDisk SDSSDA120G" in mobo_str:
mobo_str = "SSD"
if "PH4-CE120" in mobo_str:
mobo_str = "SSD"
# Flash Drives
if "Ultra" in mobo_str:
mobo_str = "Flash Drive"
if "x800m" in mobo_str:
mobo_str = "Flash Drive"
if "Cruzer" in mobo_str:
mobo_str = "Flash Drive"
if mobo_str not in dict_of_drives:
dict_of_drives[mobo_str] = 1
else:
dict_of_drives[mobo_str] += 1
return dict_of_drives
def get_average_gpu_temperature(panel_name=None):
"""Get average temp of GPUs
if poll_name is not give will count for all polls
"""
all_temp = 0
number_of_gpus = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'temp': 1, 'received_at': 1, 'miner_hashes': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if all_min_from_td(dif) <= int(Config.APP_SETTINGS_PERIOD_TO_LIVE) \
and days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res['temp'] and dict_res['temp'] is not None:
temps = dict_res['temp']
stripped = temps.strip().split(' ')
if len(stripped) == 1:
gpu_temp = float(temps)
if gpu_temp > 0.0 and gpu_temp < 120.00:
all_temp += gpu_temp
number_of_gpus += 1
elif len(stripped) >= 2:
for temp in stripped:
if (float(temp)) > 0.0 and (float(temp)) < 120.00:
all_temp += float(temp)
number_of_gpus += 1
if all_temp == 0 or number_of_gpus == 0:
return 0
else:
av_temp = all_temp / number_of_gpus
import math
av_temp = math.ceil(av_temp * 100) / 100
return av_temp
def get_gpus_temp_info_dict(panel_name=None):
gpu_temp_info = {}
gpu_temp_info["COLD"] = 0
gpu_temp_info["OK"] = 0
gpu_temp_info["YELLOW"] = 0
gpu_temp_info["RED"] = 0
if panel_name is None:
all_coll_names = mongo.db.collection_names()
else:
all_coll_names = [str(panel_name)]
for collection_name in all_coll_names:
collection = mongo.db[collection_name]
# find_one returns dict, find returns cursor
unique_hostnames = collection.find({}).distinct('hostname') # Uniquie Hostnames = Rigs
for host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'temp': 1, 'received_at': 1, 'miner_hashes': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if all_min_from_td(dif) <= int(Config.APP_SETTINGS_PERIOD_TO_LIVE) \
and days < int(Config.APP_SETTINGS_PERIOD_TO_HIDE_RIG):
if dict_res['temp'] and dict_res['temp'] is not None:
temps = dict_res['temp']
split = re.findall(r"[-+]?\d*\.\d+|\d+", temps)
temps_list = [float(x) for x in split]
if temps_list:
for temp in temps_list:
if temp > 0.00 and temp <= 40.00:
gpu_temp_info["COLD"] += 1
if temp > 40.00 and temp < 60.00:
gpu_temp_info["OK"] += 1
if temp >= 60.00 and temp < 80.00:
gpu_temp_info["YELLOW"] += 1
if temp >= 80.00 and temp < 120.00:
gpu_temp_info["RED"] += 1
return gpu_temp_info
def retrieve_rig_stat_optimized(hostname, panel_name):
"""Retrieve info from DB to show in table
"""
return_dict = {}
return_dict['miner'] = ""
return_dict['status'] = ""
return_dict['flags_status'] = []
return_dict['gpu_temps'] = []
return_dict['gpus'] = 0
return_dict['gpus_alive'] = 0
return_dict['miner_hashes'] = []
return_dict['last_request'] = 0
return_dict['is_off'] = True
return_dict['ip_address'] = ""
return_dict['last_request'] = None
return_dict['is_off'] = True
return_dict['miner_hashes'] = []
return_dict['uptime'] = None
return_dict['cpu_temp'] = 0
return_dict['rx_kbps'] = 0.0
return_dict['tx_kbps'] = 0.0
return_dict['total_hashrate'] = 0.0
return_dict['powertune'] = []
# Fans
return_dict['fanrpm'] = []
return_dict['fanpercent'] = []
return_dict['core'] = []
return_dict['default_core'] = []
return_dict['mem'] = []
return_dict['number'] = 0
return_dict['config_status'] = ""
return_dict['send_remote'] = ""
return_dict['config_s'] = ""
return_dict['mem_states'] = []
return_dict['hash'] = 0.0
# return_dict['models'] = []
if LocationFieldPanel.query.filter_by(hostname=hostname).first() is not None:
loc = LocationFieldPanel.query.filter_by(hostname=hostname).first()
return_dict['number'] = loc.number
collection = mongo.db[str(panel_name)]
# find_one returns dict, find returns cursor
second_parameter = {'ip': 1, 'temp': 1, 'status': 1,
'miner': 1, 'gpus': 1,
'received_at': 1, 'miner_hashes': 1,
'defunct': 1, 'overheat': 1,
'adl_error': 1, 'autorebooted': 1,
'updating': 1, 'throttled': 1,
"uptime": 1, "cpu_temp": 1,
"rx_kbps": 1, "tx_kbps": 1,
"powertune": 1,
'fanpercent': 1, 'fanrpm': 1,
'default_core': 1, 'core': 1,
'mem': 1, "config_status": 1,
"send_remote": 1, 'memstates': 1,
'hash': 1, "miner_version": 1}
cursor = collection.find({'hostname': str(hostname)}, second_parameter) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
mongo_dict = res[0]
return_dict['miner'] = mongo_dict.get('miner')
return_dict['status'] = mongo_dict.get('status')
return_dict['ip_address'] = mongo_dict.get('ip')
return_dict['miner_version'] = mongo_dict.get('miner_version')
# if mongo_dict.get("models"):
# models_string = mongo_dict.get("models")
# if models_string:
# models_list = models_string.strip().split('\n')
# if models_list:
# return_dict['models'] = models_list
return_dict['flags_status'] = list_from_all_status_flags(in_dict=mongo_dict)
total_hash = re.findall(r"[-+]?\d*\.\d+|\d+", mongo_dict['hash'])
if total_hash:
if float(total_hash[0]) != 0.0:
miner_hashes_list = re.findall(r"[-+]?\d*\.\d+|\d+", mongo_dict['miner_hashes'])
return_dict['miner_hashes'] = [float(x) for x in miner_hashes_list]
if return_dict['miner_hashes']:
for idx, hashrate in enumerate(return_dict['miner_hashes']):
if hashrate == 0.0:
if 'CRASHED GPU {}'.format(idx + 1) not in return_dict['flags_status']:
return_dict['flags_status'].append('CRASHED GPU {}'.format(idx + 1))
return_dict['total_hashrate'] += hashrate
return_dict['total_hashrate'] = round(return_dict['total_hashrate'], 3)
# mem_states_string = mongo_dict['memstates']
# res_list_mem_states = [int(s) for s in re.findall(r'\d+', mem_states_string)]
# if res_list_mem_states:
# for idx, mem_state in enumerate(res_list_mem_states):
# if mem_state == 0:
# if 'CRASHED GPU {}'.format(idx + 1) not in return_dict['flags_status']:
# return_dict['flags_status'].append('CRASHED GPU {}'.format(idx + 1))
#
else:
return_dict['flags_status'].append('CRASHED RIG')
mem_string = mongo_dict['mem']
res_list = [int(s) for s in re.findall(r'\d+', mem_string)]
if res_list:
return_dict['mem'] = [int(x) for x in res_list]
# CONFIG STATUS
return_dict['config_status'] = mongo_dict.get('config_status')
return_dict['send_remote'] = mongo_dict.get('send_remote')
if not return_dict['send_remote'] and return_dict['config_status'] == 'singlerig':
return_dict['config_s'] = "L"
else:
return_dict['config_s'] = "R"
days, hours, minutes, sec = days_hours_minutes_from_sec(int(mongo_dict.get('uptime')))
return_dict['uptime'] = "".join("{}D {}H {}M {}S").format(days, hours, minutes, sec)
if mongo_dict.get('rx_kbps'):
return_dict['rx_kbps'] = mongo_dict.get('rx_kbps')
if mongo_dict.get('tx_kbps'):
return_dict['tx_kbps'] = mongo_dict.get('tx_kbps')
if float(return_dict['rx_kbps']) >= Config.APP_RX_BAD_VALUE or float(
return_dict['tx_kbps']) >= Config.APP_TX_BAD_VALUE:
return_dict['flags_status'].append('RX/TX TOO HIGH')
res_list_cpu = [int(s) for s in re.findall(r'\d+', mongo_dict.get('cpu_temp'))]
if res_list_cpu:
return_dict['cpu_temp'] = int(res_list_cpu[0])
# result_dict['temp'] = result_dict['temp'].replace("'","")
gpu_temps = re.findall(r"[-+]?\d*\.\d+|\d+", mongo_dict['temp'])
# gpu_temps = result_dict['temp'].strip().split(' ')
if gpu_temps:
return_dict['gpu_temps'] = [float(x) for x in gpu_temps]
# if return_dict['gpu_temps']:
# for temp in return_dict['gpu_temps']:
# if temp > int(Config.APP_SETTINGS_OVERHEAT):
# if 'OVERHEAT' not in return_dict['flags_status']:
# return_dict['flags_status'].append('OVERHEAT')
# POWERTUNE
pwrtune = re.findall(r"[-+]?\d*\.\d+|\d+", mongo_dict['powertune'])
# gpu_temps = result_dict['temp'].strip().split(' ')
if pwrtune:
return_dict['powertune'] = [float(x) for x in pwrtune]
gpus_string = mongo_dict['gpus']
res_list = [int(s) for s in re.findall(r'\d+', gpus_string)]
if res_list:
return_dict['gpus'] = res_list[0]
## FANS
fanrpm_string = mongo_dict['fanrpm']
res_list = [int(s) for s in re.findall(r'\d+', fanrpm_string)]
if res_list:
return_dict['fanrpm'] = [int(x) for x in res_list]
fanrpm_string = mongo_dict['fanpercent']
res_list = [int(s) for s in re.findall(r'\d+', fanrpm_string)]
if res_list:
return_dict['fanpercent'] = [int(x) for x in res_list]
# Core
core_string = mongo_dict['core']
res_list = [int(s) for s in re.findall(r'\d+', core_string)]
if res_list:
return_dict['core'] = [int(x) for x in res_list]
core_default_string = mongo_dict['default_core']
res_list = [int(s) for s in re.findall(r'\d+', core_default_string)]
if res_list:
return_dict['default_core'] = [int(x) for x in res_list]
received_at_utc = mongo_dict['received_at']
received_at_utc_local = curr_time_non_naive(received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
return_dict['last_request'] = all_min_from_td(dif)
if all_min_from_td(dif) <= int(Config.APP_SETTINGS_PERIOD_TO_LIVE):
return_dict['is_off'] = False
if mongo_dict['miner_hashes'] and mongo_dict['miner_hashes'] is not None:
# hashes = result_dict['miner_hashes']
miner_hashes_list = re.findall(r"[-+]?\d*\.\d+|\d+", mongo_dict['miner_hashes'])
if miner_hashes_list:
for _hash in return_dict['miner_hashes']:
if _hash > 0.0:
return_dict['gpus_alive'] += 1
return return_dict
def execute_commands_on_multiple_rigs(self,
panel_name=None,
hosts=None,
commands=None,
username=None,
password=None,
miner_name=None,
new_password=None,
custom_command=None):
all_coll_names = mongo.db.collection_names()
ips_to_execute = {}
if panel_name in all_coll_names:
collection = mongo.db[panel_name]
unique_hostnames = collection.find({}).distinct('hostname')
for host in hosts:
if host in unique_hostnames:
cursor = collection.find({'hostname': str(host)}, {'ip': 1, 'received_at': 1}) \
.sort('received_at', flask_pymongo.DESCENDING) \
.limit(1)
if cursor.count() > 0:
res = list(cursor)
dict_res = res[0]
ip = dict_res.get("ip")
received_at_utc = dict_res['received_at']
received_at_utc_local = curr_time_non_naive(
received_at_utc)
now_local = curr_time_naive(datetime.datetime.utcnow())
dif = now_local - received_at_utc_local
days, hours, minutes = days_hours_minutes(dif)
if days == 0 and hours == 0 and minutes <= 2:
ips_to_execute[host] = ip
if ips_to_execute:
executing_tasks = {}
ips = 0
for host in ips_to_execute:
# REBOOT
if commands.get("clear_thermals"):
task = execute_rig_clear_thermals_and_reboot.apply_async(
args=[ips_to_execute[host], username, password],
expire=240,
queue="ssh_tasks")
# reboot = execute_rig_reboot.apply_async(countdown=5,
# args=[ips_to_execute[host], username, password],
# expire=60)
# executing_tasks[host] = task
elif commands.get("put_conf"):
task = execute_rig_putconf_and_reboot.apply_async(
args=[ips_to_execute[host], username, password],
expire=240,
queue="ssh_tasks")
# reboot = execute_rig_reboot.apply_async(countdown=5,
# args=[ips_to_execute[host], username, password],
# expire=60)
elif commands["reboot"]:
reboot = execute_rig_reboot.apply_async(
countdown=2,
args=[ips_to_execute[host], username, password],
expire=240,
queue="ssh_tasks")
elif commands["update_miners"]:
update_miners = execute_rig_update_miners.apply_async(
countdown=2,
args=[ips_to_execute[host], username, password],
expire=240,
queue="ssh_tasks")
elif commands["allow_command"]:
allow_command = execute_rig_allow_command.apply_async(
countdown=2,
args=[ips_to_execute[host], username, password],
expire=240,
queue="ssh_tasks")
elif commands["update_miner_with_name"]:
update_miner_with_name = execute_rig_update_miner_with_name.apply_async(
countdown=2,
args=[
ips_to_execute[host], username, password,
miner_name
],
expire=240,
queue="ssh_tasks")
elif commands["change_password"]:
change_pass = execute_change_password.apply_async(
countdown=2,
args=[
ips_to_execute[host], username, password,
new_password
],
expire=300,
queue="ssh_tasks")
elif commands["execute_custom_command"]:
execute_custom = execute_custom_command.apply_async(
countdown=2,
args=[
ips_to_execute[host], username, password,
custom_command
],
expire=300,
queue="ssh_tasks")