def db_manager(tconf):
_db_manager = DatabaseManager()
storage = initKeyValueStorage(
KeyValueStorageType.Memory,
None,
"tokenInMemoryStore",
txn_serializer=serialization.multi_sig_store_serializer)
ledger = get_fake_ledger()
def commit_txns(count):
ledger.committed_root_hash = ledger.uncommitted_root_hash
return None, [1]
ledger.commitTxns = commit_txns
ledger.root_hash = txn_root_serializer.serialize("1")
ledger.uncommitted_root_hash = "1"
ledger.uncommitted_size = 1
ledger.size = 0
ledger.discardTxns = lambda x: None
ledger.committed_root_hash = "-1"
ledger.append_txns_metadata = lambda txns, txn_time: [
append_txn_metadata(txn, 2, txn_time, 2) for txn in txns
]
ledger.appendTxns = lambda x: (None, x)
_db_manager.register_new_database(TOKEN_LEDGER_ID, ledger,
PruningState(storage))
return _db_manager
def __init__(self, viewNo, quorums, ledger_ids):
node_names = ["Alpha", "Beta", "Gamma", "Delta"]
node_stack = FakeSomething(name="fake stack",
connecteds=set(node_names))
self.replicas = []
self.viewNo = viewNo
audit_ledger = FakeSomething(size=0,
get_last_txn=lambda *args: None,
getAllTxn=lambda *args, **kwargs: [])
db_manager = DatabaseManager()
db_manager.register_new_database(AUDIT_LEDGER_ID, audit_ledger)
super().__init__(name="fake node",
ledger_ids=ledger_ids,
_viewNo=viewNo,
quorums=quorums,
nodestack=node_stack,
utc_epoch=lambda *args: get_utc_epoch(),
mode=Mode.participating,
view_change_in_progress=False,
requests=Requests(),
onBatchCreated=lambda self, *args, **kwargs: True,
applyReq=lambda self, *args, **kwargs: True,
primaries=[],
get_validators=lambda: [],
db_manager=db_manager,
write_manager=FakeSomething(
database_manager=db_manager,
apply_request=lambda req, cons_time: None,
future_primary_handler=FakeSomething(
primaries={},
get_primaries=lambda *args: [])),
timer=QueueTimer(),
poolManager=FakeSomething(
node_names_ordered_by_rank=lambda: node_names))
def nym_handler(tconf):
data_manager = DatabaseManager()
handler = NymHandler(tconf, data_manager)
state = PruningState(KeyValueStorageInMemory())
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
return handler
def node_handler():
data_manager = DatabaseManager()
bls = FakeSomething()
handler = NodeHandler(data_manager, bls)
state = PruningState(KeyValueStorageInMemory())
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
return handler
def txn_author_agreement_disable_handler(tconf, domain_state, config_state):
data_manager = DatabaseManager()
handler = TxnAuthorAgreementDisableHandler(data_manager)
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
config_state)
data_manager.register_new_database(DOMAIN_LEDGER_ID, FakeSomething(),
domain_state)
return handler
def txn_author_agreement_aml_handler(tconf, domain_state):
data_manager = DatabaseManager()
handler = TxnAuthorAgreementAmlHandler(data_manager, FakeSomething())
state = PruningState(KeyValueStorageInMemory())
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
data_manager.register_new_database(DOMAIN_LEDGER_ID, FakeSomething(),
domain_state)
return handler
def nym_handler(tconf):
data_manager = DatabaseManager()
handler = NymHandler(tconf, data_manager)
state = State()
state.txn_list = {}
state.get = lambda key, isCommitted: state.txn_list.get(key, None)
state.set = lambda key, value: state.txn_list.update({key: value})
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
return handler
def database_manager(tdir_for_func):
db = DatabaseManager()
db.register_new_database(
LEDGER_ID, Ledger(CompactMerkleTree(), dataDir=tdir_for_func),
PruningState(KeyValueStorageRocksdb(tdir_for_func, 'kv1')))
db.register_new_store(
TS_LABEL,
StateTsDbStorage('test',
{1: KeyValueStorageRocksdb(tdir_for_func, 'kv2')}))
return db
def node_handler():
data_manager = DatabaseManager()
bls = FakeSomething()
handler = NodeHandler(data_manager, bls)
state = State()
state.txn_list = {}
state.get = lambda key, is_committed: state.txn_list.get(key, None)
state.set = lambda key, value: state.txn_list.update({key: value})
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
return handler
def db_manager(pool_state, domain_state, config_state, pool_ledger,
domain_ledger, config_ledger, idr_cache_store, attrib_store,
bls_store):
dbm = DatabaseManager()
dbm.register_new_database(POOL_LEDGER_ID, pool_ledger, pool_state)
dbm.register_new_database(DOMAIN_LEDGER_ID, domain_ledger, domain_state)
dbm.register_new_database(CONFIG_LEDGER_ID, config_ledger, config_state)
dbm.register_new_store(IDR_CACHE_LABEL, idr_cache_store)
dbm.register_new_store(ATTRIB_LABEL, attrib_store)
dbm.register_new_store(BLS_LABEL, bls_store)
return dbm
def txn_author_agreement_aml_handler(tconf, domain_state):
data_manager = DatabaseManager()
handler = TxnAuthorAgreementAmlHandler(data_manager, FakeSomething())
state = State()
state.txn_list = {}
state.get = lambda key, isCommitted=False: state.txn_list.get(key, None)
state.set = lambda key, value, isCommitted=False: state.txn_list.update(
{key: value})
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
data_manager.register_new_database(DOMAIN_LEDGER_ID, FakeSomething(),
domain_state)
return handler
def db_manager(tconf, tdir):
db_manager = DatabaseManager()
name = 'name'
idr_cache = IdrCache(
name,
initKeyValueStorage(KeyValueStorageType.Rocksdb,
tdir,
tconf.idrCacheDbName,
db_config=tconf.db_idr_cache_db_config))
db_manager.register_new_store('idr', idr_cache)
db_manager.register_new_database(DOMAIN_LEDGER_ID, get_fake_ledger(),
State())
return db_manager
def db_manager(tconf, tdir):
db_manager = DatabaseManager()
state = State()
state.txn_list = {}
state.get = lambda key, isCommitted=True: state.txn_list.get(key, None)
state.set = lambda key, value: state.txn_list.update({key: value})
name = 'name'
idr_cache = IdrCache(name,
initKeyValueStorage(KeyValueStorageType.Rocksdb,
tdir,
tconf.idrCacheDbName,
db_config=tconf.db_idr_cache_db_config))
db_manager.register_new_store(IDR_CACHE_LABEL, idr_cache)
db_manager.register_new_database(DOMAIN_LEDGER_ID, get_fake_ledger(), state)
return db_manager
def test_register_database_no_state(database_manager: DatabaseManager):
db_id_1 = 1
db_led_1 = FakeSomething()
db_state_1 = FakeSomething()
database_manager.register_new_database(db_id_1, db_led_1, db_state_1)
assert db_id_1 in database_manager._ledgers
assert db_id_1 in database_manager._states
assert database_manager._ledgers[db_id_1] == db_led_1
assert database_manager._states[db_id_1] == db_state_1
db_id_2 = 2
db_led_2 = FakeSomething()
database_manager.register_new_database(db_id_2, db_led_2)
assert db_id_2 in database_manager._ledgers
assert db_id_2 not in database_manager._states
assert database_manager._ledgers[db_id_2] == db_led_2
def test_register_database(database_manager: DatabaseManager):
db_id = 1
db_led = FakeSomething()
db_state = FakeSomething()
assert database_manager.get_database(db_id) is None
assert database_manager.get_ledger(db_id) is None
assert database_manager.get_state(db_id) is None
database_manager.register_new_database(db_id, db_led, db_state)
with pytest.raises(LogicError,
match='Trying to add already existing database'):
database_manager.register_new_database(db_id, FakeSomething(),
FakeSomething())
assert database_manager.get_database(db_id).ledger == db_led
assert database_manager.get_database(db_id).state == db_state
assert database_manager.get_ledger(db_id) == db_led
assert database_manager.get_state(db_id) == db_state
def ledgers_freeze_handler(tconf, domain_state, audit_ledger):
data_manager = DatabaseManager()
handler = LedgersFreezeHandler(data_manager)
state = PruningState(KeyValueStorageInMemory())
data_manager.register_new_database(handler.ledger_id, FakeSomething(),
state)
data_manager.register_new_database(DOMAIN_LEDGER_ID, FakeSomething(),
domain_state)
data_manager.register_new_database(AUDIT_LEDGER_ID, audit_ledger)
return handler
def db_manager(tconf, tdir, idr_cache):
db_manager = DatabaseManager()
db_manager.register_new_store(IDR_CACHE_LABEL, idr_cache)
db_manager.register_new_database(DOMAIN_LEDGER_ID, get_fake_ledger(),
PruningState(KeyValueStorageInMemory()))
db_manager.register_new_database(CONFIG_LEDGER_ID, get_fake_ledger(),
PruningState(KeyValueStorageInMemory()))
db_manager.register_new_database(POOL_LEDGER_ID, get_fake_ledger(),
PruningState(KeyValueStorageInMemory()))
return db_manager
def db_manager():
audit_ledger = FakeSomething(size=0,
get_last_committed_txn=lambda: None)
dbm = DatabaseManager()
dbm.register_new_database(AUDIT_LEDGER_ID, audit_ledger)
return dbm
def db_manager(config_state, config_ledger):
db = DatabaseManager()
db.register_new_database(CONFIG_LEDGER_ID, config_ledger, config_state)
return db
def db_manager():
audit_ledger = FakeSomething(size=0)
dbm = DatabaseManager()
dbm.register_new_database(AUDIT_LEDGER_ID, audit_ledger)
return dbm
