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()
