def ucoro_event(coro, iter_data): try: coro.send(iter_data) except StopIteration as error: LOG.debug('Co-routine has been killed.') except Exception as error: LOG.warning( 'Error occurred during using co-routine. error: {}'.format(error))
def timeout_handler(self, block_height, *args, **kwargs): LOG.warning('Timeout stage of event<{}-{}> at block-{}'.format( self.event_name, self.event_type_name, block_height)) if not self.retry: self.retry_event() else: self.set_error_stage() pass
def delete_many(self, filters): if not filters: return EnumStatusCode.DBDeletedWithDangerousFilters if self.is_all(filters): LOG.warning('All of items will be deleted.') filters = {} result = self.db_table.delete_many(filters) return self.__result_of_delete(result)
def notify_peer_payment_finished(self,): try: payment_record = Channel.query_payment(self.channel_name, self.comments)[0] receiver = payment_record.receiver except: LOG.warning('No payment record with code<{}> is found'.format(self.comments)) pass else: PaymentAck.create(self.wallet.url, receiver, self.channel_name, self.asset_type, self.nonce, self.comments) return
def update_one(self, primary_key, **kwargs): """ :param primary_key: :param kwargs: :return: """ if self.primary_key in kwargs.keys(): LOG.warning('Primary key MUST not be changed.') kwargs.pop(self.primary_key) # add the update time. kwargs.update(self.update_at) result = self.db_table.update_one({self.primary_key: primary_key}, {'$set': kwargs}) return self.__result_of_update(result)
def execute(self, block_height, address='', channel_id='', nonce='', founder='', deposit=0, partner='', partner_deposit=0, founder_sign='', partner_sign='', private_key=''): super(ChannelDepositEvent, self).execute(block_height) # execute stage of channel event try: # if this wallet is not the event founder, go to next step directly. if not self.is_event_founder: self.next_stage() return True # below codes is just executed by the founder # check whether deposit is success or not if self.deposit_tx_id: checked = self.check_transaction_success(self.deposit_tx_id) if checked: # go to next stage self.next_stage() return True elif checked is False: return False else: # new transaction is pushed to chain self.deposit_tx_id = None # update the founder and partner deposit self.deposit = int(deposit) self.partner_deposit = int(partner_deposit) # get approved asset of both partners peer_approved_deposit = self.contract_event_api.get_approved_asset(partner) approved_deposit = self.contract_event_api.get_approved_asset(founder) LOG.debug('Approved asset in wallet<{}>: founder<{}:{}>, partner<{}:{}>' \ .format(address, founder, approved_deposit, partner, peer_approved_deposit)) # check approved asset of both side for event founder. if not (approved_deposit >= self.deposit and peer_approved_deposit >= self.partner_deposit): return False # Trigger deposit action if is_event_founder is True result = self.deposit_tx_id = self.contract_event_api.approve_deposit( address, channel_id, nonce, founder, deposit, partner, partner_deposit, founder_sign, partner_sign, private_key, gwei_coef=self.gwei_coef) if result: self.deposit_tx_id = '0x'+result.strip() except Exception as error: LOG.warning('Failed to approve deposit of Channel<{}>. Exception: {}'.format(self.channel_name, error)) return False
def __result_of_update(self, result): """ :param result: :return: """ if 0 == result.matched_count: return EnumStatusCode.DBUpdatedButNoMatchedItemsOK elif 0 == result.modified_count: LOG.warning('Matched count: {}.'.format( result.matched_count)) return EnumStatusCode.NOK elif result.matched_count != result.modified_count: LOG.warning('Matched count: {}; Modified count: {}.'.format(result.matched_count, result.modified_count,)) return EnumStatusCode.DBUpdatedPartOfItemsOK return EnumStatusCode.OK
def update_one_statistics(self, primary_key, **kwargs): """ :param primary_key: :param kwargs: :return: """ if self.primary_key in kwargs.keys(): LOG.warning('Primary key MUST not be changed.') kwargs.pop(self.primary_key) result = self.db_table.update_one({self.primary_key: primary_key}, { '$inc': kwargs, '$set': self.update_at }, True) return self.__result_of_update(result)
def notify_rcode_to_next_peer(self, next_channel): """ :param next_channel: :return: """ peer = None try: # original payer is found if not next_channel or next_channel == self.channel_name: 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 htlc_trade.role == EnumTradeRole.TRADE_ROLE_PARTNER.name and next_channel != htlc_trade.channel: LOG.warning( '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) channel.update_trade(next_channel, htlc_trade.nonce, rcode=self.rcode) 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) APIStatistics.update_statistics(self.wallet.address, htlc_rcode=True) except Exception as error: LOG.error('Failed to notify RCode<{}> to peer<{}>'.format( self.rcode, peer))
def update_many(self, filters, **kwargs): """ :param filters: :param kwargs: :return: """ if not filters: return EnumStatusCode.DBUpdatedWithDangerousFilters if self.is_all(filters): LOG.warning('All of items will be updated.') filters = {} if self.primary_key in kwargs.keys(): LOG.warning('Primary key MUST not be changed.') kwargs.pop(self.primary_key) # add the update time. kwargs.update(self.update_at) result = self.db_table.update_many(filters, {'$set': kwargs}) return self.__result_of_update(result)
def on_timeout(self, soft, timeout): super(MyRequest, self).on_timeout(soft, timeout) if not soft: LOG.warning('A hard timeout was enforced for task %s', self.task.name)
def on_failure(self, exc_info, send_failed_event=True, return_ok=False): super().on_failure(exc_info, send_failed_event=send_failed_event, return_ok=return_ok) LOG.warning('Failure detected for task %s', self.task.name)