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)