def transact_with_function_task(self,
signing_address,
contract_address,
contract_type,
func,
args=None,
gas_limit=None,
prior_tasks=None,
reverses_task=None):
kwargs = {
'signing_address': signing_address,
'contract_address': contract_address,
'abi_type': contract_type,
'function': func,
'args': args,
'prior_tasks': prior_tasks,
'reverses_task': reverses_task
}
if gas_limit:
kwargs['gas_limit'] = gas_limit
return signature(eth_endpoint('transact_with_contract_function'),
kwargs=kwargs)
def send_eth_task(self, signing_address, amount_wei, recipient_address):
return signature(eth_endpoint('send_eth'),
kwargs={
'signing_address': signing_address,
'amount_wei': amount_wei,
'recipient_address': recipient_address
})
def call_contract_function(self, contract_address, contract_type, func, args=None):
return signature(
eth_endpoint('call_contract_function'),
kwargs={
'contract_address': contract_address,
'abi_type': contract_type,
'function': func,
'args': args,
}
)
def deploy_contract_task(self,
signing_address,
contract_name,
args=None,
prior_tasks=None):
return signature(eth_endpoint('deploy_contract'),
kwargs={
'signing_address': signing_address,
'contract_name': contract_name,
'args': args,
'prior_tasks': prior_tasks
})
def process_send_eth_transaction(
self,
transaction_id,
recipient_address,
transfer_amount,
task_id
):
return signature(
eth_endpoint('_process_send_eth_transaction'),
args=(
transaction_id,
recipient_address,
transfer_amount,
task_id
)
)
def process_deploy_contract_transaction(
self,
transaction_id,
contract_name,
args,
kwargs,
gas_limit,
task_id
):
return signature(
eth_endpoint('_process_deploy_contract_transaction'),
args=(
transaction_id,
contract_name,
args,
kwargs,
gas_limit,
task_id
)
)
def queue_send_eth(
self,
signing_address,
amount_wei,
recipient_address,
prior_tasks,
posterior_tasks,
):
"""
This is a slightly smelly special case where the transaction supervisor needs to call the higher-level
task manager to get a send_eth task created for topup purposes.
"""
sig = signature(eth_endpoint('send_eth'),
kwargs={
'signing_address': signing_address,
'amount_wei': amount_wei,
'recipient_address': recipient_address,
'prior_tasks': prior_tasks,
'posterior_tasks': posterior_tasks
})
return celery_utils.queue_sig(sig)
def process_function_transaction(
self,
transaction_id,
contract_address,
abi_type,
fn,
args,
kwargs,
gas_limit,
task_id
):
return signature(
eth_endpoint('_process_function_transaction'),
args=(
transaction_id,
contract_address,
abi_type,
fn,
args,
kwargs,
gas_limit,
task_id
)
)
scope.set_tag("domain", config.APP_HOST)
chain_config = config.CHAINS[celery_utils.chain]
from config import logg
logg.info(f'Using chain {celery_utils.chain}')
app = Celery('tasks',
broker=config.REDIS_URL,
backend=config.REDIS_URL,
task_serializer='json')
app.conf.beat_schedule = {
"maintain_eth_balances": {
"task": celery_utils.eth_endpoint('topup_wallets'),
"schedule": 600.0
},
}
app.conf.beat_schedule = {
'third-party-transaction-sync': {
'task':
celery_utils.eth_endpoint('synchronize_third_party_transactions'),
'schedule': chain_config['THIRD_PARTY_SYNC_SCHEDULE'],
}
}
w3 = Web3(HTTPProvider(chain_config['HTTP_PROVIDER']))
w3_websocket = Web3(WebsocketProvider(chain_config['WEBSOCKET_PROVIDER']))
processor_task_config = {
**base_task_config, 'max_retries': 10,
'autoretry_for': (LockedNotAcquired, ),
'queue': 'processor',
'default_retry_delay': 3,
'retry_backoff': False
}
# @signals.task_failure.connect
# def on_task_failure(**kwargs):
# print('[task:%s]' % (kwargs['sender'].request.correlation_id, )
# + '\n'
# + kwargs.get('einfo').traceback)
@app.task(name=eth_endpoint('synchronize_third_party_transactions'),
**low_priority_config)
def synchronize_third_party_transactions(self):
return blockchain_sync.synchronize_third_party_transactions()
@app.task(name=eth_endpoint('add_transaction_filter'), **low_priority_config)
def add_transaction_filter(self,
contract_address,
contract_type,
filter_parameters,
filter_type,
decimals=18,
block_epoch=None):
f = blockchain_sync.add_transaction_filter(contract_address, contract_type,
filter_parameters, filter_type,
def handle_error(self, transaction_id):
return signature(eth_endpoint('_handle_error'),
args=(transaction_id, ))
def check_transaction_response(self):
return signature(eth_endpoint('_check_transaction_response'))
def attempt_transaction(self, task_uuid):
return signature(eth_endpoint('attempt_transaction'),
kwargs={'task_uuid': task_uuid})
processor_task_config = {
**base_task_config,
'max_retries': 10,
'autoretry_for': (LockedNotAcquired,),
'queue': 'processor',
'default_retry_delay': 3,
'retry_backoff': False
}
# @signals.task_failure.connect
# def on_task_failure(**kwargs):
# print('[task:%s]' % (kwargs['sender'].request.correlation_id, )
# + '\n'
# + kwargs.get('einfo').traceback)
@app.task(name=eth_endpoint('get_third_party_sync_metrics'), **base_task_config)
def get_third_party_sync_metrics(self):
return blockchain_sync.get_metrics()
@app.task(name=eth_endpoint('get_failed_block_fetches'), **base_task_config)
def get_failed_block_fetches(self):
return blockchain_sync.get_failed_block_fetches()
@app.task(name=eth_endpoint('get_failed_callbacks'), **base_task_config)
def get_failed_callbacks(self):
return blockchain_sync.get_failed_callbacks()
@app.task(name=eth_endpoint('force_fetch_block_range'), **base_task_config)
def force_fetch_block_range(self, filter_address, floor, ceiling):
return blockchain_sync.force_fetch_block_range(filter_address, floor, ceiling)
