def get_chaindb_manager(chain_config: ChainConfig, base_db: BaseAtomicDB) -> BaseManager:
chaindb = AsyncChainDB(base_db)
chain_head_db = AsyncChainHeadDB.load_from_saved_root_hash(base_db)
if not is_database_initialized(chaindb, chain_config):
if 'GENERATE_RANDOM_DATABASE' in os.environ:
#this is for testing, we neeed to build an initial blockchain database
#create_dev_test_random_blockchain_database(base_db)
if "INSTANCE_NUMBER" in os.environ:
create_predefined_blockchain_database(base_db, instance = int(os.environ["INSTANCE_NUMBER"]))
else:
create_predefined_blockchain_database(base_db)
else:
initialize_database(chain_config = chain_config, chaindb = chaindb)
consensus_db = AsyncConsensusDB(chaindb)
class DBManager(BaseManager):
pass
# Typeshed definitions for multiprocessing.managers is incomplete, so ignore them for now:
# https://github.com/python/typeshed/blob/85a788dbcaa5e9e9a62e55f15d44530cd28ba830/stdlib/3/multiprocessing/managers.pyi#L3
DBManager.register( # type: ignore
'get_db', callable=lambda: TracebackRecorder(base_db), proxytype=DBProxy)
DBManager.register( # type: ignore
'get_chaindb',
callable=lambda: TracebackRecorder(chaindb),
proxytype=ChainDBProxy,
)
# DBManager.register( # type: ignore
# 'get_chain', callable=lambda: TracebackRecorder(chain), proxytype=ChainProxy)
DBManager.register( # type: ignore
'get_chain_head_db',
callable=lambda: TracebackRecorder(chain_head_db),
proxytype=ChainHeadDBProxy,
)
DBManager.register( # type: ignore
'get_consensus_db',
callable=lambda: TracebackRecorder(consensus_db),
proxytype=ConsensusDBProxy,
)
manager = DBManager(address=str(chain_config.database_ipc_path)) # type: ignore
return manager
def get_predefined_blockchain_db(instance_number):
testdb1 = MemoryDB()
create_predefined_blockchain_database(testdb1, instance=instance_number)
return testdb1
async def test_consensus_avg_network_min_gas(request, event_loop):
num_peers_in_swarm = 6
base_db = MemoryDB()
create_predefined_blockchain_database(base_db)
tx_list = [[
TESTNET_GENESIS_PRIVATE_KEY, private_keys[1], 1,
int(time.time())
]]
add_transactions_to_blockchain_db(base_db, tx_list)
client_db = MemoryDB(kv_store=base_db.kv_store.copy())
peer_dbs = []
for i in range(num_peers_in_swarm):
peer_dbs.append(MemoryDB(kv_store=base_db.kv_store.copy()))
# Set their minimum gas prices
bootstrap_chain = TestnetChain(
base_db, TESTNET_GENESIS_PRIVATE_KEY.public_key.to_canonical_address())
bootstrap_chain.min_gas_db.initialize_historical_minimum_gas_price_at_genesis(
min_gas_price=100, net_tpc_cap=1)
client_chain = TestnetChain(
client_db,
TESTNET_GENESIS_PRIVATE_KEY.public_key.to_canonical_address())
client_chain.min_gas_db.initialize_historical_minimum_gas_price_at_genesis(
min_gas_price=100, net_tpc_cap=1)
for peer_db in peer_dbs:
peer_chain = TestnetChain(
peer_db,
TESTNET_GENESIS_PRIVATE_KEY.public_key.to_canonical_address())
peer_chain.min_gas_db.initialize_historical_minimum_gas_price_at_genesis(
min_gas_price=random.randint(1, 1000), net_tpc_cap=1)
bootstrap_historical_min_gas_price = bootstrap_chain.min_gas_db.load_historical_minimum_gas_price(
)
bootstrap_historical_network_tpc_capability = bootstrap_chain.min_gas_db.load_historical_network_tpc_capability(
)
async def validation(consensus_services: List[Consensus]):
# avg_min_gas_limits = [await client_consensus.calculate_average_network_min_gas_limit() for client_consensus in consensus_services]
# print(avg_min_gas_limits)
# all_equal = all(x == avg_min_gas_limits[0] for x in avg_min_gas_limits)
# assert(all_equal)
# We also want to make sure that the nodes correctly initialized to the bootstrap node
for consensus in consensus_services:
chain = consensus.node.get_chain()
node_historical_min_gas_price = chain.min_gas_db.load_historical_minimum_gas_price(
)
node_historical_network_tpc_capability = chain.min_gas_db.load_historical_network_tpc_capability(
)
assert (bootstrap_historical_min_gas_price[:-1] ==
node_historical_min_gas_price[:len(
bootstrap_historical_min_gas_price) - 1])
assert (bootstrap_historical_network_tpc_capability[:-1] ==
node_historical_network_tpc_capability[:len(
bootstrap_historical_network_tpc_capability) - 1])
async def wait_for_time(consensus_services):
while True:
# They should have the same parameters once they have received stats from all other nodes.
length_of_stats = [
len(consensus._network_min_gas_limit_statistics)
for consensus in consensus_services
]
print('ZZZZZZZZZZZZZZ')
print(length_of_stats)
if all([x >= (num_peers_in_swarm + 1) for x in length_of_stats]):
return
await asyncio.sleep(1)
await _test_consensus_swarm(request,
event_loop,
base_db,
client_db,
peer_dbs,
validation,
waiting_function=wait_for_time)