def run_testsuite(self, job_id):
"""
run test
:return:
"""
try:
suit = self.load_testsuite()
if suit is not None:
# LOG.info("********TEST START********")
now = time.strftime("%Y_%m_%d_%H_%M_%S")
result_path = os.path.join(CUR_DIR, "report")
if not os.path.exists(result_path):
os.mkdir(result_path)
if job_id == '':
report_abspath = os.path.join(result_path,
now + "_result.html")
else:
report_abspath = os.path.join(result_path,
job_id + "_result.html")
print("report path:%s" % report_abspath)
report = open(report_abspath, "wb")
runner = Htmlrunner(stream=report,
title=u'自动化测试报告,测试结果如下：',
description=u'用例执行情况：')
runner.run(suit)
else:
LOG.info("Have no case to test.")
except Exception as ex:
LOG.error(str(ex))
def notify_rcode_to_next_peer(self, next_channel):
"""
:param next_channel:
:return:
"""
peer = None
try:
# original payer is found
if not next_channel:
LOG.info('HTLC Founder with HashR<{}> received the R-code<{}>'.
format(self.hashcode, self.rcode))
return
htlc_trade = self.get_htlc_trade_by_hashr(next_channel,
self.hashcode)
if next_channel != htlc_trade.channel:
LOG.error('Why the channel is different. next_channel<{}>, stored channel<{}>' \
.format(next_channel, htlc_trade.channel))
# notify the previous node the R-code
LOG.debug('Payment get channel {}/{}'.format(
next_channel, self.hashcode))
channel = Channel(next_channel)
peer = channel.peer_uri(self.wallet.url)
nonce = channel.latest_nonce(next_channel)
LOG.info("Next peer: {}".format(peer))
self.create(next_channel, self.asset_type, nonce, self.wallet.url,
peer, self.hashcode, self.rcode, self.comments)
except Exception as error:
LOG.error('Failed to notify RCode<{}> to peer<{}>'.format(
self.rcode, peer))
def handle(self):
super(FounderResponsesMessage, self).handle()
# check response status
if not self.check_response_status(self.status):
return
try:
# some checks and verification for founder message
self.verify()
self.check_nonce(self.nonce)
founder_trade = Channel.query_trade(self.channel_name, self.nonce)
self.check_signature(self.wallet,
type_list=self._sign_type_list,
value_list=[
self.channel_name, self.nonce,
self.receiver_address,
int(founder_trade.balance),
self.sender_address,
int(founder_trade.peer_balance)
],
signature=self.commitment)
# update the trade
Channel.update_trade(self.channel_name,
self.nonce,
peer_commitment=self.commitment)
except GoTo as error:
LOG.error(error)
except Exception as error:
LOG.error(
'Exception occurred during creating channel<{}>. Exception: {}'
.format(self.channel_name, error))
else:
self.register_deposit_event()
def handle(self):
super(RsmcMessage, self).handle()
status = EnumResponseStatus.RESPONSE_OK
try:
# send RsmcSign message to peer
RsmcResponsesMessage.create(
self.wallet, self.channel_name, self.asset_type, self.nonce,
self.net_magic, self.sender, self.receiver, self.payment,
self.sender_balance, self.receiver_balance,
self.rsmc_sign_role, self.hashcode, self.comments)
except TrinityException as error:
status = error.reason
LOG.error(error)
except Exception as error:
status = EnumResponseStatus.RESPONSE_EXCEPTION_HAPPENED
LOG.error(
'Failed to handle RsmcMessage. Exception: {}'.format(error))
finally:
if EnumResponseStatus.RESPONSE_OK != status:
# nofify error response
RsmcResponsesMessage.send_error_response(
self.sender, self.receiver, self.channel_name,
self.asset_type, self.nonce, status)
return
def execute(self, block_height, channel_name='', hashcode=''):
"""
:param block_height:
:param channel_name:
:param kwargs:
:return:
"""
super(ChannelHtlcUnlockedEvent, self).execute(block_height)
# if monitor this event, update the htlc trade state to confirmed
if channel_name and hashcode:
try:
htlc_trade = Channel.batch_query_trade(
channel_name,
filters={
'type': EnumTradeType.TRADE_TYPE_HTLC.name,
'hashcode': hashcode
})[0]
except Exception as error:
LOG.error('Htlc trade with HashR<{}> not found for channel<{}>. Exception: {}'\
.format(hashcode, channel_name, error))
else:
Channel.update_trade(
channel_name,
htlc_trade.nonce,
state=EnumTradeState.confirmed_onchain.name)
else:
LOG.error(
'Error input parameters: channel <{}>, hashcode<{}>.'.format(
channel_name, hashcode))
def register_quick_close_event(self, is_founder=True):
"""
:param is_founder:
:return:
"""
try:
channel_event = ChannelQuickSettleEvent(self.channel_name,
is_founder)
if is_founder:
settle_trade = Channel.query_trade(self.channel_name,
SettleBase._SETTLE_NONCE)
# register arguments for execution action
channel_event.register_args(
EnumEventAction.EVENT_EXECUTE, self.receiver_address,
self.channel_name, self.nonce, self.receiver_address,
settle_trade.balance, self.sender_address,
settle_trade.peer_balance, settle_trade.commitment,
self.commitment, self.wallet._key.private_key_string)
# register arguments for termination action
channel_event.register_args(EnumEventAction.EVENT_TERMINATE,
asset_type=self.asset_type)
except Exception as error:
LOG.error(
'Failed to regiser quick close channel event since {}'.format(
error))
else:
# register and trigger the event
event_machine.register_event(self.channel_name, channel_event)
event_machine.trigger_start_event(self.channel_name)
def approve(cls, address, deposit, private_key, gwei_coef=1):
"""
:param address:
:param deposit:
:param private_key:
:param gwei_coef:
:return:
"""
deposit = int(deposit)
# approved_asset = cls.get_approved_asset(address)
#
# if approved_asset >= deposit:
# LOG.info('Has been approved asset count: {}'.format(approved_asset))
# return True
try:
# return tx_id
tx_id = cls._eth_interface.approve(address,
deposit,
private_key,
gwei_coef=gwei_coef)
LOG.debug(
'ContractEventInterface::approve: txId: {}'.format(tx_id))
return tx_id
except Exception as error:
LOG.error('authorized deposit error: {}'.format(error))
return False
def htlc_unlock_payment(cls,
invoker,
channel_id,
founder,
partner,
lock_period,
lock_amount,
lock_hash,
founder_signature,
partner_signature,
lock_secret,
invoker_key,
gwei_coef=1):
try:
result = cls._eth_interface.withdraw(invoker,
channel_id,
founder,
partner,
int(lock_period),
int(lock_amount),
lock_hash,
founder_signature,
partner_signature,
lock_secret,
invoker_key,
gwei_coef=gwei_coef)
LOG.debug('htlc_unlock_payment result: {}'.format(result))
return result
except Exception as error:
LOG.error('htlc_unlock_payment error: {}'.format(error))
return None
def add_one(self, channel: str, src_addr: str, dest_addr: str, state: str, alive_block: int,
deposit:dict, magic:str, hlock={}, **kwargs):
"""
:param channel:
:param src_addr:
:param dest_addr:
:param state:
:param alive_block:
:param deposit: format : {${address_1}: {${asset_type}: amount}, ${address_2}: {${asset_type}: amount}}
${address_1} ${address_2} -- the node address of the channel bi-direction's owner
${asset_type} -- current just support "NEO", "TNC"
:param balance: same format as deposit // to add operation, maybe useless
:return:
"""
if not self.is_valid_channel_state(state):
LOG.error('Error Channel state<{}> is used.'.format(state))
# Guarantee no possession loss even if users do some wrong operations.
# if not self.remove_unsupported_asset(deposit.get('source')) or \
# not self.remove_unsupported_asset(deposit.get('destination')):
# return
return super(TBLChannel, self).add(channel=channel, src_addr=src_addr, dest_addr=dest_addr,
state=state, alive_block=alive_block,
deposit=deposit, balance=deposit, hlock=hlock, magic=magic, **kwargs)
def update_close_channel(cls,
invoker,
channel_id,
nonce,
founder,
founder_balance,
partner,
partner_balance,
lock_hash,
lock_secret,
founder_signature,
partner_signature,
invoker_key,
gwei_coef=1):
try:
result = cls._eth_interface.update_transaction(
invoker,
channel_id,
nonce,
founder,
int(founder_balance),
partner,
int(partner_balance),
lock_hash,
lock_secret,
founder_signature,
partner_signature,
invoker_key,
gwei_coef=gwei_coef)
LOG.debug('update_close_channel result: {}'.format(result))
return result
except Exception as error:
LOG.error('update_close_channel error: {}'.format(error))
return None
def approve_deposit(cls,
address,
channel_id,
nonce,
founder,
founder_amount,
partner,
partner_amount,
founder_sign,
partner_sign,
private_key,
gwei_coef=1):
try:
return cls._eth_interface.deposit(address,
channel_id,
nonce,
founder,
int(founder_amount),
partner,
int(partner_amount),
founder_sign,
partner_sign,
private_key,
gwei_coef=gwei_coef)
except Exception as error:
LOG.error('approve_deposit error: {}'.format(error))
return None
def setup_events():
if FILE_PATH is not None:
logger.info("Event Definitions configuration file: %s"
% FILE_PATH.split('/')[-1])
with open(FILE_PATH) as cf:
config = cf.read()
try:
events_config = yaml.safe_load(config)
except yaml.YAMLError as err:
if hasattr(err, 'problem_mark'):
mark = err.problem_mark
errmsg = ("Invalid YAML syntax in Event Definitions file "
"%(file)s at line: %(line)s, column: %(column)s."
% dict(file=FILE_PATH.split('/')[-1],
line=mark.line + 1,
column=mark.column + 1))
else:
errmsg = ("YAML error reading Event Definitions file: %s"
% FILE_PATH.split('/')[-1])
logger.error(errmsg)
raise
else:
return EventConverter(events_config)
else:
logger.error("No Event Definitions configuration file found!")
def do_close_wallet(self):
if self.Wallet:
self.Wallet.SaveStoredData("BlockHeight", self.Wallet.BlockHeight)
try:
gate_way.close_wallet()
except Exception as e:
LOG.error(e)
super().do_close_wallet()
def close(self):
try:
self.db_client.close()
except Exception as exp_info:
LOG.error('Exception happened to close DB client. Exception: {}'.format(exp_info))
# reset the class member's value
self.db_client = None
self.db = None
def register_event(self, name, event):
try:
self.event_lock.acquire()
self.__event_queue.update({name: event})
except Exception as error:
LOG.error('event machine register_event<{}> exception: {}'.format(
name, error))
finally:
self.event_lock.release()
def get_transaction_receipt(cls, tx_id):
try:
result = cls._eth_interface.get_transaction_receipt(tx_id)
if result:
print(result)
return result
except Exception as error:
LOG.error('get_approved_asset error: {}'.format(error))
return None
def monitorCloseChannel(self, message):
"""
:param message:
:return:
message like below format:
{
'playload': '0xabf328663edff39bfa3f157556afa52bdcb14fda32d35c70e6e3386e954e7995',
'txId': '0xc0461c9a92a295eec4dd1060e4abd34bbb1c8139e2b9bc5e35e7c2daa1dccfc5',
'channelId': '0xabf328663edff39bfa3f157556afa52bdcb14fda32d35c70e6e3386e954e7995',
'invoker': '0x23cca051bfedb5e17d3aad2038ba0a5155d1b1b7',
'nonce': 5,
'blockNumber': 3924231,
'messageType': 'monitorCloseChannel'
}
"""
if not message:
LOG.error('Invalid message: {}'.format(message))
return
try:
invoker = message.get('invoker').strip()
channel_name = message.get('channelId')
nonce = message.get('nonce')
end_time = int(message.get('blockNumber'))
except Exception as error:
LOG.exception('Invalid message: {}. Exception: {}'.format(
message, error))
else:
if not (self.wallet_address and invoker):
LOG.error(
'Wallet address<{}> or invoker<{}> should not be none'.
format(self.wallet_address, invoker))
return
if invoker != self.wallet_address.lower():
channel_event = ChannelUpdateSettleEvent(
channel_name, self.wallet_address)
channel_event.register_args(
EnumEventAction.EVENT_EXECUTE, self.wallet.url,
channel_name, self.wallet._key.private_key_string, nonce)
event_machine.register_event(channel_name, channel_event)
event_machine.trigger_start_event(channel_name)
else:
LOG.debug('register ChannelEndSettleEvent at block<{}>'.format(
end_time))
channel_event = ChannelEndSettleEvent(channel_name,
self.wallet_address)
channel_event.register_args(
EnumEventAction.EVENT_EXECUTE, invoker, channel_name,
self.wallet._key.private_key_string)
self.register_event(channel_event, end_time)
return
def handlemaessage(self):
while self.go_on:
if MessageList:
message = MessageList.pop(0)
try:
self._handlemessage(message[0])
except Exception as e:
LOG.error("handle message error {} {}".format(
json.dumps(message), str(e)))
time.sleep(0.1)
def open_execl(self):
"""打开Execl"""
try:
# formatting_info=True 写入数据时不会改变原有格式
execl_data = xlrd.open_workbook(self.path, formatting_info=True)
return execl_data
except Exception as e:
LOG.error("""打开%s失败，
错误原因%s""" % (self.path, e))
print('打开%s失败\n\r错误原因%s' % (self.path, e))
def request(self, url, params, method, **kwargs):
"""根据传入的请求类型发出请求"""
if method == 'GET':
response_data_str = self.request_get(url, params, **kwargs)
return response_data_str
elif method == 'POST':
response_data_str = self.request_post(url, params, **kwargs)
return response_data_str
else:
LOG.error('method参数有误，请检查！')
def wrapper(*args, **kwargs):
try:
callback(*args, **kwargs)
except Exception as error:
console_log.error(
'Error occurred to run command: {}. Please check logs for details.'
.format(command))
LOG.error(
'Error occurred to run command: {}. Exception: {}'.format(
command, error))
def is_valid_deposit(asset_type, deposit, spv_wallet=False):
"""
:param asset_type:
:param deposit:
:param spv_wallet:
:return:
"""
if len(asset_type) > 10:
asset_type = get_asset_type_name(asset_type)
else:
asset_type = asset_type.upper()
if not asset_type:
LOG.error('Must specified the asset type. Current value is None')
return False
if spv_wallet:
try:
max_deposit_configure = Configure.get("Channel").get(
asset_type).get("CommitMaxDeposit")
except Exception as e:
LOG.warn(str(e))
max_deposit_configure = 0
try:
min_deposit_configure = Configure.get("Channel").get(
asset_type.upper()).get("CommitMinDeposit")
except Exception as e:
LOG.warn(str(e))
min_deposit_configure = 0
max_deposit = TrinityNumber(str(max_deposit_configure)).number
min_deposit = TrinityNumber(str(min_deposit_configure)).number
if min_deposit > 0 and max_deposit > 0:
return min_deposit <= deposit <= max_deposit, None
elif 0 >= min_deposit:
LOG.warn('CommitMinDeposit is set as an illegal value<{}>.'.format(
str(min_deposit_configure)))
return deposit <= max_deposit, None
elif 0 >= max_deposit:
LOG.warn('CommitMaxDeposit is set as an illegal value<{}>.'.format(
str(max_deposit_configure)))
return deposit >= min_deposit, None
else:
if asset_type == "TNC":
deposit_l = DepositAuth.deposit_limit()
deposit_cmp = TrinityNumber(str(deposit_l)).number
if deposit <= deposit_cmp:
return False, "Node wallet channel deposit should larger than {}, " \
"but now is {}".format(str(deposit_l),str(deposit/pow(10, 8)))
return True, None
def end_close_channel(cls, invoker, channel_id, invoker_key, gwei_coef=1):
try:
result = cls._eth_interface.settle_transaction(invoker,
channel_id,
invoker_key,
gwei_coef=gwei_coef)
LOG.debug('end_close_channel result: {}'.format(result))
return result
except Exception as error:
LOG.error('end force_settle error: {}'.format(error))
return None
def trigger_start_event(self, name):
try:
self.event_lock.acquire()
if name not in self.__event_ordered_list:
self.__event_ordered_list.append(name)
except Exception as error:
LOG.error(
'event machine trigger_start_event<{}> exception: {}'.format(
name, error))
finally:
self.event_lock.release()
def send(self, payload):
try:
self._conn.send(payload)
except WebSocketConnectionClosedException as error:
LOG.error('send: Websocket was closed: {}'.format(error))
self.reconnect()
# re-send this payload
if self._conn:
self._conn.send(payload)
except Exception as error:
LOG.error('send: Websocket exception: {}'.format(error))
def get_event(self, key):
try:
self.event_lock.acquire()
event = self.__monitor_queue.pop(key, [])
except Exception as error:
event = None
LOG.error('websocket get_event exception: {}'.format(error))
finally:
self.event_lock.release()
return event
def check_response_status(cls, status):
"""
:param status:
:return:
"""
if EnumResponseStatus.RESPONSE_OK.name != status:
LOG.error('Message {} with error status<{}>'.format(
cls._message_name, status))
return False
return True
def register_deposit_event(self, is_founder=True):
"""
:param is_founder:
:return:
"""
try:
channel_event = ChannelDepositEvent(self.channel_name, is_founder)
# get the transaction record of founder message
founder_trade = Channel.query_trade(self.channel_name,
FounderBase._FOUNDER_NONCE)
# set some arguments by the role type
self_address = self.receiver_address
self_deposit = founder_trade.balance
if is_founder:
founder_address = self.receiver_address
founder_deposit = founder_trade.balance
founder_commitment = founder_trade.commitment
partner_address = self.sender_address
partner_deposit = founder_trade.peer_balance
partner_commitment = founder_trade.peer_commitment
else:
founder_address = self.sender_address
founder_deposit = founder_trade.peer_balance
founder_commitment = founder_trade.peer_commitment
partner_address = self.receiver_address
partner_deposit = founder_trade.balance
partner_commitment = founder_trade.commitment
# register the preparation action for deposit event
channel_event.register_args(EnumEventAction.EVENT_PREPARE,
self_address, self_deposit,
self.wallet._key.private_key_string)
# add execution action for deposit event
channel_event.register_args(
EnumEventAction.EVENT_EXECUTE, self_address, self.channel_name,
FounderBase._FOUNDER_NONCE, founder_address, founder_deposit,
partner_address, partner_deposit, founder_commitment,
partner_commitment, self.wallet._key.private_key_string)
channel_event.register_args(EnumEventAction.EVENT_TERMINATE,
asset_type=self.asset_type)
except Exception as error:
LOG.error(
'Failed to register deposit event since {}'.format(error))
else:
# register and trigger event
event_machine.register_event(self.channel_name, channel_event)
event_machine.trigger_start_event(self.channel_name)
return
def clientConnectionFailed(self, connector, reason):
"""
connection failed
:param connector:
:param reason:
:return:
"""
if GatwayClientProtocol.printlog:
print('Can Not connect Gateway, Please Check the gateway')
LOG.error(reason)
self._handle_connection_lose(connector)
def clientConnectionLost(self, connector, reason):
"""
connection lost
:param connector:
:param reason:
:return:
"""
if GatwayClientProtocol.printlog:
print('Lost Gateway')
LOG.error(reason)
self._handle_connection_lose(connector)
