def test_restore_without_snapshot():
wal = new_wal()
wal.log_and_dispatch(Block(5), 5)
wal.log_and_dispatch(Block(7), 7)
wal.log_and_dispatch(Block(8), 8)
newwal, events = restore_from_latest_snapshot(
state_transtion_acc,
wal.storage,
)
assert not events
aggregate = newwal.state_manager.current_state
assert aggregate.state_changes == [Block(5), Block(7), Block(8)]
def test_restore_without_snapshot():
wal = new_wal()
wal.log_and_dispatch(Block(5), 5)
wal.log_and_dispatch(Block(7), 7)
wal.log_and_dispatch(Block(8), 8)
newwal, events = restore_from_latest_snapshot(
state_transtion_acc,
wal.storage,
)
assert not events
aggregate = newwal.state_manager.current_state
assert aggregate.state_changes == [Block(5), Block(7), Block(8)]
def start(self):
""" Start the node. """
if self.stop_event and self.stop_event.is_set():
self.stop_event.clear()
if self.database_dir is not None:
self.db_lock.acquire(timeout=0)
assert self.db_lock.is_locked
# The database may be :memory:
storage = sqlite.SQLiteStorage(self.database_path,
serialize.PickleSerializer())
self.wal, unapplied_events = wal.restore_from_latest_snapshot(
node.state_transition,
storage,
)
last_log_block_number = None
# First run, initialize the basic state
if self.wal.state_manager.current_state is None:
block_number = self.chain.block_number()
state_change = ActionInitNode(
random.Random(),
block_number,
)
self.wal.log_and_dispatch(state_change, block_number)
else:
# Get the last known block number after reapplying all the state changes from the log
last_log_block_number = views.block_number(
self.wal.state_manager.current_state)
# The alarm task must be started after the snapshot is loaded or the
# state is primed, the callbacks assume the node is initialized.
self.alarm.start()
self.alarm.register_callback(self.poll_blockchain_events)
self.alarm.register_callback(self.set_block_number)
self._block_number = self.chain.block_number()
# Registry registration must start *after* the alarm task. This
# avoids corner cases where the registry is queried in block A, a new
# block B is mined, and the alarm starts polling at block C.
# If last_log_block_number is None, the wal.state_manager.current_state was
# None in the log, meaning we don't have any events we care about, so just
# read the latest state from the network
self.register_payment_network(self.default_registry.address,
last_log_block_number)
# Start the protocol after the registry is queried to avoid warning
# about unknown channels.
queueids_to_queues = views.get_all_messagequeues(
views.state_from_raiden(self))
# TODO: remove the cyclic dependency between the protocol and this instance
self.protocol.start(self, queueids_to_queues)
# Health check needs the protocol layer
self.start_neighbours_healthcheck()
for event in unapplied_events:
on_raiden_event(self, event)
self.start_event.set()
def start(self):
""" Start the node. """
if self.stop_event and self.stop_event.is_set():
self.stop_event.clear()
if self.database_dir is not None:
self.db_lock.acquire(timeout=0)
assert self.db_lock.is_locked
# The database may be :memory:
storage = sqlite.SQLiteStorage(self.database_path,
serialize.PickleSerializer())
self.wal, unapplied_events = wal.restore_from_latest_snapshot(
node.state_transition,
storage,
)
if self.wal.state_manager.current_state is None:
block_number = self.chain.block_number()
state_change = ActionInitChain(
random.Random(),
block_number,
self.chain.network_id,
)
self.wal.log_and_dispatch(state_change, block_number)
payment_network = PaymentNetworkState(
self.default_registry.address,
[], # empty list of token network states as it's the node's startup
)
state_change = ContractReceiveNewPaymentNetwork(payment_network)
self.handle_state_change(state_change)
# 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 = 0
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)
# 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 avoid rejecting messages for unknown channels.
self.alarm.register_callback(self._callback_new_block)
self.alarm.first_run()
self.alarm.start()
queueids_to_queues = views.get_all_messagequeues(
views.state_from_raiden(self))
self.transport.start(self, queueids_to_queues)
# Health check needs the transport layer
self.start_neighbours_healthcheck()
for event in unapplied_events:
on_raiden_event(self, event)
self.start_event.set()
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'],
)
# The database may be :memory:
storage = sqlite.SQLiteStorage(self.database_path,
serialize.JSONSerializer())
self.wal = wal.restore_from_latest_snapshot(
node.state_transition,
storage,
)
if self.wal.state_manager.current_state is None:
log.debug(
'No recoverable state available, created inital state',
node=pex(self.address),
)
block_number = self.chain.block_number()
state_change = ActionInitChain(
random.Random(),
block_number,
self.chain.node_address,
self.chain.network_id,
)
self.wal.log_and_dispatch(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.NULL_HASH_BYTES,
payment_network,
)
self.handle_state_change(state_change)
# 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 = 0
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}', )
# Clear ref cache & disable caching
serialize.RaidenJSONDecoder.ref_cache.clear()
serialize.RaidenJSONDecoder.cache_object_references = False
# Restore the current snapshot group
self.snapshot_group = last_log_block_number // SNAPSHOT_BLOCK_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 avoid rejecting messages for unknown channels.
self.alarm.register_callback(self._callback_new_block)
self.alarm.first_run()
chain_state = views.state_from_raiden(self)
# Dispatch pending transactions
pending_transactions = views.get_pending_transactions(chain_state, )
log.debug(
'Processing pending transactions',
num_pending_transactions=len(pending_transactions),
node=pex(self.address),
)
with self.dispatch_events_lock:
for transaction in pending_transactions:
on_raiden_event(self, transaction)
self.alarm.start()
queueids_to_queues = views.get_all_messagequeues(chain_state)
# repopulate identifier_to_results for pending transfers
for queue_messages in queueids_to_queues.values():
for message in queue_messages:
if isinstance(message, SendDirectTransfer):
self.identifier_to_results[
message.payment_identifier] = AsyncResult()
self.transport.start(self, queueids_to_queues)
# 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()
if self.config['transport_type'] == 'udp':
endpoint_registration_greenlet.get(
) # re-raise if exception occurred
super().start()
def start(self):
""" Start the node. """
if self.stop_event and self.stop_event.is_set():
self.stop_event.clear()
if self.database_dir is not None:
self.db_lock.acquire(timeout=0)
assert self.db_lock.is_locked
# The database may be :memory:
storage = sqlite.SQLiteStorage(self.database_path, serialize.PickleSerializer())
self.wal, unapplied_events = wal.restore_from_latest_snapshot(
node.state_transition,
storage,
)
if self.wal.state_manager.current_state is None:
block_number = self.chain.block_number()
state_change = ActionInitNode(
random.Random(),
block_number,
)
self.wal.log_and_dispatch(state_change, block_number)
# 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 = None
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)
# The time the alarm task is started or the callbacks are installed doesn't
# really matter.
#
# But it is of paramount importance to:
# - Install the filters which will be polled by poll_blockchain_events
# after the state has been primed, otherwise the state changes won't
# have effect.
# - Install the filters using the correct from_block value, otherwise
# blockchain logs can be lost.
self.alarm.register_callback(self._callback_new_block)
self.alarm.start()
self.install_payment_network_filters(
self.default_registry.address,
last_log_block_number,
)
# Start the transport after the registry is queried to avoid warning
# about unknown channels.
queueids_to_queues = views.get_all_messagequeues(views.state_from_raiden(self))
self.transport.start(self, queueids_to_queues)
# Health check needs the transport layer
self.start_neighbours_healthcheck()
for event in unapplied_events:
on_raiden_event(self, event)
self.start_event.set()
def start_async(self) -> RaidenGreenletEvent:
""" Start the node asynchronously. """
self.start_event.clear()
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'],
)
# The database may be :memory:
storage = sqlite.SQLiteStorage(self.database_path, serialize.PickleSerializer())
self.wal = wal.restore_from_latest_snapshot(
node.state_transition,
storage,
)
if self.wal.state_manager.current_state is None:
log.debug('No recoverable state available, created inital state')
block_number = self.chain.block_number()
state_change = ActionInitChain(
random.Random(),
block_number,
self.chain.node_address,
self.chain.network_id,
)
self.wal.log_and_dispatch(state_change, block_number)
payment_network = PaymentNetworkState(
self.default_registry.address,
[], # empty list of token network states as it's the node's startup
)
state_change = ContractReceiveNewPaymentNetwork(
constants.NULL_ADDRESS,
payment_network,
)
self.handle_state_change(state_change)
# 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 = 0
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)
# Restore the current snapshot group
self.snapshot_group = last_log_block_number // SNAPSHOT_BLOCK_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 avoid rejecting messages for unknown channels.
self.alarm.register_callback(self._callback_new_block)
self.alarm.first_run()
chain_state = views.state_from_raiden(self)
# Dispatch pending transactions
pending_transactions = views.get_pending_transactions(
chain_state,
)
log.debug(
'Processing pending transactions',
num_pending_transactions=len(pending_transactions),
)
with self.dispatch_events_lock:
for transaction in pending_transactions:
on_raiden_event(self, transaction)
self.alarm.start()
queueids_to_queues = views.get_all_messagequeues(chain_state)
self.transport.start(self, queueids_to_queues)
# Health check needs the transport layer
self.start_neighbours_healthcheck()
if self.config['transport_type'] == 'udp':
def set_start_on_registration(_):
self.start_event.set()
endpoint_registration_greenlet.link_safe(set_start_on_registration)
else:
self.start_event.set()
return self.start_event
def start(self):
""" Start the node. """
if self.stop_event and self.stop_event.is_set():
self.stop_event.clear()
if self.database_dir is not None:
self.db_lock.acquire(timeout=0)
assert self.db_lock.is_locked
# The database may be :memory:
storage = sqlite.SQLiteStorage(self.database_path, serialize.PickleSerializer())
self.wal, unapplied_events = wal.restore_from_latest_snapshot(
node.state_transition,
storage,
)
if self.wal.state_manager.current_state is None:
block_number = self.chain.block_number()
state_change = ActionInitChain(
random.Random(),
block_number,
self.chain.network_id,
)
self.wal.log_and_dispatch(state_change, block_number)
payment_network = PaymentNetworkState(
self.default_registry.address,
[], # empty list of token network states as it's the node's startup
)
state_change = ContractReceiveNewPaymentNetwork(payment_network)
self.handle_state_change(state_change)
# 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 = 0
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)
# 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 avoid rejecting messages for unknown channels.
self.alarm.register_callback(self._callback_new_block)
self.alarm.first_run()
self.alarm.start()
queueids_to_queues = views.get_all_messagequeues(views.state_from_raiden(self))
self.transport.start(self, queueids_to_queues)
# Health check needs the transport layer
self.start_neighbours_healthcheck()
for event in unapplied_events:
on_raiden_event(self, event)
self.start_event.set()