class TestCompleter(unittest.TestCase):
def setUp(self):
self.dir = tempfile.mkdtemp()
self.block_db = NativeLmdbDatabase(
os.path.join(self.dir, 'block.lmdb'),
BlockStore.create_index_configuration())
self.block_store = BlockStore(self.block_db)
self.block_manager = BlockManager()
self.block_manager.add_commit_store(self.block_store)
self.gossip = MockGossip()
self.completer = Completer(
block_manager=self.block_manager,
transaction_committed=self.block_store.has_transaction,
get_committed_batch_by_id=self.block_store.get_batch,
get_committed_batch_by_txn_id=(
self.block_store.get_batch_by_transaction),
gossip=self.gossip)
self.completer.set_get_chain_head(lambda: self.block_store.chain_head)
self.completer.set_on_block_received(self._on_block_received)
self.completer.set_on_batch_received(self._on_batch_received)
self._has_block_value = True
context = create_context('secp256k1')
private_key = context.new_random_private_key()
crypto_factory = CryptoFactory(context)
self.signer = crypto_factory.new_signer(private_key)
self.blocks = []
self.batches = []
def _on_block_received(self, block_id):
return self.blocks.append(block_id)
def _on_batch_received(self, batch):
return self.batches.append(batch.header_signature)
def _has_block(self, batch):
return self._has_block_value
def _create_transactions(self, count, missing_dep=False):
txn_list = []
for _ in range(count):
payload = {
'Verb': 'set',
'Name': 'name' + str(random.randint(0, 100)),
'Value': random.randint(0, 100)
}
intkey_prefix = \
hashlib.sha512('intkey'.encode('utf-8')).hexdigest()[0:6]
addr = intkey_prefix + \
hashlib.sha512(payload["Name"].encode('utf-8')).hexdigest()
payload_encode = hashlib.sha512(cbor.dumps(payload)).hexdigest()
header = TransactionHeader(
signer_public_key=self.signer.get_public_key().as_hex(),
family_name='intkey',
family_version='1.0',
inputs=[addr],
outputs=[addr],
dependencies=[],
batcher_public_key=self.signer.get_public_key().as_hex(),
payload_sha512=payload_encode)
if missing_dep:
header.dependencies.extend(["Missing"])
header_bytes = header.SerializeToString()
signature = self.signer.sign(header_bytes)
transaction = Transaction(header=header_bytes,
payload=cbor.dumps(payload),
header_signature=signature)
txn_list.append(transaction)
return txn_list
def _create_batches(self, batch_count, txn_count, missing_dep=False):
batch_list = []
for _ in range(batch_count):
txn_list = self._create_transactions(txn_count,
missing_dep=missing_dep)
txn_sig_list = [txn.header_signature for txn in txn_list]
batch_header = BatchHeader(
signer_public_key=self.signer.get_public_key().as_hex())
batch_header.transaction_ids.extend(txn_sig_list)
header_bytes = batch_header.SerializeToString()
signature = self.signer.sign(header_bytes)
batch = Batch(header=header_bytes,
transactions=txn_list,
header_signature=signature)
batch_list.append(batch)
return batch_list
def _create_blocks(self,
block_count,
batch_count,
missing_predecessor=False,
missing_batch=False,
find_batch=True):
block_list = []
for i in range(0, block_count):
batch_list = self._create_batches(batch_count, 2)
batch_ids = [batch.header_signature for batch in batch_list]
if missing_predecessor:
predecessor = "Missing"
else:
predecessor = (block_list[i - 1].header_signature
if i > 0 else NULL_BLOCK_IDENTIFIER)
block_header = BlockHeader(
signer_public_key=self.signer.get_public_key().as_hex(),
batch_ids=batch_ids,
block_num=i,
previous_block_id=predecessor)
header_bytes = block_header.SerializeToString()
signature = self.signer.sign(header_bytes)
if missing_batch:
if find_batch:
self.completer.add_batch(batch_list[-1])
batch_list = batch_list[:-1]
block = Block(header=header_bytes,
batches=batch_list,
header_signature=signature)
block_list.append(block)
return block_list
def test_good_block(self):
"""
Add completed block to completer. Block should be passed to
on_block_recieved.
"""
block = self._create_blocks(1, 1)[0]
self.completer.add_block(block)
self.assertIn(block.header_signature, self.blocks)
def test_duplicate_block(self):
"""
Submit same block twice.
"""
block = self._create_blocks(1, 1)[0]
self.completer.add_block(block)
self.completer.add_block(block)
self.assertIn(block.header_signature, self.blocks)
self.assertEqual(len(self.blocks), 1)
def test_block_missing_predecessor(self):
"""
The block is completed but the predecessor is missing.
"""
block = self._create_blocks(1, 1, missing_predecessor=True)[0]
self._has_block_value = False
self.completer.add_block(block)
self.assertEqual(len(self.blocks), 0)
self.assertIn("Missing", self.gossip.requested_blocks)
header = BlockHeader(previous_block_id=NULL_BLOCK_IDENTIFIER)
missing_block = Block(header_signature="Missing",
header=header.SerializeToString())
self._has_block_value = True
self.completer.add_block(missing_block)
self.assertIn(block.header_signature, self.blocks)
self.assertEqual(block,
self.completer.get_block(block.header_signature))
def test_block_with_extra_batch(self):
"""
The block has a batch that is not in the batch_id list.
"""
block = self._create_blocks(1, 1)[0]
batches = self._create_batches(1, 1, True)
block.batches.extend(batches)
self.completer.add_block(block)
self.assertEqual(len(self.blocks), 0)
def test_block_missing_batch(self):
"""
The block is a missing batch and the batch is in the cache. The Block
will be build and passed to on_block_recieved. This puts the block
in the self.blocks list.
"""
block = self._create_blocks(1, 2, missing_batch=True)[0]
self.completer.add_block(block)
self.assertIn(block.header_signature, self.blocks)
self.assertEqual(block,
self.completer.get_block(block.header_signature))
def test_block_missing_batch_not_in_cache(self):
"""
The block is a missing batch and the batch is not in the cache.
The batch will be requested and the block will not be passed to
on_block_recieved.
"""
block = self._create_blocks(1, 3, missing_batch=True,
find_batch=False)[0]
self.completer.add_block(block)
header = BlockHeader()
header.ParseFromString(block.header)
self.assertIn(header.batch_ids[-1], self.gossip.requested_batches)
def test_block_batches_wrong_order(self):
"""
The block has all of its batches but they are in the wrong order. The
batches will be reordered and the block will be passed to
on_block_recieved.
"""
block = self._create_blocks(1, 6)[0]
batches = list(block.batches)
random.shuffle(batches)
del block.batches[:]
block.batches.extend(batches)
self.completer.add_block(block)
self.assertIn(block.header_signature, self.blocks)
def test_block_batches_wrong_batch(self):
"""
The block has all the correct number of batches but one is not in the
batch_id list. This block should be dropped.
"""
block = self._create_blocks(1, 6)[0]
batch = Batch(header_signature="Extra")
batches = list(block.batches)
batches[-1] = batch
block.batches.extend(batches)
self.completer.add_block(block)
self.assertEqual(len(self.blocks), 0)
def test_good_batch(self):
"""
Add complete batch to completer. The batch should be passed to
on_batch_received.
"""
batch = self._create_batches(1, 1)[0]
self.completer.add_batch(batch)
self.assertIn(batch.header_signature, self.batches)
self.assertEqual(batch,
self.completer.get_batch(batch.header_signature))
def test_batch_with_missing_dep(self):
"""
Add batch to completer that has a missing dependency. The missing
transaction's batch should be requested add the missing batch is then
added to the completer. The incomplete batch should be rechecked
and passed to on_batch_received.
"""
batch = self._create_batches(1, 1, missing_dep=True)[0]
self.completer.add_batch(batch)
self.assertIn("Missing", self.gossip.requested_batches_by_txn_id)
missing = Transaction(header_signature="Missing")
missing_batch = Batch(header_signature="Missing_batch",
transactions=[missing])
self.completer.add_batch(missing_batch)
self.assertIn(missing_batch.header_signature, self.batches)
self.assertIn(batch.header_signature, self.batches)
self.assertEqual(missing_batch,
self.completer.get_batch_by_transaction("Missing"))
def __init__(self,
bind_network,
bind_component,
bind_consensus,
endpoint,
peering,
seeds_list,
peer_list,
data_dir,
config_dir,
identity_signer,
key_dir,
scheduler_type,
permissions,
minimum_peer_connectivity,
maximum_peer_connectivity,
state_pruning_block_depth,
fork_cache_keep_time,
network_public_key=None,
network_private_key=None,
roles=None,
component_thread_pool_workers=10,
network_thread_pool_workers=10,
signature_thread_pool_workers=3):
"""Constructs a validator instance.
Args:
bind_network (str): the network endpoint
bind_component (str): the component endpoint
endpoint (str): the zmq-style URI of this validator's
publically reachable endpoint
peering (str): The type of peering approach. Either 'static'
or 'dynamic'. In 'static' mode, no attempted topology
buildout occurs -- the validator only attempts to initiate
peering connections with endpoints specified in the
peer_list. In 'dynamic' mode, the validator will first
attempt to initiate peering connections with endpoints
specified in the peer_list and then attempt to do a
topology buildout starting with peer lists obtained from
endpoints in the seeds_list. In either mode, the validator
will accept incoming peer requests up to max_peers.
seeds_list (list of str): a list of addresses to connect
to in order to perform the initial topology buildout
peer_list (list of str): a list of peer addresses
data_dir (str): path to the data directory
config_dir (str): path to the config directory
identity_signer (Signer): cryptographic signer the validator uses
for signing
key_dir (str): path to the data directory
component_thread_pool_workers (int): number of workers in the
component thread pool; defaults to 10.
network_thread_pool_workers (int): number of workers in the network
thread pool; defaults to 10.
signature_thread_pool_workers (int): number of workers in the
signature thread pool; defaults to 3.
"""
# -- Setup Global State Database and Factory -- #
global_state_db_filename = os.path.join(
data_dir, 'merkle-{}.lmdb'.format(bind_network[-2:]))
LOGGER.debug('global state database file is %s',
global_state_db_filename)
global_state_db = NativeLmdbDatabase(
global_state_db_filename,
indexes=MerkleDatabase.create_index_configuration())
state_view_factory = StateViewFactory(global_state_db)
# -- Setup Receipt Store -- #
receipt_db_filename = os.path.join(
data_dir, 'txn_receipts-{}.lmdb'.format(bind_network[-2:]))
LOGGER.debug('txn receipt store file is %s', receipt_db_filename)
receipt_db = LMDBNoLockDatabase(receipt_db_filename, 'c')
receipt_store = TransactionReceiptStore(receipt_db)
# -- Setup Block Store -- #
block_db_filename = os.path.join(
data_dir, 'block-{}.lmdb'.format(bind_network[-2:]))
LOGGER.debug('block store file is %s', block_db_filename)
block_db = NativeLmdbDatabase(
block_db_filename, indexes=BlockStore.create_index_configuration())
block_store = BlockStore(block_db)
# The cache keep time for the journal's block cache must be greater
# than the cache keep time used by the completer.
base_keep_time = 1200
block_manager = BlockManager()
block_manager.add_commit_store(block_store)
block_status_store = BlockValidationResultStore()
# -- Setup Thread Pools -- #
component_thread_pool = InstrumentedThreadPoolExecutor(
max_workers=component_thread_pool_workers, name='Component')
network_thread_pool = InstrumentedThreadPoolExecutor(
max_workers=network_thread_pool_workers, name='Network')
client_thread_pool = InstrumentedThreadPoolExecutor(max_workers=5,
name='Client')
sig_pool = InstrumentedThreadPoolExecutor(
max_workers=signature_thread_pool_workers, name='Signature')
# -- Setup Dispatchers -- #
component_dispatcher = Dispatcher()
network_dispatcher = Dispatcher()
# -- Setup Services -- #
component_service = Interconnect(bind_component,
component_dispatcher,
secured=False,
reap=False,
max_incoming_connections=20,
monitor=True,
max_future_callback_workers=10)
zmq_identity = hashlib.sha512(
time.time().hex().encode()).hexdigest()[:23]
secure = False
if network_public_key is not None and network_private_key is not None:
secure = True
network_service = Interconnect(bind_network,
dispatcher=network_dispatcher,
zmq_identity=zmq_identity,
secured=secure,
server_public_key=network_public_key,
server_private_key=network_private_key,
reap=True,
public_endpoint=endpoint,
connection_timeout=120,
max_incoming_connections=100,
max_future_callback_workers=10,
authorize=True,
signer=identity_signer,
roles=roles)
# -- Setup Transaction Execution Platform -- #
batch_tracker = BatchTracker(block_store.has_batch)
settings_cache = SettingsCache(
SettingsViewFactory(state_view_factory), )
event_broadcaster = EventBroadcaster(component_service, block_store,
receipt_store)
# -- Consensus Engine -- #
consensus_thread_pool = InstrumentedThreadPoolExecutor(
max_workers=3, name='Consensus')
consensus_dispatcher = Dispatcher()
consensus_service = Interconnect(bind_consensus,
consensus_dispatcher,
secured=False,
reap=False,
max_incoming_connections=20,
max_future_callback_workers=10)
consensus_registry = ConsensusRegistry()
consensus_notifier = ConsensusNotifier(
consensus_service, consensus_registry,
identity_signer.get_public_key().as_hex())
consensus_activation_observer = ConsensusActivationObserver(
consensus_registry,
consensus_notifier,
settings_view_factory=SettingsViewFactory(state_view_factory))
# -- Setup P2P Networking -- #
gossip = Gossip(network_service,
settings_cache,
lambda: block_store.chain_head,
block_store.chain_head_state_root,
consensus_notifier,
endpoint=endpoint,
peering_mode=peering,
initial_seed_endpoints=seeds_list,
initial_peer_endpoints=peer_list,
minimum_peer_connectivity=minimum_peer_connectivity,
maximum_peer_connectivity=maximum_peer_connectivity,
topology_check_frequency=1)
consensus_notifier.set_gossip(gossip)
completer = Completer(
block_manager=block_manager,
transaction_committed=block_store.has_transaction,
get_committed_batch_by_id=block_store.get_batch,
get_committed_batch_by_txn_id=(
block_store.get_batch_by_transaction),
gossip=gossip,
cache_keep_time=base_keep_time,
cache_purge_frequency=30,
requested_keep_time=300)
self._completer = completer
block_sender = BroadcastBlockSender(completer, gossip)
identity_view_factory = IdentityViewFactory(
StateViewFactory(global_state_db))
id_cache = IdentityCache(identity_view_factory)
# -- Setup Permissioning -- #
permission_verifier = PermissionVerifier(
permissions, block_store.chain_head_state_root, id_cache)
identity_observer = IdentityObserver(to_update=id_cache.invalidate,
forked=id_cache.forked)
settings_observer = SettingsObserver(
to_update=settings_cache.invalidate, forked=settings_cache.forked)
# -- Setup Journal -- #
journal = Journal(
block_store=block_store,
block_manager=block_manager,
state_database=global_state_db,
block_sender=block_sender,
block_status_store=block_status_store,
consensus_notifier=consensus_notifier,
consensus_registry=consensus_registry,
state_pruning_block_depth=state_pruning_block_depth,
fork_cache_keep_time=fork_cache_keep_time,
data_dir=data_dir,
batch_observers=[batch_tracker],
invalid_transaction_observers=[batch_tracker],
observers=[
event_broadcaster, receipt_store, batch_tracker,
identity_observer, settings_observer,
consensus_activation_observer
],
key_dir=key_dir,
genesis_observers=[receipt_store],
)
completer.set_get_chain_head(lambda: journal.chain_head)
responder = Responder(completer)
completer.set_on_block_received(journal.queue_block)
# -- Register Message Handler -- #
network_handlers.add(network_dispatcher, network_service, gossip,
completer, responder, network_thread_pool,
sig_pool,
lambda block_id: block_id in block_manager,
journal.has_batch, permission_verifier,
consensus_notifier)
component_handlers.add(component_dispatcher, gossip, completer,
block_store, batch_tracker, global_state_db,
self.get_chain_head_state_root_hash,
receipt_store, event_broadcaster,
permission_verifier, component_thread_pool,
client_thread_pool, sig_pool, journal,
identity_signer.get_public_key().as_hex())
# -- Store Object References -- #
self._component_dispatcher = component_dispatcher
self._component_service = component_service
self._component_thread_pool = component_thread_pool
self._network_dispatcher = network_dispatcher
self._network_service = network_service
self._network_thread_pool = network_thread_pool
consensus_proxy = ConsensusProxy(
block_manager=block_manager,
journal=journal,
gossip=gossip,
identity_signer=identity_signer,
settings_view_factory=SettingsViewFactory(state_view_factory),
state_view_factory=state_view_factory,
consensus_registry=consensus_registry,
consensus_notifier=consensus_notifier)
consensus_handlers.add(consensus_dispatcher, consensus_thread_pool,
consensus_proxy, consensus_notifier)
self._block_status_store = block_status_store
self._consensus_notifier = consensus_notifier
self._consensus_dispatcher = consensus_dispatcher
self._consensus_service = consensus_service
self._consensus_thread_pool = consensus_thread_pool
self._consensus_registry = consensus_registry
self._client_thread_pool = client_thread_pool
self._sig_pool = sig_pool
self._gossip = gossip
self._journal = journal