def _setup_matrix(config):
if config["transport"]["matrix"].get("available_servers") is None:
# fetch list of known servers from raiden-network/raiden-tranport repo
available_servers_url = DEFAULT_MATRIX_KNOWN_SERVERS[config["environment_type"]]
available_servers = get_matrix_servers(available_servers_url)
log.debug("Fetching available matrix servers", available_servers=available_servers)
config["transport"]["matrix"]["available_servers"] = available_servers
# TODO: This needs to be adjusted once #3735 gets implemented
# Add PFS broadcast room if enabled
if config["services"]["pathfinding_service_address"] is not None:
if PATH_FINDING_BROADCASTING_ROOM not in config["transport"]["matrix"]["global_rooms"]:
config["transport"]["matrix"]["global_rooms"].append(PATH_FINDING_BROADCASTING_ROOM)
# Add monitoring service broadcast room if enabled
if config["services"]["monitoring_enabled"] is True:
config["transport"]["matrix"]["global_rooms"].append(MONITORING_BROADCASTING_ROOM)
try:
database_path = config["database_path"]
database_dir = os.path.dirname(config["database_path"])
os.makedirs(database_dir, exist_ok=True)
storage = sqlite.SerializedSQLiteStorage(
database_path=database_path, serializer=serialize.JSONSerializer()
)
light_clients = storage.get_all_light_clients()
light_client_transports = []
for light_client in light_clients:
light_client_transport = get_matrix_light_client_instance(config["transport"]["matrix"],
light_client['password'],
light_client['display_name'],
light_client['seed_retry'],
light_client['address'])
light_client_transports.append(light_client_transport)
hub_transport = MatrixTransport(config["transport"]["matrix"])
node_transport = NodeTransport(hub_transport, light_client_transports)
except RaidenError as ex:
click.secho(f"FATAL: {ex}", fg="red")
sys.exit(1)
return node_transport
def main(db_file, token_network_identifier, partner_address, names_translator):
if names_translator:
translator = Translator(json.load(names_translator))
lookup = {v: k for k, v in translator.items()}
token_network_identifier = lookup.get(token_network_identifier, token_network_identifier)
partner_address = lookup.get(partner_address, partner_address)
else:
translator = None
replay_wal(
storage=sqlite.SerializedSQLiteStorage(db_file, serialize.JSONSerializer()),
token_network_identifier=token_network_identifier,
partner_address=partner_address,
translator=translator,
)
def start(self):
""" Start the node synchronously. Raises directly if anything went wrong on startup """
if not self.stop_event.ready():
raise RuntimeError(f'{self!r} already started')
self.stop_event.clear()
if self.database_dir is not None:
self.db_lock.acquire(timeout=0)
assert self.db_lock.is_locked
# start the registration early to speed up the start
if self.config['transport_type'] == 'udp':
endpoint_registration_greenlet = gevent.spawn(
self.discovery.register,
self.address,
self.config['transport']['udp']['external_ip'],
self.config['transport']['udp']['external_port'],
)
self.maybe_upgrade_db()
storage = sqlite.SerializedSQLiteStorage(
database_path=self.database_path,
serializer=serialize.JSONSerializer(),
)
storage.log_run()
self.wal = wal.restore_to_state_change(
transition_function=node.state_transition,
storage=storage,
state_change_identifier='latest',
)
if self.wal.state_manager.current_state is None:
log.debug(
'No recoverable state available, created inital state',
node=pex(self.address),
)
# On first run Raiden needs to fetch all events for the payment
# network, to reconstruct all token network graphs and find opened
# channels
last_log_block_number = self.query_start_block
state_change = ActionInitChain(
random.Random(),
last_log_block_number,
self.chain.node_address,
self.chain.network_id,
)
self.handle_state_change(state_change)
payment_network = PaymentNetworkState(
self.default_registry.address,
[], # empty list of token network states as it's the node's startup
)
state_change = ContractReceiveNewPaymentNetwork(
constants.EMPTY_HASH,
payment_network,
last_log_block_number,
)
self.handle_state_change(state_change)
else:
# The `Block` state change is dispatched only after all the events
# for that given block have been processed, filters can be safely
# installed starting from this position without losing events.
last_log_block_number = views.block_number(self.wal.state_manager.current_state)
log.debug(
'Restored state from WAL',
last_restored_block=last_log_block_number,
node=pex(self.address),
)
known_networks = views.get_payment_network_identifiers(views.state_from_raiden(self))
if known_networks and self.default_registry.address not in known_networks:
configured_registry = pex(self.default_registry.address)
known_registries = lpex(known_networks)
raise RuntimeError(
f'Token network address mismatch.\n'
f'Raiden is configured to use the smart contract '
f'{configured_registry}, which conflicts with the current known '
f'smart contracts {known_registries}',
)
# Restore the current snapshot group
state_change_qty = self.wal.storage.count_state_changes()
self.snapshot_group = state_change_qty // SNAPSHOT_STATE_CHANGES_COUNT
# Install the filters using the correct from_block value, otherwise
# blockchain logs can be lost.
self.install_all_blockchain_filters(
self.default_registry,
self.default_secret_registry,
last_log_block_number,
)
# Complete the first_run of the alarm task and synchronize with the
# blockchain since the last run.
#
# Notes about setup order:
# - The filters must be polled after the node state has been primed,
# otherwise the state changes won't have effect.
# - The alarm must complete its first run before the transport is started,
# to reject messages for closed/settled channels.
self.alarm.register_callback(self._callback_new_block)
with self.dispatch_events_lock:
self.alarm.first_run(last_log_block_number)
chain_state = views.state_from_raiden(self)
self._initialize_transactions_queues(chain_state)
self._initialize_whitelists(chain_state)
self._initialize_payment_statuses(chain_state)
# send messages in queue before starting transport,
# this is necessary to avoid a race where, if the transport is started
# before the messages are queued, actions triggered by it can cause new
# messages to be enqueued before these older ones
self._initialize_messages_queues(chain_state)
# The transport must not ever be started before the alarm task's
# `first_run()` has been, because it's this method which synchronizes the
# node with the blockchain, including the channel's state (if the channel
# is closed on-chain new messages must be rejected, which will not be the
# case if the node is not synchronized)
self.transport.start(
raiden_service=self,
message_handler=self.message_handler,
prev_auth_data=chain_state.last_transport_authdata,
)
# First run has been called above!
self.alarm.start()
# exceptions on these subtasks should crash the app and bubble up
self.alarm.link_exception(self.on_error)
self.transport.link_exception(self.on_error)
# Health check needs the transport layer
self.start_neighbours_healthcheck(chain_state)
if self.config['transport_type'] == 'udp':
endpoint_registration_greenlet.get() # re-raise if exception occurred
log.debug('Raiden Service started', node=pex(self.address))
super().start()
def start(self):
""" Start the node synchronously. Raises directly if anything went wrong on startup """
assert self.stop_event.ready(), f"Node already started. node:{self!r}"
self.stop_event.clear()
self.greenlets = list()
self.ready_to_process_events = False # set to False because of restarts
if self.database_dir is not None:
self.db_lock.acquire(timeout=0)
assert self.db_lock.is_locked, f"Database not locked. node:{self!r}"
# start the registration early to speed up the start
if self.config["transport_type"] == "udp":
endpoint_registration_greenlet = gevent.spawn(
self.discovery.register,
self.address,
self.config["transport"]["udp"]["external_ip"],
self.config["transport"]["udp"]["external_port"],
)
self.maybe_upgrade_db()
storage = sqlite.SerializedSQLiteStorage(
database_path=self.database_path,
serializer=serialize.JSONSerializer())
storage.update_version()
storage.log_run()
self.wal = wal.restore_to_state_change(
transition_function=node.state_transition,
storage=storage,
state_change_identifier="latest",
)
if self.wal.state_manager.current_state is None:
log.debug("No recoverable state available, creating inital state.",
node=pex(self.address))
# On first run Raiden needs to fetch all events for the payment
# network, to reconstruct all token network graphs and find opened
# channels
last_log_block_number = self.query_start_block
last_log_block_hash = self.chain.client.blockhash_from_blocknumber(
last_log_block_number)
state_change = ActionInitChain(
pseudo_random_generator=random.Random(),
block_number=last_log_block_number,
block_hash=last_log_block_hash,
our_address=self.chain.node_address,
chain_id=self.chain.network_id,
)
self.handle_and_track_state_change(state_change)
payment_network = PaymentNetworkState(
self.default_registry.address,
[], # empty list of token network states as it's the node's startup
)
state_change = ContractReceiveNewPaymentNetwork(
transaction_hash=constants.EMPTY_HASH,
payment_network=payment_network,
block_number=last_log_block_number,
block_hash=last_log_block_hash,
)
self.handle_and_track_state_change(state_change)
else:
# The `Block` state change is dispatched only after all the events
# for that given block have been processed, filters can be safely
# installed starting from this position without losing events.
last_log_block_number = views.block_number(
self.wal.state_manager.current_state)
log.debug(
"Restored state from WAL",
last_restored_block=last_log_block_number,
node=pex(self.address),
)
known_networks = views.get_payment_network_identifiers(
views.state_from_raiden(self))
if known_networks and self.default_registry.address not in known_networks:
configured_registry = pex(self.default_registry.address)
known_registries = lpex(known_networks)
raise RuntimeError(
f"Token network address mismatch.\n"
f"Raiden is configured to use the smart contract "
f"{configured_registry}, which conflicts with the current known "
f"smart contracts {known_registries}")
# Restore the current snapshot group
state_change_qty = self.wal.storage.count_state_changes()
self.snapshot_group = state_change_qty // SNAPSHOT_STATE_CHANGES_COUNT
# Install the filters using the latest confirmed from_block value,
# otherwise blockchain logs can be lost.
self.install_all_blockchain_filters(self.default_registry,
self.default_secret_registry,
last_log_block_number)
# Complete the first_run of the alarm task and synchronize with the
# blockchain since the last run.
#
# Notes about setup order:
# - The filters must be polled after the node state has been primed,
# otherwise the state changes won't have effect.
# - The alarm must complete its first run before the transport is started,
# to reject messages for closed/settled channels.
self.alarm.register_callback(self._callback_new_block)
self.alarm.first_run(last_log_block_number)
chain_state = views.state_from_raiden(self)
self._initialize_payment_statuses(chain_state)
self._initialize_transactions_queues(chain_state)
self._initialize_messages_queues(chain_state)
self._initialize_whitelists(chain_state)
self._initialize_monitoring_services_queue(chain_state)
self._initialize_ready_to_processed_events()
if self.config["transport_type"] == "udp":
endpoint_registration_greenlet.get(
) # re-raise if exception occurred
# Start the side-effects:
# - React to blockchain events
# - React to incoming messages
# - Send pending transactions
# - Send pending message
self.alarm.link_exception(self.on_error)
self.transport.link_exception(self.on_error)
self._start_transport(chain_state)
self._start_alarm_task()
log.debug("Raiden Service started", node=pex(self.address))
super().start()
def main(db_file):
global database_path
database_path = db_file
migrate_db(
storage=sqlite.SerializedSQLiteStorage(db_file, serialize.JSONSerializer()),
)