class ScenarioRunner(object): def __init__( self, account: Account, chain_urls: Dict[str, List[str]], auth: str, data_path: Path, scenario_file: Path, ): from scenario_player.tasks.base import get_task_class_for_type from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.task_count = 0 self.running_task_count = 0 self.auth = auth self.release_keeper = RaidenReleaseKeeper( data_path.joinpath('raiden_releases')) self.task_cache = {} self.task_storage = defaultdict(dict) self.scenario_name = os.path.basename( scenario_file.name).partition('.')[0] self.scenario = yaml.load(scenario_file) self.scenario_version = self.scenario.get('version', 1) if self.scenario_version not in SUPPORTED_SCENARIO_VERSIONS: raise ScenarioError( f'Unexpected scenario version {self.scenario_version}') self.data_path = data_path.joinpath('scenarios', self.scenario_name) self.data_path.mkdir(exist_ok=True, parents=True) log.debug('Data path', path=self.data_path) self.run_number = 0 run_number_file = self.data_path.joinpath('run_number.txt') if run_number_file.exists(): self.run_number = int(run_number_file.read_text()) + 1 run_number_file.write_text(str(self.run_number)) log.info('Run number', run_number=self.run_number) nodes = self.scenario['nodes'] node_mode = NodeMode.EXTERNAL.name if self.is_v2: node_mode = nodes.get('mode', '').upper() if not node_mode: raise ScenarioError( 'Version 2 scenarios require a "mode" in the "nodes" section.' ) try: self.node_mode = NodeMode[node_mode] except KeyError: known_modes = ', '.join(mode.name.lower() for mode in NodeMode) raise ScenarioError( f'Unknown node mode "{node_mode}". Expected one of {known_modes}', ) from None if self.is_managed: self.node_controller = NodeController( self, nodes.get('raiden_version', 'LATEST'), nodes['count'], nodes.get('default_options', {}), nodes.get('node_options', {}), ) else: if 'range' in nodes: range_config = nodes['range'] template = range_config['template'] self.raiden_nodes = [ template.format(i) for i in range(range_config['first'], range_config['last'] + 1) ] else: self.raiden_nodes = nodes['list'] self.node_commands = nodes.get('commands', {}) settings = self.scenario.get('settings') if settings is None: settings = {} self.timeout = settings.get('timeout', TIMEOUT) if self.is_managed: self.protocol = 'http' if 'protocol' in settings: log.warning( 'The "protocol" setting is not supported in "managed" node mode.' ) else: self.protocol = settings.get('protocol', 'http') self.notification_email = settings.get('notify') self.chain_name = settings.get('chain', 'any') if self.chain_name == 'any': self.chain_name = random.choice(list(chain_urls.keys())) elif self.chain_name not in chain_urls: raise ScenarioError( f'The scenario requested chain "{self.chain_name}" for which no RPC-URL is known.', ) log.info('Using chain', chain=self.chain_name) self.eth_rpc_urls = chain_urls[self.chain_name] self.client = JSONRPCClient( Web3(HTTPProvider(chain_urls[self.chain_name][0])), privkey=account.privkey, gas_price_strategy=get_gas_price_strategy( settings.get('gas_price', 'fast')), ) self.chain_id = self.client.web3.net.version balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f'Insufficient balance ({balance / 10 ** 18} Eth) ' f'in account {to_checksum_address(account.address)} on chain "{self.chain_name}"', ) self.session = Session() # WTF? https://github.com/requests/requests/issues/2605 if auth: self.session.auth = tuple(auth.split(":")) self.session.mount('http', TimeOutHTTPAdapter(timeout=self.timeout)) self.session.mount('https', TimeOutHTTPAdapter(timeout=self.timeout)) self._node_to_address = None self.token_address = None 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) 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 register_token(self, token_address, node): try: base_url = API_URL_TOKENS.format(protocol=self.protocol, target_host=node) url = "{}/{}".format(base_url, token_address) log.info("Registering token with network", url=url) resp = self.session.put(url) code = resp.status_code msg = resp.text except RequestException as ex: code = -1 msg = str(ex) return code, msg def _spawn_and_wait(self, objects, callback): tasks = {obj: gevent.spawn(callback, obj) for obj in objects} gevent.joinall(tasks.values()) return {obj: task.get() for obj, task in tasks.items()} @property def is_v2(self): return self.scenario_version == 2 @property def is_managed(self): return self.node_mode is NodeMode.MANAGED def get_node_address(self, index): if self.is_managed: return self.node_controller[index].address else: return self.node_to_address[self.raiden_nodes[index]] def get_node_baseurl(self, index): if self.is_managed: return self.node_controller[index].base_url else: return self.raiden_nodes[index] # Legacy for 'external' nodes def _get_node_addresses(self, nodes): def cb(node): log.debug("Getting node address", node=node) url = API_URL_ADDRESS.format(protocol=self.protocol, target_host=node) log.debug("Requesting", url=url) try: resp = self.session.get(url) except RequestException: log.error("Error fetching node address", url=url, node=node) return try: return resp.json().get('our_address', '') except ValueError: log.error( "Error decoding response", response=resp.text, code=resp.status_code, url=url, ) ret = self._spawn_and_wait(nodes, cb) return ret @property def node_to_address(self): if not self.raiden_nodes: return {} if self._node_to_address is None: self._node_to_address = { node: address for node, address in self._get_node_addresses( self.raiden_nodes).items() } return self._node_to_address
def __init__( self, account: Account, chain_urls: Dict[str, List[str]], auth: str, data_path: Path, scenario_file: Path, ): from scenario_player.tasks.base import get_task_class_for_type from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.task_count = 0 self.running_task_count = 0 self.auth = auth self.release_keeper = RaidenReleaseKeeper( data_path.joinpath('raiden_releases')) self.task_cache = {} self.task_storage = defaultdict(dict) self.scenario_name = os.path.basename( scenario_file.name).partition('.')[0] self.scenario = yaml.load(scenario_file) self.scenario_version = self.scenario.get('version', 1) if self.scenario_version not in SUPPORTED_SCENARIO_VERSIONS: raise ScenarioError( f'Unexpected scenario version {self.scenario_version}') self.data_path = data_path.joinpath('scenarios', self.scenario_name) self.data_path.mkdir(exist_ok=True, parents=True) log.debug('Data path', path=self.data_path) self.run_number = 0 run_number_file = self.data_path.joinpath('run_number.txt') if run_number_file.exists(): self.run_number = int(run_number_file.read_text()) + 1 run_number_file.write_text(str(self.run_number)) log.info('Run number', run_number=self.run_number) nodes = self.scenario['nodes'] node_mode = NodeMode.EXTERNAL.name if self.is_v2: node_mode = nodes.get('mode', '').upper() if not node_mode: raise ScenarioError( 'Version 2 scenarios require a "mode" in the "nodes" section.' ) try: self.node_mode = NodeMode[node_mode] except KeyError: known_modes = ', '.join(mode.name.lower() for mode in NodeMode) raise ScenarioError( f'Unknown node mode "{node_mode}". Expected one of {known_modes}', ) from None if self.is_managed: self.node_controller = NodeController( self, nodes.get('raiden_version', 'LATEST'), nodes['count'], nodes.get('default_options', {}), nodes.get('node_options', {}), ) else: if 'range' in nodes: range_config = nodes['range'] template = range_config['template'] self.raiden_nodes = [ template.format(i) for i in range(range_config['first'], range_config['last'] + 1) ] else: self.raiden_nodes = nodes['list'] self.node_commands = nodes.get('commands', {}) settings = self.scenario.get('settings') if settings is None: settings = {} self.timeout = settings.get('timeout', TIMEOUT) if self.is_managed: self.protocol = 'http' if 'protocol' in settings: log.warning( 'The "protocol" setting is not supported in "managed" node mode.' ) else: self.protocol = settings.get('protocol', 'http') self.notification_email = settings.get('notify') self.chain_name = settings.get('chain', 'any') if self.chain_name == 'any': self.chain_name = random.choice(list(chain_urls.keys())) elif self.chain_name not in chain_urls: raise ScenarioError( f'The scenario requested chain "{self.chain_name}" for which no RPC-URL is known.', ) log.info('Using chain', chain=self.chain_name) self.eth_rpc_urls = chain_urls[self.chain_name] self.client = JSONRPCClient( Web3(HTTPProvider(chain_urls[self.chain_name][0])), privkey=account.privkey, gas_price_strategy=get_gas_price_strategy( settings.get('gas_price', 'fast')), ) self.chain_id = self.client.web3.net.version balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f'Insufficient balance ({balance / 10 ** 18} Eth) ' f'in account {to_checksum_address(account.address)} on chain "{self.chain_name}"', ) self.session = Session() # WTF? https://github.com/requests/requests/issues/2605 if auth: self.session.auth = tuple(auth.split(":")) self.session.mount('http', TimeOutHTTPAdapter(timeout=self.timeout)) self.session.mount('https', TimeOutHTTPAdapter(timeout=self.timeout)) self._node_to_address = None self.token_address = None 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)
class ScenarioRunner: def __init__( self, account: Account, chain_urls: Dict[str, List[str]], auth: str, data_path: Path, scenario_file: Path, task_state_callback: Optional[ Callable[["ScenarioRunner", "Task", "TaskState"], None] ] = None, ): from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.auth = auth self.release_keeper = RaidenReleaseKeeper(data_path.joinpath("raiden_releases")) self.task_count = 0 self.running_task_count = 0 self.task_cache = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage = defaultdict(dict) scenario_name = scenario_file.stem self.data_path = data_path.joinpath("scenarios", scenario_name) self.data_path.mkdir(exist_ok=True, parents=True) self.yaml = ScenarioYAML(scenario_file, self.data_path) log.debug("Data path", path=self.data_path) # Determining the run number requires :attr:`.data_path` self.run_number = self.determine_run_number() self.node_controller = NodeController(self, self.yaml.nodes) self.protocol = "http" self.gas_limit = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL * 2 self.chain_name, chain_urls = self.select_chain(chain_urls) self.eth_rpc_urls = chain_urls self.client = JSONRPCClient( Web3(HTTPProvider(chain_urls[0])), privkey=account.privkey, gas_price_strategy=self.yaml.settings.gas_price_strategy, ) self.chain_id = int(self.client.web3.net.version) self.contract_manager = ContractManager(contracts_precompiled_path()) balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f'in account {to_checksum_address(account.address)} on chain "{self.chain_name}"' ) self.session = Session() if auth: self.session.auth = tuple(auth.split(":")) self.session.mount("http", TimeOutHTTPAdapter(timeout=self.yaml.settings.timeout)) self.session.mount("https", TimeOutHTTPAdapter(timeout=self.yaml.settings.timeout)) self.service_session = ServiceInterface(self.yaml.spaas) # Request an RPC Client instance ID from the RPC service and assign it to the runner. assign_rpc_instance_id(self, chain_urls[0], account.privkey, self.yaml.settings.gas_price) self.token = Token(self, data_path) self.udc = None self.token_network_address = None task_config = self.yaml.scenario.root_config task_class = self.yaml.scenario.root_class self.root_task = task_class(runner=self, config=task_config) def determine_run_number(self) -> int: """Determine the current run number. We check for a run number file, and use any number that is logged there after incrementing it. REFAC: Replace this with a property. """ run_number = 0 run_number_file = self.data_path.joinpath("run_number.txt") if run_number_file.exists(): run_number = int(run_number_file.read_text()) + 1 run_number_file.write_text(str(run_number)) log.info("Run number", run_number=run_number) return run_number def select_chain(self, chain_urls: Dict[str, List[str]]) -> Tuple[str, List[str]]: """Select a chain and return its name and RPC URL. If the currently loaded scenario's designated chain is set to 'any', we randomly select a chain from the given `chain_urls`. Otherwise, we will return `ScenarioRunner.scenario.chain_name` and whatever value may be associated with this key in `chain_urls`. :raises ScenarioError: if ScenarioRunner.scenario.chain_name is not one of `('any', 'Any', 'ANY')` and it is not a key in `chain_urls`. """ chain_name = self.yaml.settings.chain if chain_name in ("any", "Any", "ANY"): chain_name = random.choice(list(chain_urls.keys())) log.info("Using chain", chain=chain_name) try: return chain_name, chain_urls[chain_name] except KeyError: raise ScenarioError( f'The scenario requested chain "{chain_name}" for which no RPC-URL is known.' ) def wait_for_token_network_discovery(self, node): """Check for token network discovery with the given `node`. By default exit the wait if the token has not been discovered after `n` seconds, where `n` is the value of :attr:`.timeout`. :raises TokenNetworkDiscoveryTimeout: If we waited a set time for the token network to be discovered, but it wasn't. """ log.info("Waiting till new network is found by nodes") node_endpoint = API_URL_TOKEN_NETWORK_ADDRESS.format( protocol=self.protocol, target_host=node, token_address=self.token.address ) started = time.monotonic() elapsed = 0 while elapsed < self.yaml.settings.timeout: try: resp = self.session.get(node_endpoint) resp.raise_for_status() except HTTPError as e: # We explicitly handle 404 Not Found responses only - anything else is none # of our business. if e.response.status_code != 404: raise # Wait before continuing, no sense in spamming the node. gevent.sleep(1) # Update our elapsed time tracker. elapsed = time.monotonic() - started continue else: # The node appears to have discovered our token network. data = resp.json() if not is_checksum_address(data): # Something's amiss about this response. Notify a human. raise TypeError(f"Unexpected response type from API: {data!r}") return data # We could not assert that our token network was registered within an # acceptable time frame. raise TokenNetworkDiscoveryTimeout def run_scenario(self): mint_gas = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL * 2 fund_tx, node_starter, node_addresses, node_count = self._initialize_nodes() ud_token_tx, udc_ctr, should_deposit_ud_token = self._initialize_udc( gas_limit=mint_gas, node_count=node_count ) mint_tx = self._initialize_scenario_token( node_addresses=node_addresses, udc_ctr=udc_ctr, should_deposit_ud_token=should_deposit_ud_token, gas_limit=mint_gas, ) wait_for_txs(self.client, fund_tx | ud_token_tx | mint_tx) if node_starter is not None: log.debug("Waiting for nodes to finish starting") node_starter.get(block=True) first_node = self.get_node_baseurl(0) registered_tokens = set( self.session.get( API_URL_TOKENS.format(protocol=self.protocol, target_host=first_node) ).json() ) if self.token.checksum_address not in registered_tokens: for _ in range(5): code, msg = self.register_token(self.token.checksum_address, first_node) if 199 < code < 300: break gevent.sleep(1) else: log.error("Couldn't register token with network", code=code, message=msg) raise TokenRegistrationError(msg) last_node = self.node_controller[-1].base_url self.token_network_address = self.wait_for_token_network_discovery(last_node) log.info( "Received token network address", token_network_address=self.token_network_address ) # Start root task root_task_greenlet = gevent.spawn(self.root_task) greenlets = {root_task_greenlet} greenlets.add(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 _initialize_scenario_token( self, node_addresses: Set[ChecksumAddress], udc_ctr: Optional[ContractProxy], should_deposit_ud_token: bool, gas_limit: int, ) -> Set[TransactionHash]: """Deploy new token to the blockchain, or load an existing one's data from disk.""" self.token.init() mint_tx = set() for address in node_addresses: tx = self.token.mint(address) if tx: mint_tx.add(tx) if not should_deposit_ud_token: continue deposit_tx = self.udc.deposit(address) if deposit_tx: mint_tx.add(deposit_tx) return mint_tx def _initialize_udc( self, gas_limit: int, node_count: int ) -> Tuple[Set[TransactionHash], Optional[ContractProxy], bool]: our_address = to_checksum_address(self.client.address) udc_settings = self.yaml.settings.services.udc udc_enabled = udc_settings.enable ud_token_tx = set() if not udc_enabled: return ud_token_tx, None, False udc_ctr, ud_token_ctr = get_udc_and_token(self) ud_token_address = to_checksum_address(ud_token_ctr.contract_address) udc_address = to_checksum_address(udc_ctr.contract_address) log.info("UDC enabled", contract_address=udc_address, token_address=ud_token_address) self.udc = UserDepositContract(self, udc_ctr, ud_token_ctr) should_deposit_ud_token = udc_enabled and udc_settings.token["deposit"] allowance_tx = self.udc.update_allowance() if allowance_tx: ud_token_tx.add(allowance_tx) if should_deposit_ud_token: tx = self.udc.mint(our_address) if tx: ud_token_tx.add(tx) return ud_token_tx, udc_ctr, should_deposit_ud_token def _initialize_nodes( self ) -> Tuple[Set[TransactionHash], gevent.Greenlet, Set[ChecksumAddress], int]: fund_tx = set() self.node_controller.initialize_nodes() node_addresses = self.node_controller.addresses node_count = len(self.node_controller) balance_per_node = {address: self.client.balance(address) for address in node_addresses} low_balances = { address: balance for address, balance in balance_per_node.items() if balance < NODE_ACCOUNT_BALANCE_MIN } if low_balances: log.info("Funding nodes", nodes=low_balances.keys()) fund_tx = set() for address, balance in low_balances.items(): params = { "client_id": self.yaml.spaas.rpc.client_id, "to": address, "value": NODE_ACCOUNT_BALANCE_FUND - balance, "startgas": 21_000, } resp = self.service_session.post("spaas://rpc/transactions", json=params) tx_hash = resp.json()["tx_hash"] fund_tx.add(tx_hash) node_starter = self.node_controller.start(wait=False) return fund_tx, node_starter, node_addresses, node_count def task_state_changed(self, task: "Task", state: "TaskState"): if self.task_state_callback: self.task_state_callback(self, task, state) def register_token(self, token_address, node): # TODO: Move this to :class:`scenario_player.utils.token.Token`. try: base_url = API_URL_TOKENS.format(protocol=self.protocol, target_host=node) url = "{}/{}".format(base_url, token_address) log.info("Registering token with network", url=url) resp = self.session.put(url) code = resp.status_code msg = resp.text except RequestException as ex: code = -1 msg = str(ex) return code, msg @staticmethod def _spawn_and_wait(objects, callback): tasks = {obj: gevent.spawn(callback, obj) for obj in objects} gevent.joinall(set(tasks.values())) return {obj: task.get() for obj, task in tasks.items()} def get_node_address(self, index): return self.node_controller[index].address def get_node_baseurl(self, index): return self.node_controller[index].base_url
def __init__( self, account: Account, chain_urls: Dict[str, List[str]], auth: str, data_path: Path, scenario_file: Path, task_state_callback: Optional[ Callable[["ScenarioRunner", "Task", "TaskState"], None] ] = None, ): from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.auth = auth self.release_keeper = RaidenReleaseKeeper(data_path.joinpath("raiden_releases")) self.task_count = 0 self.running_task_count = 0 self.task_cache = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage = defaultdict(dict) scenario_name = scenario_file.stem self.data_path = data_path.joinpath("scenarios", scenario_name) self.data_path.mkdir(exist_ok=True, parents=True) self.yaml = ScenarioYAML(scenario_file, self.data_path) log.debug("Data path", path=self.data_path) # Determining the run number requires :attr:`.data_path` self.run_number = self.determine_run_number() self.node_controller = NodeController(self, self.yaml.nodes) self.protocol = "http" self.gas_limit = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL * 2 self.chain_name, chain_urls = self.select_chain(chain_urls) self.eth_rpc_urls = chain_urls self.client = JSONRPCClient( Web3(HTTPProvider(chain_urls[0])), privkey=account.privkey, gas_price_strategy=self.yaml.settings.gas_price_strategy, ) self.chain_id = int(self.client.web3.net.version) self.contract_manager = ContractManager(contracts_precompiled_path()) balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f'in account {to_checksum_address(account.address)} on chain "{self.chain_name}"' ) self.session = Session() if auth: self.session.auth = tuple(auth.split(":")) self.session.mount("http", TimeOutHTTPAdapter(timeout=self.yaml.settings.timeout)) self.session.mount("https", TimeOutHTTPAdapter(timeout=self.yaml.settings.timeout)) self.service_session = ServiceInterface(self.yaml.spaas) # Request an RPC Client instance ID from the RPC service and assign it to the runner. assign_rpc_instance_id(self, chain_urls[0], account.privkey, self.yaml.settings.gas_price) self.token = Token(self, data_path) self.udc = None self.token_network_address = None task_config = self.yaml.scenario.root_config task_class = self.yaml.scenario.root_class self.root_task = task_class(runner=self, config=task_config)
def __init__( self, account: Account, chain_urls: Dict[str, List[str]], auth: str, data_path: Path, scenario_file: Path, task_state_callback: Optional[Callable[ ["ScenarioRunner", Task, TaskState], None]] = None, ): from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.task_count = 0 self.running_task_count = 0 self.auth = auth self.release_keeper = RaidenReleaseKeeper( data_path.joinpath("raiden_releases")) self.task_cache = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage = defaultdict(dict) self.scenario = Scenario(scenario_file) self.scenario_name = self.scenario.name self.data_path = data_path.joinpath("scenarios", self.scenario.name) self.data_path.mkdir(exist_ok=True, parents=True) log.debug("Data path", path=self.data_path) self.run_number = self.determine_run_number() self.node_mode = self.scenario.nodes.mode if self.is_managed: self.node_controller = NodeController( self, self.scenario.nodes.raiden_version, self.scenario.nodes.count, self.scenario.nodes.default_options, self.scenario.nodes.node_options, ) else: self.raiden_nodes = self.scenario.nodes self.node_commands = self.scenario.nodes.commands self.timeout = self.scenario.timeout self.protocol = self.scenario.protocol self.notification_email = self.scenario.notification_email self.chain_name, chain_urls = self.select_chain(chain_urls) self.eth_rpc_urls = chain_urls self.client = JSONRPCClient( Web3(HTTPProvider(chain_urls[0])), privkey=account.privkey, gas_price_strategy=self.scenario.gas_price_strategy, ) self.chain_id = int(self.client.web3.net.version) self.contract_manager = ContractManager(contracts_precompiled_path()) balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f'in account {to_checksum_address(account.address)} on chain "{self.chain_name}"' ) self.session = Session() if auth: self.session.auth = tuple(auth.split(":")) self.session.mount("http", TimeOutHTTPAdapter(timeout=self.timeout)) self.session.mount("https", TimeOutHTTPAdapter(timeout=self.timeout)) self._node_to_address = None self.token_address = None self.token_deployment_block = 0 self.token_network_address = None task_config = self.scenario.task_config task_class = self.scenario.task_class self.root_task = task_class(runner=self, config=task_config)
class ScenarioRunner: # TODO: #73 Drop support for version 1 scenario files. def __init__( self, account: Account, chain_urls: Dict[str, List[str]], auth: str, data_path: Path, scenario_file: Path, task_state_callback: Optional[Callable[ ["ScenarioRunner", Task, TaskState], None]] = None, ): from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.task_count = 0 self.running_task_count = 0 self.auth = auth self.release_keeper = RaidenReleaseKeeper( data_path.joinpath("raiden_releases")) self.task_cache = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage = defaultdict(dict) self.scenario = Scenario(scenario_file) self.scenario_name = self.scenario.name self.data_path = data_path.joinpath("scenarios", self.scenario.name) self.data_path.mkdir(exist_ok=True, parents=True) log.debug("Data path", path=self.data_path) self.run_number = self.determine_run_number() self.node_mode = self.scenario.nodes.mode if self.is_managed: self.node_controller = NodeController( self, self.scenario.nodes.raiden_version, self.scenario.nodes.count, self.scenario.nodes.default_options, self.scenario.nodes.node_options, ) else: self.raiden_nodes = self.scenario.nodes self.node_commands = self.scenario.nodes.commands self.timeout = self.scenario.timeout self.protocol = self.scenario.protocol self.notification_email = self.scenario.notification_email self.chain_name, chain_urls = self.select_chain(chain_urls) self.eth_rpc_urls = chain_urls self.client = JSONRPCClient( Web3(HTTPProvider(chain_urls[0])), privkey=account.privkey, gas_price_strategy=self.scenario.gas_price_strategy, ) self.chain_id = int(self.client.web3.net.version) self.contract_manager = ContractManager(contracts_precompiled_path()) balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f'in account {to_checksum_address(account.address)} on chain "{self.chain_name}"' ) self.session = Session() if auth: self.session.auth = tuple(auth.split(":")) self.session.mount("http", TimeOutHTTPAdapter(timeout=self.timeout)) self.session.mount("https", TimeOutHTTPAdapter(timeout=self.timeout)) self._node_to_address = None self.token_address = None self.token_deployment_block = 0 self.token_network_address = None task_config = self.scenario.task_config task_class = self.scenario.task_class self.root_task = task_class(runner=self, config=task_config) def determine_run_number(self) -> int: """Determine the current run number. We check for a run number file, and use any number that is logged there after incrementing it. REFAC: Replace this with a property. """ run_number = 0 run_number_file = self.data_path.joinpath("run_number.txt") if run_number_file.exists(): run_number = int(run_number_file.read_text()) + 1 run_number_file.write_text(str(run_number)) log.info("Run number", run_number=run_number) return run_number def select_chain( self, chain_urls: Dict[str, List[str]]) -> Tuple[str, List[str]]: """Select a chain and return its name and RPC URL. If the currently loaded scenario's designated chain is set to 'any', we randomly select a chain from the given `chain_urls`. Otherwise, we will return `ScenarioRunner.scenario.chain_name` and whatever value may be associated with this key in `chain_urls`. :raises ScenarioError: if ScenarioRunner.scenario.chain_name is not one of `('any', 'Any', 'ANY')` and it is not a key in `chain_urls`. """ chain_name = self.scenario.chain_name if chain_name in ("any", "Any", "ANY"): chain_name = random.choice(list(chain_urls.keys())) log.info("Using chain", chain=chain_name) try: return chain_name, chain_urls[chain_name] except KeyError: raise ScenarioError( f'The scenario requested chain "{chain_name}" for which no RPC-URL is known.' ) def run_scenario(self): mint_gas = GAS_LIMIT_FOR_TOKEN_CONTRACT_CALL * 2 fund_tx, node_starter, node_addresses, node_count = self._initialize_nodes( ) ud_token_tx, udc_ctr, should_deposit_ud_token = self._initialize_udc( gas_limit=mint_gas, node_count=node_count) mint_tx = self._initialize_scenario_token( node_addresses=node_addresses, udc_ctr=udc_ctr, should_deposit_ud_token=should_deposit_ud_token, gas_limit=mint_gas, ) wait_for_txs(self.client, fund_tx | ud_token_tx | mint_tx) if node_starter is not None: log.debug("Waiting for nodes to finish starting") node_starter.get(block=True) first_node = self.get_node_baseurl(0) registered_tokens = set( self.session.get( API_URL_TOKENS.format(protocol=self.protocol, target_host=first_node)).json()) if self.token_address not in registered_tokens: for _ in range(5): code, msg = self.register_token(self.token_address, first_node) if 199 < code < 300: break gevent.sleep(1) else: log.error("Couldn't register token with network", code=code, message=msg) raise TokenRegistrationError(msg) # The nodes need some time to find the token, see # https://github.com/raiden-network/raiden/issues/3544 # FIXME: Add proper check via API log.info("Waiting till new network is found by nodes") while self.token_network_address is None: self.token_network_address = self.session.get( API_URL_TOKEN_NETWORK_ADDRESS.format( protocol=self.protocol, target_host=first_node, token_address=self.token_address, )).json() gevent.sleep(1) log.info("Received token network address", token_network_address=self.token_network_address) # Start root task root_task_greenlet = gevent.spawn(self.root_task) greenlets = {root_task_greenlet} if self.is_managed: greenlets.add(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 _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 _initialize_udc( self, gas_limit: int, node_count: int ) -> Tuple[Set[TransactionHash], Optional[ContractProxy], bool]: our_address = to_checksum_address(self.client.address) udc_settings = self.scenario.services.get("udc", {}) udc_enabled = udc_settings.get("enable") ud_token_tx = set() if not udc_enabled: return ud_token_tx, None, False udc_ctr, ud_token_ctr = get_udc_and_token(self) ud_token_address = to_checksum_address(ud_token_ctr.contract_address) udc_address = to_checksum_address(udc_ctr.contract_address) log.info("UDC enabled", contract_address=udc_address, token_address=ud_token_address) should_deposit_ud_token = udc_enabled and udc_settings.get( "token", {}).get("deposit", False) if should_deposit_ud_token: tx = mint_token_if_balance_low( token_contract=ud_token_ctr, target_address=our_address, min_balance=DEFAULT_TOKEN_BALANCE_FUND * node_count, fund_amount=DEFAULT_TOKEN_BALANCE_FUND * 10 * node_count, gas_limit=gas_limit, mint_msg="Minting UD tokens", no_action_msg="UD token balance sufficient", ) if tx: ud_token_tx.add(tx) udt_allowance = ud_token_ctr.contract.functions.allowance( our_address, udc_address).call() if udt_allowance < DEFAULT_TOKEN_BALANCE_FUND * node_count: allow_amount = (DEFAULT_TOKEN_BALANCE_FUND * 10 * node_count) - udt_allowance log.debug("Updating UD token allowance", allowance=allow_amount) ud_token_tx.add( ud_token_ctr.transact("approve", gas_limit, udc_address, allow_amount)) else: log.debug("UD token allowance sufficient", allowance=udt_allowance) return ud_token_tx, udc_ctr, should_deposit_ud_token def _initialize_nodes( self ) -> Tuple[Set[TransactionHash], gevent.Greenlet, Set[ChecksumAddress], int]: fund_tx = set() node_starter: gevent.Greenlet = None if self.is_managed: self.node_controller.initialize_nodes() node_addresses = self.node_controller.addresses node_count = len(self.node_controller) 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=21_000, 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)}") node_addresses = set(self.node_to_address.values()) node_count = len(self.node_to_address) return fund_tx, node_starter, node_addresses, node_count def task_state_changed(self, task: "Task", state: "TaskState"): if self.task_state_callback: self.task_state_callback(self, task, state) def register_token(self, token_address, node): try: base_url = API_URL_TOKENS.format(protocol=self.protocol, target_host=node) url = "{}/{}".format(base_url, token_address) log.info("Registering token with network", url=url) resp = self.session.put(url) code = resp.status_code msg = resp.text except RequestException as ex: code = -1 msg = str(ex) return code, msg @staticmethod def _spawn_and_wait(objects, callback): tasks = {obj: gevent.spawn(callback, obj) for obj in objects} gevent.joinall(set(tasks.values())) return {obj: task.get() for obj, task in tasks.items()} @property def is_managed(self): return self.node_mode is NodeMode.MANAGED def get_node_address(self, index): if self.is_managed: return self.node_controller[index].address else: return self.node_to_address[self.raiden_nodes[index]] def get_node_baseurl(self, index): if self.is_managed: return self.node_controller[index].base_url else: return self.raiden_nodes[index] # Legacy for 'external' nodes def _get_node_addresses(self, nodes): def cb(node): log.debug("Getting node address", node=node) url = API_URL_ADDRESS.format(protocol=self.protocol, target_host=node) log.debug("Requesting", url=url) try: resp = self.session.get(url) except RequestException: log.error("Error fetching node address", url=url, node=node) return None try: return to_checksum_address(resp.json().get("our_address", "")) except ValueError: log.error("Error decoding response", response=resp.text, code=resp.status_code, url=url) return None ret = self._spawn_and_wait(nodes, cb) return ret @property def node_to_address(self) -> Dict[str, ChecksumAddress]: if not self.raiden_nodes: return {} if self._node_to_address is None: self._node_to_address = { node: address for node, address in self._get_node_addresses( self.raiden_nodes).items() } return self._node_to_address
def __init__( self, account: Account, auth: str, chain: str, data_path: Union[Path, str], scenario_file: Path, task_state_callback: Optional[ Callable[["ScenarioRunner", "Task", "TaskState"], None] ] = None, ): from scenario_player.node_support import RaidenReleaseKeeper, NodeController self.auth = auth self.release_keeper = RaidenReleaseKeeper(data_path.joinpath("raiden_releases")) self.task_count = 0 self.running_task_count = 0 self.task_cache = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage = defaultdict(dict) self.definition = ScenarioDefinition(scenario_file, data_path) log.debug("Local seed", seed=self.local_seed) self.run_number = self.determine_run_number() self.node_controller = NodeController(self, self.definition.nodes) self.protocol = "http" if chain: name, endpoint = chain.split(":", maxsplit=1) # Set CLI overrides. self.definition.settings._cli_chain = name self.definition.settings._cli_rpc_address = endpoint self.client = JSONRPCClient( Web3(HTTPProvider(self.definition.settings.eth_client_rpc_address)), privkey=account.privkey, gas_price_strategy=self.definition.settings.gas_price_strategy, ) self.definition.settings.chain_id = int(self.client.web3.net.version) self.contract_manager = ContractManager(contracts_precompiled_path()) balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f"in account {to_checksum_address(account.address)} " f'on chain "{self.definition.settings.chain}"' f" - it needs additional {(OWN_ACCOUNT_BALANCE_MIN - balance) / 10 ** 18} Eth (" f"that is {OWN_ACCOUNT_BALANCE_MIN - balance} Wei)." ) self.session = Session() if auth: self.session.auth = tuple(auth.split(":")) self.session.mount("http", TimeOutHTTPAdapter(timeout=self.definition.settings.timeout)) self.session.mount("https", TimeOutHTTPAdapter(timeout=self.definition.settings.timeout)) self.service_session = ServiceInterface(self.definition.spaas) # Assign an RPC Client instance ID on the RPC service, for this run. self.definition.spaas.rpc.assign_rpc_instance( self, account.privkey, self.definition.settings.gas_price ) self.token = Token(self, data_path) self.udc = None self.token_network_address = None task_config = self.definition.scenario.root_config task_class = self.definition.scenario.root_class self.root_task = task_class(runner=self, config=task_config)
def __init__( self, account: Account, auth: str, data_path: Path, scenario_file: Path, environment: EnvironmentConfig, success: Event, raiden_client: Optional[str], task_state_callback: Optional[ Callable[["ScenarioRunner", "Task", "TaskState"], None] ] = None, smoketest_deployment_data: DeployedContracts = None, delete_snapshots: bool = False, ) -> None: self.success = success self.smoketest_deployment_data = smoketest_deployment_data self.delete_snapshots = delete_snapshots self.data_path = data_path self.environment = environment # Set the client executable to use if raiden_client is not None: self.environment.raiden_client = raiden_client self.task_count = 0 self.running_task_count = 0 self.task_cache: Dict[str, Task] = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage: Dict[str, dict] = defaultdict(dict) self.definition = ScenarioDefinition(scenario_file, data_path, self.environment) log.debug("Local seed", seed=self.local_seed) self.run_number = determine_run_number(self.definition.scenario_dir) log.info("Run number", run_number=self.run_number) self.protocol = "http" self.session = make_session(auth, self.definition.settings, self.definition.nodes) web3 = Web3(HTTPProvider(environment.eth_rpc_endpoints[0], session=self.session)) self.chain_id = ChainID(web3.eth.chainId) self.definition.settings.eth_rpc_endpoint_iterator = environment.eth_rpc_endpoint_iterator self.definition.settings.chain_id = self.chain_id assert account.privkey, "Account not unlockable" self.client = JSONRPCClient( web3=web3, privkey=account.privkey, gas_price_strategy=faster_gas_price_strategy, block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS, ) assert account.address, "Account not loaded" balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f"in account {to_checksum_address(account.address)} " f'on chain "{self.definition.settings.chain_id}"' f" - it needs additional {(OWN_ACCOUNT_BALANCE_MIN - balance) / 10 ** 18} Eth (" f"that is {OWN_ACCOUNT_BALANCE_MIN - balance} Wei)." ) self.node_controller = NodeController( runner=self, config=self.definition.nodes, raiden_client=self.environment.raiden_client, delete_snapshots=self.delete_snapshots, ) task_config = self.definition.scenario.root_config task_class = self.definition.scenario.root_class self.root_task = task_class(runner=self, config=task_config)
class ScenarioRunner: def __init__( self, account: Account, auth: str, data_path: Path, scenario_file: Path, environment: EnvironmentConfig, success: Event, raiden_client: Optional[str], task_state_callback: Optional[ Callable[["ScenarioRunner", "Task", "TaskState"], None] ] = None, smoketest_deployment_data: DeployedContracts = None, delete_snapshots: bool = False, ) -> None: self.success = success self.smoketest_deployment_data = smoketest_deployment_data self.delete_snapshots = delete_snapshots self.data_path = data_path self.environment = environment # Set the client executable to use if raiden_client is not None: self.environment.raiden_client = raiden_client self.task_count = 0 self.running_task_count = 0 self.task_cache: Dict[str, Task] = {} self.task_state_callback = task_state_callback # Storage for arbitrary data tasks might need to persist self.task_storage: Dict[str, dict] = defaultdict(dict) self.definition = ScenarioDefinition(scenario_file, data_path, self.environment) log.debug("Local seed", seed=self.local_seed) self.run_number = determine_run_number(self.definition.scenario_dir) log.info("Run number", run_number=self.run_number) self.protocol = "http" self.session = make_session(auth, self.definition.settings, self.definition.nodes) web3 = Web3(HTTPProvider(environment.eth_rpc_endpoints[0], session=self.session)) self.chain_id = ChainID(web3.eth.chainId) self.definition.settings.eth_rpc_endpoint_iterator = environment.eth_rpc_endpoint_iterator self.definition.settings.chain_id = self.chain_id assert account.privkey, "Account not unlockable" self.client = JSONRPCClient( web3=web3, privkey=account.privkey, gas_price_strategy=faster_gas_price_strategy, block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS, ) assert account.address, "Account not loaded" balance = self.client.balance(account.address) if balance < OWN_ACCOUNT_BALANCE_MIN: raise ScenarioError( f"Insufficient balance ({balance / 10 ** 18} Eth) " f"in account {to_checksum_address(account.address)} " f'on chain "{self.definition.settings.chain_id}"' f" - it needs additional {(OWN_ACCOUNT_BALANCE_MIN - balance) / 10 ** 18} Eth (" f"that is {OWN_ACCOUNT_BALANCE_MIN - balance} Wei)." ) self.node_controller = NodeController( runner=self, config=self.definition.nodes, raiden_client=self.environment.raiden_client, delete_snapshots=self.delete_snapshots, ) task_config = self.definition.scenario.root_config task_class = self.definition.scenario.root_class self.root_task = task_class(runner=self, config=task_config) @property def local_seed(self) -> str: """Return a persistent random seed value. We need a unique seed per scenario player 'installation'. This is used in the node private key generation to prevent re-use of node keys between multiple users of the scenario player. The seed is stored in a file inside the ``.definition.settings.sp_root_dir``. """ assert self.definition.settings.sp_root_dir seed_file = self.definition.settings.sp_root_dir.joinpath("seed.txt") if not seed_file.exists(): seed = str(encode_hex(bytes(random.randint(0, 255) for _ in range(20)))) seed_file.write_text(seed) else: seed = seed_file.read_text().strip() return seed def ensure_token_network_discovery( self, token: CustomToken, token_network_addresses: TokenNetworkAddress ) -> None: """Ensure that all our nodes have discovered the same token network.""" for node in self.node_controller: # type: ignore node_endpoint = API_URL_TOKEN_NETWORK_ADDRESS.format( protocol=self.protocol, target_host=node.base_url, token_address=to_checksum_address(token.address), ) address = wait_for_token_network_discovery( node_endpoint, self.definition.settings, self.session ) if to_canonical_address(address) != Address(token_network_addresses): raise RuntimeError( f"Nodes diverged on the token network address, there should be " f"exactly one token network available for all nodes. Current " f"values : {to_hex(token_network_addresses)}" ) def run_scenario(self) -> None: with Janitor() as nursery: self.node_controller.set_nursery(nursery) self.node_controller.initialize_nodes() try: for node_runner in self.node_controller._node_runners: node_runner.start() except Exception: log.error("failed to start", exc_info=True) raise node_addresses = self.node_controller.addresses scenario = nursery.spawn_under_watch( self.setup_environment_and_run_main_task, node_addresses ) scenario.name = "orchestration" # Wait for either a crash in one of the Raiden nodes or for the # scenario to exit (successfully or not). greenlets = {scenario} gevent.joinall(greenlets, raise_error=True, count=1) self.success.set() def setup_environment_and_run_main_task(self, node_addresses: Set[ChecksumAddress]) -> None: """This will first make sure the on-chain state is setup properly, and then execute the scenario. The on-chain state consists of: - Deployment of the test CustomToken - For each of the Raiden nodes, make sure they have enough: - Ether to pay for the transactions. - Utility token balances in the user deposit smart contract. - Tokens to be used with the test token network. """ block_execution_started = self.client.block_number() settings = self.definition.settings udc_settings = settings.services.udc smoketesting = False if self.chain_id != CHAINNAME_TO_ID["smoketest"]: deploy = get_contracts_deployment_info( self.chain_id, RAIDEN_CONTRACT_VERSION, development_environment=self.environment.development_environment, ) else: smoketesting = True deploy = self.smoketest_deployment_data msg = "There is no deployment details for the given chain_id and contracts version pair" assert deploy, msg proxy_manager = get_proxy_manager(self.client, deploy) # Tracking pool to synchronize on all concurrent transactions pool = Pool() log.debug("Funding Raiden node's accounts with ether") self.setup_raiden_nodes_ether_balances(pool, node_addresses) if is_udc_enabled(udc_settings): ( userdeposit_proxy, user_token_proxy, ) = get_udc_and_corresponding_token_from_dependencies( udc_address=udc_settings.address, chain_id=settings.chain_id, proxy_manager=proxy_manager, development_environment=self.environment.development_environment, ) log.debug("Minting utility tokens and /scheduling/ transfers to the nodes") mint_greenlets = self.setup_mint_user_deposit_tokens_for_distribution( pool, userdeposit_proxy, user_token_proxy, node_addresses ) self.setup_raiden_nodes_with_sufficient_user_deposit_balances( pool, userdeposit_proxy, node_addresses, mint_greenlets ) # This is a blocking call. If the token has to be deployed it will # block until mined and confirmed, since that is a requirement for the # following setup calls. token_proxy = self.setup_token_contract_for_token_network(proxy_manager) if smoketesting: token_network_registry_proxy = get_token_network_registry_from_dependencies( settings=settings, proxy_manager=proxy_manager, smoketest_deployment_data=deploy, development_environment=self.environment.development_environment, ) else: token_network_registry_proxy = get_token_network_registry_from_dependencies( settings=settings, proxy_manager=proxy_manager, development_environment=self.environment.development_environment, ) self.setup_raiden_token_balances(pool, token_proxy, node_addresses) # Wait for all the transactions # - Move ether from the orcheastration account (the scenario player), # to the raiden nodes. # - Mint enough utility tokens (user deposit tokens) for the # orchestration account to transfer for the nodes. # - Mint network tokens for the nodes to use in the scenarion. # - Deposit utility tokens for the raiden nodes in the user deposit # contract. log.debug("Waiting for funding transactions to be mined") pool.join(raise_error=True) log.debug("Registering token to create the network") token_network_address = maybe_create_token_network( token_network_registry_proxy, token_proxy ) log.debug("Waiting for the REST APIs") wait_for_nodes_to_be_ready(self.node_controller._node_runners, self.session) log.info("Making sure all nodes have the same token network") self.ensure_token_network_discovery(token_proxy, token_network_address) log.info( "Setup done, running scenario", token_network_address=to_checksum_address(token_network_address), ) # Expose attributes used by the tasks self.token = token_proxy self.contract_manager = proxy_manager.contract_manager self.token_network_address = to_checksum_address(token_network_address) self.block_execution_started = block_execution_started self.root_task() def setup_raiden_nodes_ether_balances( self, pool: Pool, node_addresses: Set[ChecksumAddress] ) -> Set[Greenlet]: """ Makes sure every Raiden node has at least `NODE_ACCOUNT_BALANCE_MIN`. """ greenlets: Set[Greenlet] = set() for address in node_addresses: g = pool.spawn( eth_maybe_transfer, orchestration_client=self.client, target=to_canonical_address(address), minimum_balance=NODE_ACCOUNT_BALANCE_MIN, maximum_balance=NODE_ACCOUNT_BALANCE_FUND, ) greenlets.add(g) return greenlets def setup_mint_user_deposit_tokens_for_distribution( self, pool: Pool, userdeposit_proxy: UserDeposit, token_proxy: CustomToken, node_addresses: Set[ChecksumAddress], ) -> Set[Greenlet]: """Ensures the scenario player account has enough tokens and allowance to fund the Raiden nodes. """ settings = self.definition.settings udc_settings = settings.services.udc balance_per_node = settings.services.udc.token.balance_per_node msg = "udc is not enabled, this function should not be called" assert is_udc_enabled(udc_settings), msg node_count = len(node_addresses) required_allowance = balance_per_node * node_count allowance_greenlet = pool.spawn( userdeposit_maybe_increase_allowance, token_proxy=token_proxy, userdeposit_proxy=userdeposit_proxy, orchestrator_address=self.client.address, minimum_allowance=required_allowance, maximum_allowance=UINT256_MAX, ) mint_greenlet = pool.spawn( token_maybe_mint, token_proxy=token_proxy, target_address=to_checksum_address(self.client.address), minimum_balance=required_allowance, maximum_balance=ORCHESTRATION_MAXIMUM_BALANCE, ) return {allowance_greenlet, mint_greenlet} def setup_raiden_token_balances( self, pool: Pool, token_proxy: CustomToken, node_addresses: Set[ChecksumAddress] ) -> Set[Greenlet]: """Mint the necessary amount of tokens from `token_proxy` for every `node_addresses`. This will use the scenario player's account, therefore it doesn't have to wait for the ether transfers to finish. """ token_min_amount = self.definition.token.min_balance token_max_amount = self.definition.token.max_funding greenlets: Set[Greenlet] = set() for address in node_addresses: g = pool.spawn( token_maybe_mint, token_proxy=token_proxy, target_address=address, minimum_balance=token_min_amount, maximum_balance=token_max_amount, ) greenlets.add(g) return greenlets def setup_raiden_nodes_with_sufficient_user_deposit_balances( self, pool: Pool, userdeposit_proxy: UserDeposit, node_addresses: Set[ChecksumAddress], mint_greenlets: Set[Greenlet], ) -> Set[Greenlet]: """Makes sure every Raiden node's account has enough tokens in the user deposit contract. For these transfers to work, the approve and mint transacations have to be mined and confirmed. This is necessary because otherwise the gas estimation of the deposits fail. """ msg = "udc is not enabled, this function should not be called" assert is_udc_enabled(self.definition.settings.services.udc), msg minimum_effective_deposit = self.definition.settings.services.udc.token.balance_per_node maximum_funding = self.definition.settings.services.udc.token.max_funding log.debug("Depositing utility tokens for the nodes") greenlets: Set[Greenlet] = set() for address in node_addresses: g = pool.spawn( userdeposit_maybe_deposit, userdeposit_proxy=userdeposit_proxy, mint_greenlets=mint_greenlets, target_address=to_canonical_address(address), minimum_effective_deposit=minimum_effective_deposit, maximum_funding=maximum_funding, ) greenlets.add(g) return greenlets def setup_token_contract_for_token_network(self, proxy_manager: ProxyManager) -> CustomToken: """Ensure there is a deployed token contract and return a `CustomToken` proxy to it. This token will be used for the scenario's token network. This will either: - Use the token from the address provided in the scenario configuration. - Use a previously deployed token, with the details loaded from the disk. - Deploy a new token if neither of the above options is used. """ token_definition = self.definition.token reuse_token_from_file = token_definition.can_reuse_token if token_definition.address: token_address = to_canonical_address(token_definition.address) elif reuse_token_from_file: token_details = load_token_configuration_from_file(token_definition.token_file) token_address = to_canonical_address(token_details["address"]) else: contract_data = proxy_manager.contract_manager.get_contract(CONTRACT_CUSTOM_TOKEN) contract, receipt = self.client.deploy_single_contract( contract_name=CONTRACT_CUSTOM_TOKEN, contract=contract_data, constructor_parameters=( ORCHESTRATION_MAXIMUM_BALANCE, token_definition.decimals, token_definition.name, token_definition.symbol, ), ) token_address = to_canonical_address(contract.address) if token_definition.should_reuse_token: details = TokenDetails( { "name": token_definition.name, "address": to_checksum_address(token_address), "block": receipt["blockNumber"], } ) save_token_configuration_to_file(token_definition.token_file, details) return proxy_manager.custom_token(TokenAddress(token_address), "latest") def task_state_changed(self, task: "Task", state: "TaskState"): if self.task_state_callback: self.task_state_callback(self, task, state) def get_node_address(self, index): return self.node_controller[index].address def get_node_baseurl(self, index): return self.node_controller[index].base_url