def run_scenario(self):
from scenario_player.tasks.base import get_task_class_for_type
log.info("Fetching node addresses")
unreachable_nodes = [node for node, addr in self.node_to_address.items() if not addr]
if not self.node_to_address or unreachable_nodes:
raise NodesUnreachableError(f"Raiden nodes unreachable: {','.join(unreachable_nodes)}")
token_ctr = get_or_deploy_token(self.client, self.scenario)
token_address = self.token_address = to_checksum_address(token_ctr.contract_address)
first_node = first(self.raiden_nodes)
token_settings = self.scenario.get('token') or {}
token_balance_min = token_settings.get(
'balance_min',
DEFAULT_TOKEN_BALANCE_MIN,
)
mint_tx = []
for node, address in self.node_to_address.items():
balance = token_ctr.contract.functions.balanceOf(address).call()
if balance < token_balance_min:
mint_amount = token_balance_min - balance
log.debug("Minting tokens for", address=address, node=node, amount=mint_amount)
mint_tx.append(token_ctr.transact('mintFor', mint_amount, address))
elif balance > token_balance_min:
log.warning("Node is overfunded", address=address, node=node, balance=balance)
wait_for_txs(self.client, mint_tx)
registered_tokens = set(
self.session.get(
API_URL_TOKENS.format(protocol=self.protocol, target_host=first_node),
).json(),
)
if token_address not in registered_tokens:
code, msg = self.register_token(token_address, first_node)
if not 199 < code < 300:
log.error("Couldn't register token with network", code=code, message=msg)
raise TokenRegistrationError(msg)
scenario_config = self.scenario.get('scenario')
if not scenario_config:
raise ScenarioError("Invalid scenario definition. Missing 'scenario' key.")
try:
(root_task_type, root_task_config), = scenario_config.items()
except ValueError:
# will be thrown if it's not a 1-element dict
raise ScenarioError(
"Invalid scenario definition. "
"Exactly one root task is required below the 'scenario' key.",
) from None
task_class = get_task_class_for_type(root_task_type)
self.root_task = task_class(runner=self, config=root_task_config)
self.root_task()
def _initialize_scenario_token(
self,
node_addresses: Set[ChecksumAddress],
udc_ctr: Optional[ContractProxy],
should_deposit_ud_token: bool,
gas_limit: int,
) -> Set[TransactionHash]:
token_ctr, token_block = get_or_deploy_token(self)
self.token_address = to_checksum_address(token_ctr.contract_address)
self.token_deployment_block = token_block
token_settings = self.scenario.get('token') or {}
token_balance_min = token_settings.get(
'balance_min',
DEFAULT_TOKEN_BALANCE_MIN,
)
token_balance_fund = token_settings.get(
'balance_fund',
DEFAULT_TOKEN_BALANCE_FUND,
)
mint_tx = set()
for address in node_addresses:
tx = mint_token_if_balance_low(
token_contract=token_ctr,
target_address=address,
min_balance=token_balance_min,
fund_amount=token_balance_fund,
gas_limit=gas_limit,
mint_msg="Minting tokens for",
)
if tx:
mint_tx.add(tx)
if not should_deposit_ud_token:
continue
ud_deposit_balance = udc_ctr.contract.functions.effectiveBalance(
address).call()
if ud_deposit_balance < DEFAULT_TOKEN_BALANCE_MIN // 2:
deposit_amount = (DEFAULT_TOKEN_BALANCE_FUND //
2) - ud_deposit_balance
log.debug("Depositing into UDC",
address=address,
amount=deposit_amount)
mint_tx.add(
udc_ctr.transact(
'deposit',
gas_limit,
address,
DEFAULT_TOKEN_BALANCE_FUND // 2,
), )
return mint_tx
def run_scenario(self):
fund_tx = []
node_starter: gevent.Greenlet = None
if self.is_managed:
self.node_controller.initialize_nodes()
node_addresses = self.node_controller.addresses
node_balances = {
address: self.client.balance(address)
for address in node_addresses
}
low_balances = {
address: balance
for address, balance in node_balances.items()
if balance < NODE_ACCOUNT_BALANCE_MIN
}
if low_balances:
log.info('Funding nodes', nodes=low_balances.keys())
fund_tx = [
self.client.send_transaction(
to=address,
startgas=21000,
value=NODE_ACCOUNT_BALANCE_FUND - balance,
) for address, balance in low_balances.items()
]
node_starter = self.node_controller.start(wait=False)
else:
log.info("Fetching node addresses")
unreachable_nodes = [
node for node, addr in self.node_to_address.items() if not addr
]
if not self.node_to_address or unreachable_nodes:
raise NodesUnreachableError(
f"Raiden nodes unreachable: {','.join(unreachable_nodes)}",
)
token_ctr = get_or_deploy_token(self)
token_address = self.token_address = to_checksum_address(
token_ctr.contract_address)
first_node = self.get_node_baseurl(0)
token_settings = self.scenario.get('token') or {}
token_balance_min = token_settings.get(
'balance_min',
DEFAULT_TOKEN_BALANCE_MIN,
)
token_balance_fund = token_settings.get(
'balance_fund',
DEFAULT_TOKEN_BALANCE_FUND,
)
mint_tx = []
if self.is_managed:
addresses = self.node_controller.addresses
else:
addresses = self.node_to_address.values()
for address in addresses:
balance = token_ctr.contract.functions.balanceOf(address).call()
if balance < token_balance_min:
mint_amount = token_balance_fund - balance
startgas = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL
log.debug("Minting tokens for",
address=address,
amount=mint_amount)
mint_tx.append(
token_ctr.transact('mintFor', startgas, mint_amount,
address))
elif balance > token_balance_min:
log.warning("Node is overfunded",
address=address,
balance=balance)
wait_for_txs(self.client, mint_tx + fund_tx)
if node_starter is not None:
log.debug('Waiting for nodes to finish starting')
node_starter.get(block=True)
registered_tokens = set(
self.session.get(
API_URL_TOKENS.format(protocol=self.protocol,
target_host=first_node), ).json(), )
if token_address not in registered_tokens:
code, msg = self.register_token(token_address, first_node)
if not 199 < code < 300:
log.error("Couldn't register token with network",
code=code,
message=msg)
raise TokenRegistrationError(msg)
# Start root task
root_task_greenlet = gevent.spawn(self.root_task)
greenlets = [root_task_greenlet]
if self.is_managed:
greenlets.append(self.node_controller.start_node_monitor())
try:
gevent.joinall(greenlets, raise_error=True)
except BaseException:
if not root_task_greenlet.dead:
# Make sure we kill the tasks if a node dies
root_task_greenlet.kill()
raise
def run_scenario(self):
if self.is_managed:
self.node_controller.initialize_nodes()
node_addresses = self.node_controller.addresses
node_balances = {
address: self.client.balance(address)
for address in node_addresses
}
low_balances = {
address: balance
for address, balance in node_balances.items()
if balance < NODE_ACCOUNT_BALANCE_MIN
}
fund_tx = []
if low_balances:
log.info('Funding nodes', nodes=low_balances.keys())
fund_tx = [
self.client.send_transaction(address, NODE_ACCOUNT_BALANCE_FUND - balance)
for address, balance in low_balances.items()
]
self.node_controller.start()
if fund_tx:
wait_for_txs(self.client, fund_tx)
else:
log.info("Fetching node addresses")
unreachable_nodes = [node for node, addr in self.node_to_address.items() if not addr]
if not self.node_to_address or unreachable_nodes:
raise NodesUnreachableError(
f"Raiden nodes unreachable: {','.join(unreachable_nodes)}",
)
token_ctr = get_or_deploy_token(self)
token_address = self.token_address = to_checksum_address(token_ctr.contract_address)
first_node = self.get_node_baseurl(0)
token_settings = self.scenario.get('token') or {}
token_balance_min = token_settings.get(
'balance_min',
DEFAULT_TOKEN_BALANCE_MIN,
)
mint_tx = []
if self.is_managed:
addresses = self.node_controller.addresses
else:
addresses = self.node_to_address.values()
for address in addresses:
balance = token_ctr.contract.functions.balanceOf(address).call()
if balance < token_balance_min:
mint_amount = token_balance_min - balance
log.debug("Minting tokens for", address=address, amount=mint_amount)
mint_tx.append(token_ctr.transact('mintFor', mint_amount, address))
elif balance > token_balance_min:
log.warning("Node is overfunded", address=address, balance=balance)
wait_for_txs(self.client, mint_tx)
registered_tokens = set(
self.session.get(
API_URL_TOKENS.format(protocol=self.protocol, target_host=first_node),
).json(),
)
if token_address not in registered_tokens:
code, msg = self.register_token(token_address, first_node)
if not 199 < code < 300:
log.error("Couldn't register token with network", code=code, message=msg)
raise TokenRegistrationError(msg)
self.root_task()
