def _run(self) -> None: # pylint: disable=method-hidden register_error_handler() try: self.matrix_listener.start() except ConnectionError as exc: log.critical("Could not connect to broadcasting system.", exc=exc) sys.exit(1) log.info( "Listening to token network registry", registry_address=self.registry_address, start_block=self.database.get_latest_known_block(), ) while not self._is_running.is_set(): last_confirmed_block = self.web3.eth.blockNumber - self._required_confirmations max_query_interval_end_block = ( self.database.get_latest_known_block() + MAX_FILTER_INTERVAL) # Limit the max number of blocks that is processed per iteration last_block = min(last_confirmed_block, max_query_interval_end_block) self._process_new_blocks(last_block) try: gevent.sleep(self._poll_interval) except KeyboardInterrupt: log.info("Shutting down") sys.exit(0)
def __init__(self, config, chain, default_registry, transport, discovery=None): register_error_handler(greenlet_error_handler) self.config = config self.discovery = discovery try: self.raiden = RaidenService( chain, default_registry, unhexlify(config['privatekey_hex']), transport, config, discovery, ) except filelock.Timeout: pubkey = address_encoder( privatekey_to_address(unhexlify(self.config['privatekey_hex'])) ) print( f'FATAL: Another Raiden instance already running for account {pubkey} on ' f'network id {chain.network_id}' ) sys.exit(1) self.start_console = self.config['console'] # raiden.ui.console:Console assumes that a services # attribute is available for auto-registration self.services = dict()
def _run(self) -> None: # pylint: disable=method-hidden register_error_handler() try: self.matrix_listener.start() except ConnectionError as exc: log.critical("Could not connect to broadcasting system.", exc=exc) sys.exit(1)
def _run(self): register_error_handler(error_handler) self.transport.start() self.token_network_listener.start() if self.token_network_registry_listener: self.token_network_registry_listener.start() self.is_running.wait()
def _run(self): register_error_handler(error_handler) if self.token_network_registry_listener is not None: self.token_network_registry_listener.start() if self.endpoint_registry_listener is not None: self.endpoint_registry_listener.start() self.is_running.wait()
def _run(self) -> None: # pylint: disable=method-hidden register_error_handler() try: self.matrix_listener.start() self.matrix_listener.startup_finished.wait( timeout=MATRIX_START_TIMEOUT) except (Timeout, ConnectionError) as exc: log.critical("Could not connect to broadcasting system.", exc=exc) sys.exit(1)
def _run(self): register_error_handler(error_handler) self.token_network_listener.start() # this loop will wait until spawned greenlets complete while self.stop_event.is_set() is False: tasks = gevent.wait(self.task_list, timeout=5, count=1) if len(tasks) == 0: gevent.sleep(1) continue task = tasks[0] log.info('%s completed (%s)' % (task, task.value)) self.task_list.remove(task)
def _run(self) -> None: # pylint: disable=method-hidden register_error_handler(error_handler) self.matrix_listener.start() while not self.is_running.is_set(): last_confirmed_block = self.web3.eth.blockNumber - self.required_confirmations max_query_interval_end_block = ( self.blockchain_state.latest_known_block + MAX_FILTER_INTERVAL ) # Limit the max number of blocks that is processed per iteration last_block = min(last_confirmed_block, max_query_interval_end_block) self._process_new_blocks(last_block) try: gevent.sleep(self.poll_interval) except KeyboardInterrupt: log.info('Shutting down') sys.exit(0)
def _run(self): register_error_handler(error_handler) self.transport.start() self.blockchain.start() self.blockchain.register_handler( EVENT_CHANNEL_CLOSE, lambda event, tx: self.on_channel_close(event, tx)) self.blockchain.register_handler( EVENT_CHANNEL_SETTLED, lambda event, tx: self.on_channel_settled(event, tx)) self.blockchain.register_handler( EVENT_TRANSFER_UPDATED, lambda event, tx: self.on_transfer_updated(event, tx)) # this loop will wait until spawned greenlets complete while self.stop_event.is_set() is False: tasks = gevent.wait(self.task_list, timeout=5, count=1) if len(tasks) == 0: gevent.sleep(5) continue task = tasks[0] self.task_list.remove(task)
def _run(self): register_error_handler(error_handler) self.matrix_listener.start() self.token_network_registry_listener.start() self.is_running.wait()
def _run(self) -> None: # pylint: disable=method-hidden register_error_handler(error_handler) self.matrix_listener.start()
def _run(self): register_error_handler(error_handler) self.matrix_listener.start()