def test_14_forge_transaction(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
print("* forge transaction[0] and update the data in node 0")
txobj = transactions[0]
txdata = bytearray(bbclib.serialize(txobj))
txdata[int(len(txdata) / 3)] = txdata[int(len(txdata) / 3)] + 0x01
data_handler = cores[0].networking.domains[domain_id]['data']
sql = "UPDATE transaction_table SET transaction_data = %s WHERE transaction_id = %s" % \
(data_handler.db_adaptors[0].placeholder, data_handler.db_adaptors[0].placeholder)
data_handler.exec_sql(sql=sql,
args=(bytes(txdata), txobj.transaction_id),
commit=True)
print(
"* forge transaction[1] with the data of transaction[2] and update the data in node 1"
)
txobj = transactions[1]
txdata = bbclib.serialize(transactions[2])
data_handler = cores[1].networking.domains[domain_id]['data']
sql = "UPDATE transaction_table SET transaction_data = %s WHERE transaction_id = %s" % \
(data_handler.db_adaptors[0].placeholder, data_handler.db_adaptors[0].placeholder)
data_handler.exec_sql(sql=sql,
args=(bytes(txdata), txobj.transaction_id),
commit=True)
def test_05_insert_transaction(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
ret = data_handler.insert_transaction(bbclib.serialize(
transactions[0]),
transactions[0],
no_replication=True)
assert ret is None
def test_07_1_insert_transaction(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
global transaction
transaction = bbclib.BBcTransaction()
rtn = bbclib.BBcRelation()
rtn.asset_group_id = asset_group_id
rtn.asset = bbclib.BBcAsset()
rtn.asset.add(user_id=user_id1, asset_body=b'bbbbbb', asset_file=b'cccccccccc')
ptr = bbclib.BBcPointer()
ptr.add(transaction_id=txid1)
rtn.add(pointer=ptr)
wit = bbclib.BBcWitness()
transaction.add(relation=rtn, witness=wit)
wit.add_witness(user_id1)
sig = transaction.sign(private_key=keypair.private_key, public_key=keypair.public_key)
transaction.add_signature_object(user_id=user_id1, signature=sig)
transaction.digest()
asset_files = {
transaction.relations[0].asset.asset_id: transaction.relations[0].asset.asset_file,
}
ret = cores[0].insert_transaction(domain_id, bbclib.serialize(transaction), asset_files)
assert ret[KeyType.transaction_id] == transaction.transaction_id
ret = cores[0]._search_transaction_by_txid(domain_id, transaction.transaction_id)
assert ret is not None
assert len(ret[KeyType.all_asset_files]) == 1
print(ret)
print("-- wait 2 seconds --")
time.sleep(2)
def test_05_1__search_transaction_by_txid_other_node_not_found(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
print("-- insert transaction only at core_node_2 --")
global transaction
user1 = clients[2]['user_id']
transaction = bbclib.make_transaction(event_num=2, witness=True)
bbclib.add_event_asset(transaction, event_idx=0, asset_group_id=asset_group_id,
user_id=user1, asset_body=b'aaddbbdd')
bbclib.add_event_asset(transaction, event_idx=1, asset_group_id=asset_group_id,
user_id=user1, asset_file=b'112423')
for i, user in enumerate(clients):
transaction.witness.add_witness(user_id=clients[i]['user_id'])
for i, user in enumerate(clients):
sig = transaction.sign(keypair=clients[i]['keypair'])
transaction.witness.add_signature(user_id=clients[i]['user_id'], signature=sig)
transaction.digest()
print(transaction)
print("register transaction=", binascii.b2a_hex(transaction.transaction_id))
asset_file = dict()
asset_file[transaction.events[1].asset.asset_id] = transaction.events[1].asset.asset_file
ret = cores[2].insert_transaction(domain_id, bbclib.serialize(transaction), asset_file)
assert KeyType.transaction_id in ret
assert ret[KeyType.transaction_id] == transaction.transaction_id
# -- search the transaction at core_node_0
ret = cores[0]._search_transaction_by_txid(domain_id, transaction.transaction_id)
print(ret)
assert ret is None
def test_13_insert_first_transaction(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
user = clients[0]['user_id']
transactions[0] = bbclib.make_transaction(event_num=2, witness=True)
transactions[0].events[0].add(reference_index=0, mandatory_approver=user)
bbclib.add_event_asset(transactions[0], event_idx=0, asset_group_id=asset_group_id,
user_id=user, asset_body=b'123456')
bbclib.add_event_asset(transactions[0], event_idx=1, asset_group_id=asset_group_id,
user_id=user, asset_body=b'abcdefg')
transactions[0].witness.add_witness(user)
sig = transactions[0].sign(keypair=clients[0]['keypair'])
assert sig is not None
if sig is None:
print(bbclib.error_text)
import os
os._exit(1)
transactions[0].add_signature(user_id=user, signature=sig)
print(transactions[0])
transactions[0].digest()
global transaction_dat
transaction_dat = bbclib.serialize(transactions[0])
print("register transaction=", binascii.b2a_hex(transactions[0].transaction_id))
clients[0]['app'].insert_transaction(transactions[0])
dat = msg_processor[0].synchronize()
assert KeyType.transaction_id in dat
assert dat[KeyType.transaction_id] == transactions[0].transaction_id
time.sleep(2)
def insert_transaction(self, txobj):
"""Request to insert a legitimate transaction
Args:
txobj (BBcTransaction): Transaction object to insert
Returns:
bytes: query_id
"""
if txobj.transaction_id is None:
txobj.digest()
dat = self._make_message_structure(MsgType.REQUEST_INSERT)
dat[KeyType.transaction_data] = bbclib.serialize(txobj)
ast = dict()
for evt in txobj.events:
if evt.asset is None:
continue
asset_digest, content = evt.asset.get_asset_file()
if content is not None:
ast[evt.asset.asset_id] = content
for rtn in txobj.relations:
if rtn.asset is None:
continue
asset_digest, content = rtn.asset.get_asset_file()
if content is not None:
ast[rtn.asset.asset_id] = content
dat[KeyType.all_asset_files] = ast
return self._send_msg(dat)
def test_03_insert_transaction(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
asset_files = {
transactions[0].relations[0].asset.asset_id: transactions[0].relations[0].asset.asset_file,
}
ret = data_handler.insert_transaction(bbclib.serialize(transactions[0]), transactions[0],
asset_files=asset_files, no_replication=True)
assert asset_group_id1 in ret and asset_group_id2 in ret
def gather_signatures(self,
txobj,
reference_obj=None,
asset_files=None,
destinations=None,
anycast=False):
"""Request to gather signatures from the specified user_ids
Args:
txobj (BBcTransaction):
reference_obj (BBcReference): BBcReference object that includes the information about destinations
asset_files (dict): mapping from asset_id to its file content
destinations (list): list of destination user_ids
anycast (bool): True if this message is for anycasting
Returns:
bytes: query_id
"""
if reference_obj is None and destinations is None:
return False
dat = self._make_message_structure(MsgType.REQUEST_GATHER_SIGNATURE)
dat[KeyType.transaction_data] = bbclib.serialize(txobj)
dat[KeyType.transaction_id] = txobj.transaction_id
if anycast:
dat[KeyType.is_anycast] = True
if reference_obj is not None:
dat[KeyType.destination_user_ids] = reference_obj.get_destinations(
)
referred_transactions = {
reference_obj.transaction_id:
bbclib.serialize(reference_obj.ref_transaction)
}
if len(referred_transactions) > 0:
dat[KeyType.transactions] = referred_transactions
elif destinations is not None:
dat[KeyType.destination_user_ids] = destinations
if isinstance(asset_files, dict):
dat[KeyType.all_asset_files] = asset_files
return self._send_msg(dat)
def _insert_transaction_into_a_db(self,
db_num,
txobj,
fmt_type=bbclib_config.DEFAULT_BBC_FORMAT
):
"""Insert transaction data into the transaction table of the specified DB
Args:
db_num (int): index of DB if multiple DBs are used
txobj (BBcTransaction): transaction object to insert
fmt_type (int): 2-byte value of BBcFormat type
Returns:
bool: True if successful
"""
#print("_insert_transaction_into_a_db: for txid =", txobj.transaction_id.hex())
txdata = bbclib.serialize(txobj, format_type=fmt_type)
ret = self.exec_sql(
db_num=db_num,
sql="INSERT INTO transaction_table VALUES (%s,%s)" %
(self.db_adaptors[0].placeholder, self.db_adaptors[0].placeholder),
args=(txobj.transaction_id, txdata),
commit=True)
if ret is None:
return False
for asset_group_id, asset_id, user_id, fileflag, filedigest in self.get_asset_info(
txobj):
self.exec_sql(
db_num=db_num,
sql=
"INSERT INTO asset_info_table(transaction_id, asset_group_id, asset_id, user_id) "
"VALUES (%s, %s, %s, %s)" % (self.db_adaptors[0].placeholder,
self.db_adaptors[0].placeholder,
self.db_adaptors[0].placeholder,
self.db_adaptors[0].placeholder),
args=(txobj.transaction_id, asset_group_id, asset_id, user_id),
commit=True)
for base, point_to in self._get_topology_info(txobj):
self.exec_sql(
db_num=db_num,
sql="INSERT INTO topology_table(base, point_to) VALUES (%s, %s)"
% (self.db_adaptors[0].placeholder,
self.db_adaptors[0].placeholder),
args=(base, point_to),
commit=True)
#print("topology: base:%s, point_to:%s" % (base.hex(), point_to.hex()))
return True
def _send_transaction_data(self, dat):
"""Send transaction data if having valid one"""
#print("_send_transaction_data::")
transaction_id = dat[KeyType.transaction_id]
for idx in range(len(self.data_handler.db_adaptors)):
result_txobj, result_asset_files = self.data_handler.search_transaction(
transaction_id=transaction_id, db_num=idx)
txobj_is_valid, valid_assets, invalid_assets = bbclib.validate_transaction_object(
result_txobj[transaction_id])
if txobj_is_valid:
dat[KeyType.command] = RepairManager.RESPONSE_TRANSACTION_DATA
dat[KeyType.transaction_data] = bbclib.serialize(
result_txobj[transaction_id])
dat[KeyType.destination_node_id] = dat[KeyType.source_node_id]
self.network.send_message_in_network(None,
domain_id=self.domain_id,
msg=dat)
return
def test_04_insert(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
sig = transactions[0].sign(keypair=clients[0]['keypair'])
assert sig is not None
if sig is None:
print(bbclib.error_text)
import os
os._exit(1)
transactions[0].witness.add_signature(user_id=clients[0]['user_id'],
signature=sig)
print(transactions[0])
transactions[0].digest()
global transaction_dat
transaction_dat = bbclib.serialize(transactions[0])
print("register transaction=",
binascii.b2a_hex(transactions[0].transaction_id))
clients[0]['app'].insert_transaction(transactions[0])
dat = msg_processor[0].synchronize()
assert KeyType.transaction_id in dat
assert dat[KeyType.transaction_id] == transactions[0].transaction_id
def test_03_transaction_insert(self):
print("\n-----", sys._getframe().f_code.co_name, "-----")
global transaction
print("-- insert transaction only at core_node_1 --")
user1 = clients[1]['user_id']
transaction = bbclib.make_transaction(event_num=2, witness=True)
transaction.events[0].add(mandatory_approver=clients[1]['user_id'])
bbclib.add_event_asset(transaction, event_idx=0, asset_group_id=asset_group_id,
user_id=user1, asset_body=b'123456')
bbclib.add_event_asset(transaction, event_idx=1, asset_group_id=asset_group_id,
user_id=user1, asset_file=b'abcdefg')
transaction.witness.add_witness(user_id=user1)
sig = transaction.sign(keypair=clients[1]['keypair'])
transaction.witness.add_signature(user_id=user1, signature=sig)
transaction.digest()
print(transaction)
print("register transaction=", binascii.b2a_hex(transaction.transaction_id))
asset_file = dict()
asset_file[transaction.events[1].asset.asset_id] = transaction.events[1].asset.asset_file
ret = cores[1].insert_transaction(domain_id, bbclib.serialize(transaction), asset_file)
assert ret[KeyType.transaction_id] == transaction.transaction_id
