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)
