def _send_changes(self, block, deltas, subscriber):
state_change_evt = StateDeltaEvent(
block_id=block.header_signature,
block_num=block.header.block_num,
state_root_hash=block.header.state_root_hash,
state_changes=subscriber.deltas_of_interest(deltas))
LOGGER.debug('sending change event to %s', subscriber.connection_id)
self._send(subscriber.connection_id,
state_change_evt.SerializeToString())
def test_publish_deltas_no_state_changes(self):
"""Given a block transition, where no state changes happened (e.g. it
only had transactions which did not change state), the
StateDeltaProcessor should still publish an event with the block change
information.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
database = DictDatabase()
delta_store = StateDeltaStore(database)
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'subscriber_conn_id', [block_tree_manager.chain_head.identifier],
['000000'])
next_block = block_tree_manager.generate_block()
delta_processor.publish_deltas(next_block)
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=next_block.identifier,
block_num=next_block.header.block_num,
state_root_hash=next_block.header.state_root_hash,
previous_block_id=next_block.header.previous_block_id,
state_changes=[]).SerializeToString(),
connection_id='subscriber_conn_id')
def _broadcast_changes(self, block, deltas):
state_change_evt = StateDeltaEvent(
block_id=block.header_signature,
block_num=block.header.block_num,
state_root_hash=block.header.state_root_hash)
for subscriber in self._subscribers.values():
acceptable_changes = subscriber.deltas_of_interest(deltas)
state_change_evt.ClearField('state_changes')
if len(acceptable_changes) > 0:
state_change_evt.state_changes.extend(acceptable_changes)
LOGGER.debug('sending change event to %s',
subscriber.connection_id)
self._send(subscriber.connection_id,
state_change_evt.SerializeToString())
def test_add_subscriber(self):
"""Test adding a subscriber, who has no known blocks.
This scenerio is valid for subscribers who have never connected and
would need to receive all deltas since the genesis block.
On registration, the subscriber should receive one event, comprised
of the state changes for the genesis block.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
delta_store = StateDeltaStore(DictDatabase())
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_store.save_state_deltas(
block_tree_manager.chain_head.state_root_hash,
[StateChange(address='deadbeef0000000',
value='my_genesis_value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)])
delta_processor.add_subscriber(
'test_conn_id',
[],
['deadbeef'])
self.assertEqual(['test_conn_id'], delta_processor.subscriber_ids)
# test that it catches up, and receives the events from the chain head.
# In this case, it should just be once, as the chain head is the
# genesis block
chain_head = block_tree_manager.chain_head
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=chain_head.identifier,
block_num=chain_head.block_num,
state_root_hash=chain_head.state_root_hash,
previous_block_id=chain_head.previous_block_id,
state_changes=[StateChange(address='deadbeef0000000',
value='my_genesis_value'.encode(),
type=StateChange.SET)]
).SerializeToString(),
connection_id='test_conn_id')
def test_publish_deltas(self):
"""Tests that a subscriber filtering on an address prefix receives only
the changes in an event that match.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
database = DictDatabase()
delta_store = StateDeltaStore(database)
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'test_conn_id', [block_tree_manager.chain_head.identifier],
['deadbeef'])
next_block = block_tree_manager.generate_block()
# State added during context squash for our block
delta_store.save_state_deltas(next_block.header.state_root_hash, [
StateChange(address='deadbeef01',
value='my_state_Value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)
])
# call to publish deltas for that block to the subscribers
delta_processor.publish_deltas(next_block)
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=next_block.identifier,
block_num=next_block.header.block_num,
state_root_hash=next_block.header.state_root_hash,
previous_block_id=next_block.header.previous_block_id,
state_changes=[
StateChange(address='deadbeef01',
value='my_state_Value'.encode(),
type=StateChange.SET)
]).SerializeToString(),
connection_id='test_conn_id')
def test_get_events_ignore_bad_blocks(self):
"""Tests that the GetStateDeltaEventsHandler will return a response
containing only the events for blocks that exists.
"""
block_tree_manager = BlockTreeManager()
delta_store = StateDeltaStore(DictDatabase())
delta_store.save_state_deltas(
block_tree_manager.chain_head.state_root_hash, [
StateChange(address='deadbeef0000000',
value='my_genesis_value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)
])
handler = GetStateDeltaEventsHandler(block_tree_manager.block_store,
delta_store)
request = GetStateDeltaEventsRequest(
block_ids=[
block_tree_manager.chain_head.identifier, 'somebadblockid'
],
address_prefixes=['deadbeef']).SerializeToString()
response = handler.handle('test_conn_id', request)
self.assertEqual(HandlerStatus.RETURN, response.status)
self.assertEqual(GetStateDeltaEventsResponse.OK,
response.message_out.status)
chain_head = block_tree_manager.chain_head
self.assertEqual([
StateDeltaEvent(block_id=chain_head.identifier,
block_num=chain_head.block_num,
state_root_hash=chain_head.state_root_hash,
previous_block_id=chain_head.previous_block_id,
state_changes=[
StateChange(address='deadbeef0000000',
value='my_genesis_value'.encode(),
type=StateChange.SET)
])
], [event for event in response.message_out.events])
def test_publish_deltas_subscriber_matches_no_addresses(self):
"""Given a subscriber whose prefix filters don't match any addresses
in the current state delta, it should still receive an event with the
block change information.
"""
mock_service = Mock()
block_tree_manager = BlockTreeManager()
database = DictDatabase()
delta_store = StateDeltaStore(database)
delta_processor = StateDeltaProcessor(
service=mock_service,
state_delta_store=delta_store,
block_store=block_tree_manager.block_store)
delta_processor.add_subscriber(
'settings_conn_id',
[block_tree_manager.chain_head.identifier],
['000000'])
next_block = block_tree_manager.generate_block()
# State added during context squash for our block
delta_store.save_state_deltas(
next_block.header.state_root_hash,
[StateChange(address='deadbeef01',
value='my_state_Value'.encode(),
type=StateChange.SET),
StateChange(address='a14ea01',
value='some other state value'.encode(),
type=StateChange.SET)])
# call to publish deltas for that block to the subscribers
delta_processor.publish_deltas(next_block)
mock_service.send.assert_called_with(
validator_pb2.Message.STATE_DELTA_EVENT,
StateDeltaEvent(
block_id=next_block.identifier,
block_num=next_block.header.block_num,
state_root_hash=next_block.header.state_root_hash,
state_changes=[]
).SerializeToString(),
connection_id='settings_conn_id')
def handle(self, connection_id, message_content):
request = StateDeltaGetEventsRequest()
request.ParseFromString(message_content)
# Create a temporary subscriber for this response
temp_subscriber = _DeltaSubscriber(connection_id,
request.address_prefixes)
events = []
for block_id in request.block_ids:
try:
block = self._block_store[block_id]
except KeyError:
LOGGER.debug('Ignoring state delete event request for %s...',
block_id[:8])
continue
try:
deltas = self._state_delta_store.get_state_deltas(
block.header.state_root_hash)
except KeyError:
deltas = []
event = StateDeltaEvent(
block_id=block_id,
block_num=block.header.block_num,
state_root_hash=block.header.state_root_hash,
previous_block_id=block.header.previous_block_id,
state_changes=temp_subscriber.deltas_of_interest(deltas))
events.append(event)
status = StateDeltaGetEventsResponse.OK if events else \
StateDeltaGetEventsResponse.NO_VALID_BLOCKS_SPECIFIED
ack = StateDeltaGetEventsResponse(status=status, events=events)
return HandlerResult(
HandlerStatus.RETURN,
message_out=ack,
message_type=self._msg_type)