def test_miner_no_update(self):
miner = Miner('test')
miner.ipaddress = 'ip1'
minerupdate = Miner('test')
minerupdate.ipaddress = None
miner.updatefrom(minerupdate)
self.assertTrue(miner.ipaddress != minerupdate.ipaddress)
def test_miner_update_port(self):
miner = Miner('test')
miner.port = 'port1'
minerupdate = Miner('test')
minerupdate.port = 'port2'
miner.updatefrom(minerupdate)
self.assertTrue(miner.port == minerupdate.port)
def test_miner_can_monitor(self):
miner = Miner("test", '', '', '', '', '', '', '', '')
self.assertFalse(miner.can_monitor())
miner.ipaddress = '123.123.123.123'
self.assertFalse(miner.can_monitor())
miner.port = '4028'
self.assertTrue(miner.can_monitor())
def test_miner_status_no_you_cant(self):
miner = Miner('test')
def set_status_test():
miner.status = 'you can be anyting'
self.assertRaises(ValueError, set_status_test)
def make_minermessage(self, data):
'''reconstitute a minermessage'''
miner = None
command = None
minerstats = None
minerpool = None
if 'miner' in data:
#miner comes in as dict instead of entity when there is an error in the schema
if isinstance(data['miner'], Miner):
miner = data['miner']
else:
miner = Miner(**data['miner'])
if 'command' in data:
if isinstance(data['command'], MinerCommand):
command = data['command']
else:
command = MinerCommand(**data['command'])
if 'minerstats' in data:
#minerstats = MinerStatistics(Miner=miner,**data['minerstats'])
minerstats = data['minerstats']
if 'minerpool' in data:
#minerpool = MinerCurrentPool(Miner=miner, **data['minerpool'])
minerpool = data['minerpool']
entity = MinerMessage(miner, command, minerstats, minerpool)
return entity
def test_minerserialization(self):
sch = MinerSchema()
miner = Miner('test')
miner.status = MinerStatus.Offline
miner.status = MinerStatus.Online
miner.minerinfo = MinerInfo('Antminer S9', '123')
miner.minerpool = MinerCurrentPool(miner,
'test pool',
'test worker',
allpools={})
miner.minerpool.poolname = 'unittest'
miner.minerstats = MinerStatistics(miner, datetime.datetime.utcnow(),
0, 1, 0, 99, 98, 97, 123, '', '',
'')
miner.minerstats.boardstatus1 = 'o'
miner.minerstats.boardstatus2 = 'oo'
miner.minerstats.boardstatus3 = 'ooo'
jminer = sch.dumps(miner).data
#rehydrate miner
reminer = MinerSchema().loads(jminer).data
self.assertTrue(isinstance(reminer.minerinfo, MinerInfo))
self.assertTrue(isinstance(reminer.minerpool, MinerCurrentPool))
self.assertTrue(reminer.minerpool.poolname == 'unittest')
self.assertTrue(isinstance(reminer.minerstats, MinerStatistics))
self.assertTrue(reminer.laststatuschanged)
self.assertTrue(reminer.minerstats.boardstatus1 == 'o')
self.assertTrue(reminer.minerstats.boardstatus2 == 'oo')
self.assertTrue(reminer.minerstats.boardstatus3 == 'ooo')
def readminers(self, file_name):
with open(file_name, encoding='utf-8-sig') as config_file:
jsonarray = json.loads(config_file.read())
miners = [Miner(**k) for k in jsonarray]
#TODO: Remove disabled miners
#if miner.name.startswith("#"):
return miners
def setUp(self):
'''create test miner'''
self.minerinfo = MinerInfo('Antminer S9', '')
self.miner = Miner('Test',
'Online',
'Antminer S9',
'',
'',
'',
'',
'',
'',
'',
lastmonitor=None,
offlinecount=0,
defaultpool='',
minerinfo=self.minerinfo)
self.minerstats = MinerStatistics(self.miner,
datetime.datetime.utcnow(),
3,
currenthash=9999,
controllertemp=0,
tempboard1=0,
tempboard2=0,
tempboard3=0)
def test_miner_status_change_keeps_original(self):
miner = Miner('test')
miner.status = MinerStatus.Offline
self.assertTrue(miner.laststatuschanged)
originalstatuschangetime = miner.laststatuschanged
miner.status = MinerStatus.Offline
self.assertTrue(miner.laststatuschanged == originalstatuschangetime)
def test_miner_monitored_timer(self):
miner = Miner('test')
stats = domain.minerstatistics.MinerStatistics(miner)
apicall = MinerApiCall(miner)
apicall.start()
apicall.stop()
miner.monitored(stats, pool=None, info=None, sec=apicall.elapsed())
self.assertFalse(miner.lastmonitor is None)
def test_miner_monitored_pool(self):
miner = Miner('test')
stats = domain.minerstatistics.MinerStatistics(miner)
miner.monitored(stats,
pool=MinerCurrentPool(miner),
info=None,
sec=None)
self.assertTrue(miner.minerpool)
def test_miner_summary(self):
miner = Miner("test", '', '', '', '', '', '', '', '')
self.assertTrue(miner.summary() is not None)
miner.status = MinerStatus.Online
self.assertTrue(miner.summary() is not None)
miner.minerstats = None
self.assertTrue(miner.summary() is not None)
miner.minerstats = domain.minerstatistics.MinerStatistics(miner)
self.assertTrue(miner.summary() is not None)
def test_miner_update(self):
miner = Miner('test')
miner.minerid = 'test'
miner.ipaddress = 'ip1'
miner.location = 'location1'
miner.in_service_date = datetime.datetime.now().replace(second=0,
microsecond=0)
minerupdate = Miner('test1')
minerupdate.minerid = 'test1'
minerupdate.ipaddress = 'ip2'
minerupdate.location = 'location2'
minerupdate.in_service_date = datetime.datetime.now()
miner.updatefrom(minerupdate)
self.assertFalse(miner.ipaddress == minerupdate.ipaddress)
minerupdate.minerid = miner.minerid
miner.updatefrom(minerupdate)
self.assertTrue(miner.ipaddress == minerupdate.ipaddress)
self.assertTrue(miner.location == minerupdate.location)
self.assertTrue(miner.in_service_date == minerupdate.in_service_date)
def test_miner_should_monitor(self):
miner = Miner("#test", '', '', '', '', '', '', '', '')
self.assertTrue(miner.should_monitor())
miner.monitored(domain.minerstatistics.MinerStatistics(miner), None,
None, None)
self.assertFalse(miner.should_monitor())
miner.name = "test"
self.assertTrue(miner.should_monitor())
miner.status = MinerStatus.Disabled
self.assertTrue(miner.should_monitor())
def test_miner_currentpoolname(self):
miner = Miner('test')
self.assertTrue(miner.currentpoolname() == '?')
miner.minerpool = MinerCurrentPool(miner,
'test pool',
'test worker',
allpools={},
poolname='unit test')
self.assertTrue(miner.currentpoolname() == 'unit test')
self.assertFalse(
miner.minerpool.findpoolnumberforpool('test pool', 'test worker'))
def findminerbyname(minertofind):
miners = MinerRepository()
miner = miners.getminerbyname(minertofind, APP.getconfigfilename('config/miners.conf'))
if miner is None:
miner = APP.getknownminerbyname(minertofind)
if miner is None:
miner = APP.getminer(Miner(name=minertofind))
if miner is None:
print('Miner {0} does not exist'.format(minertofind))
sys.exit(1)
return miner
def main():
'''main'''
if COMPONENTDISCOVERED.app.isrunnow:
miner = Miner('192.168.1.117')
dodiscovered(miner)
COMPONENTDISCOVERED.app.shutdown()
else:
print('Waiting for messages on {0}. To exit press CTRL+C'.format(QueueName.Q_DISCOVERED))
COMPONENTDISCOVERED.listeningqueue = COMPONENTDISCOVERED.app.makequeue(QueueName.Q_DISCOVERED)
COMPONENTDISCOVERED.listeningqueue.subscribe(when_discovered, no_acknowledge=False)
COMPONENTDISCOVERED.app.listen(COMPONENTDISCOVERED.listeningqueue)
def test_miner_reset_offline_count(self):
miner = Miner('test')
self.assertTrue(miner.offlinecount == 0)
self.assertTrue(miner.is_send_offline_alert())
miner.offline_now()
miner.offline_now()
miner.offline_now()
miner.offline_now()
self.assertFalse(miner.is_send_offline_alert())
miner.online_now()
self.assertTrue(miner.offlinecount == 0)
self.assertTrue(miner.is_send_offline_alert())
def test_miner_pools_available(self):
miner = Miner('test')
self.assertTrue(miner.pools_available is None)
miner.minerpool = MinerCurrentPool(miner,
'test pool',
'test worker',
allpools={})
self.assertTrue(len(miner.pools_available) == 0)
miner.minerpool.allpools = {
"POOLS": [{
"Pool Stale%": 0,
"Accepted": 421743,
"Difficulty Stale": 0,
"Stratum URL": "test",
"Rejected": 85,
"Difficulty Accepted": 6587318272,
"Best Share": 4019408192,
"User": "******",
"Stratum Active": True,
"Difficulty Rejected": 1343488,
"Diff": "16.4K",
"Remote Failures": 3,
"Discarded": 1094132,
"Long Poll": "N",
"Proxy": "",
"Priority": 0,
"Has GBT": False,
"Pool Rejected%": 0.0204,
"Stale": 63,
"Last Share Difficulty": 16384,
"Diff1 Shares": 0,
"Has Stratum": True,
"Status": "Alive",
"URL": "test",
"Quota": 1,
"Last Share Time": "0:00:05",
"Getworks": 70163,
"Get Failures": 3,
"POOL": 3,
"Proxy Type": ""
}]
}
self.assertTrue(len(miner.pools_available) > 0)
self.assertTrue(miner.minerpool.findpoolnumberforpool('test', 'test'))
self.assertFalse(miner.minerpool.findpoolnumberforpool('not', 'found'))
def doit(args):
if len(args) < 2:
print('usage: python runcommand.py nameofcommand [nameofminer] [commandparameter]')
APP.shutdown(1)
cmd = args[1]
if len(args) == 2:
#single command, no miner specified
queue_command = Queue(cmd, APP.getservice('rabbit'))
queue_command.publish('{0} runcommand called on {1}'.format(APP.now(), cmd))
queue_command.close()
print('sent command {0}'.format(cmd))
else:
minertofind = args[2]
cmdparam = ''
if len(args) > 3:
cmdparam = args[3]
miners = MinerRepository()
miner = miners.getminerbyname(minertofind, APP.getconfigfilename('config/miners.conf'))
if miner is None:
miner = APP.getknownminerbyname(minertofind)
if miner is None:
miner = APP.getminer(Miner(name=minertofind))
if miner is None:
print('Miner {0} does not exist'.format(minertofind))
sys.exit(1)
qnames = QueueName()
if not qnames.isvalidqname(cmd):
print('Queue {0} is not valid'.format(cmd))
sys.exit(1)
queue_command = Queue(cmd, APP.getservice('rabbit'))
#TODO: cleanup logic here. when to call app and when to override with just miner and command
if cmd:
qmess = MinerCommand(cmd, cmdparam)
msg = APP.createmessagecommand(miner, qmess)
queue_command.publish(msg)
else:
queue_command.publish(APP.messageencode(miner))
queue_command.close()
print('sent command {0} for miner {1}'.format(cmd, miner.name))
def dosave(msg):
entries = QueueEntries()
if msg.entity == 'miner':
#add or update miner
minerid = name = ipaddress = port = None
for pair in msg.values:
if 'minerid' in pair:
minerid = pair['minerid']
if 'name' in pair:
name = pair['name']
if 'ipaddress' in pair:
ipaddress = pair['ipaddress']
if 'port' in pair:
port = pair['port']
miner = Miner(name, '', '', ipaddress, port, '', '')
COMPONENTSAVE.app.save_miner(miner)
entries.add(QueueName.Q_MONITORMINER,
COMPONENTSAVE.app.messageencode(miner))
entries.add(QueueName.Q_PROVISION,
COMPONENTSAVE.app.messageencode(miner))
if msg.entity == 'pool':
#save the new named pool
pool_type = name = url = user = priority = None
for pair in msg.values:
if 'pool_type' in pair:
pool_type = pair['pool_type']
if 'name' in pair:
name = pair['name']
if 'url' in pair:
url = pair['url']
if 'user' in pair:
user = pair['user']
if 'priority' in pair:
priority = pair['priority']
pool = Pool(pool_type, name, url, user, priority)
COMPONENTSAVE.app.save_pool(pool)
return entries
'''Test saving application data'''
'''
Requires services to be running.
Redis
'''
from domain.mining import Miner
from backend.fcmapp import ApplicationService, ComponentName
APP = ApplicationService(ComponentName.fullcycle)
KNOWN = APP.allminers()
CNT = len(KNOWN)
MINER = Miner('New Miner2', '', '', '192.168.1.2', '4028', '', '')
APP.save_miner(MINER)
KNOWN2 = APP.allminers()
CNT2 = len(KNOWN2)
print(CNT2)
APP.save_miner(MINER)
KNOWN3 = APP.allminers()
CNT3 = len(KNOWN3)
print(CNT3)
def make(self, data):
return Miner(**data)
def make_miner(self) -> Miner:
miner = Miner("unittest", None, "", "unitip", "unitport", "", "")
miner.customerid = 1
return miner
def test_miner_is_not_disabled(self):
miner = Miner("test", '', '', '', '', '', '', '', '')
self.assertFalse(miner.is_disabled())
def test_miner_status_set_last_update(self):
miner = Miner('test')
self.assertTrue(not miner.laststatuschanged)
miner.status = MinerStatus.Offline
self.assertTrue(miner.laststatuschanged)
def test_miner_uses_default(self):
miner = Miner('test')
miner.ftpport = ''
miner.set_ftp_port('22')
self.assertTrue(miner.ftpport == '22')
def test_miner_uses_custom(self):
miner = Miner('test')
miner.ftpport = '99'
miner.set_ftp_port('22')
self.assertTrue(miner.ftpport == '99')
def test_miner_format_time_with_fraction(self):
miner = Miner('test')
miner.lastmonitor = '2018-04-11T01:28:45.3821739+00:00'
self.assertTrue(miner.formattime(miner.lastmonitor))
def test_miner_format_time_string(self):
miner = Miner('test')
miner.lastmonitor = '2018-04-11T01:28:45+00:00'
self.assertTrue(miner.formattime(miner.lastmonitor))
