Mirroristas/planetmint
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint.git synced 2025-11-24 14:35:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add cleanup and add constants

Browse Source 
Signed-off-by: cybnon <stefan.weber93@googlemail.com>
This commit is contained in:
cybnon 2022-11-17 10:59:36 +01:00
parent 101706a3f5
commit 9a0823001b
3 changed files with 126 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
planetmint/backend/tarantool/const.py Normal file
View File

@ -0,0 +1,14 @@
# Copyright © 2020 Interplanetary Database Association e.V.,
# Planetmint and IPDB software contributors.
# SPDX-License-Identifier: (Apache-2.0 AND CC-BY-4.0)
# Code is Apache-2.0 and docs are CC-BY-4.0
TARANT_TABLE_META_DATA = "meta_data"
TARANT_TABLE_ASSETS = "assets"
TARANT_TABLE_KEYS = "keys"
TARANT_TABLE_TRANSACTION = "transactions"
TARANT_TABLE_INPUT = "inputs"
TARANT_TABLE_OUTPUT = "outputs"
TARANT_TABLE_SCRIPT = "scripts"
TARANT_TX_ID_SEARCH = "txid_search"
TARANT_ID_SEARCH = "id_search"

135
planetmint/backend/tarantool/query.py
View File

@ -10,6 +10,9 @@ from hashlib import sha256
from operator import itemgetter from operator import itemgetter
from tarantool.error import DatabaseError from tarantool.error import DatabaseError
from planetmint.backend import query from planetmint.backend import query
from planetmint.backend.tarantool.const import TARANT_TABLE_META_DATA, TARANT_TABLE_ASSETS, TARANT_TABLE_KEYS, \
TARANT_TABLE_TRANSACTION, TARANT_TABLE_INPUT, TARANT_TABLE_OUTPUT, TARANT_TABLE_SCRIPT, TARANT_TX_ID_SEARCH, \
TARANT_ID_SEARCH
from planetmint.backend.utils import module_dispatch_registrar from planetmint.backend.utils import module_dispatch_registrar
from planetmint.backend.models import Asset, MetaData, Input, Fulfills from planetmint.backend.models import Asset, MetaData, Input, Fulfills
from planetmint.backend.tarantool.connection import TarantoolDBConnection from planetmint.backend.tarantool.connection import TarantoolDBConnection
@ -22,27 +25,27 @@ register_query = module_dispatch_registrar(query)
def _group_transaction_by_ids(connection, txids: list): def _group_transaction_by_ids(connection, txids: list):
_transactions = [] _transactions = []
for txid in txids: for txid in txids:
_txobject = connection.run(connection.space("transactions").select(txid, index="id_search")) _txobject = connection.run(connection.space(TARANT_TABLE_TRANSACTION).select(txid, index=TARANT_ID_SEARCH))
if len(_txobject) == 0: if len(_txobject) == 0:
continue continue
_txobject = _txobject[0] _txobject = _txobject[0]
_txinputs = connection.run(connection.space("inputs").select(txid, index="id_search")) _txinputs = connection.run(connection.space(TARANT_TABLE_INPUT).select(txid, index=TARANT_ID_SEARCH))
_txoutputs = connection.run(connection.space("outputs").select(txid, index="id_search")) _txoutputs = connection.run(connection.space(TARANT_TABLE_OUTPUT).select(txid, index=TARANT_ID_SEARCH))
_txkeys = connection.run(connection.space("keys").select(txid, index="txid_search")) _txkeys = connection.run(connection.space(TARANT_TABLE_KEYS).select(txid, index=TARANT_TX_ID_SEARCH))
_txassets = connection.run(connection.space("assets").select(txid, index="txid_search")) _txassets = connection.run(connection.space(TARANT_TABLE_ASSETS).select(txid, index=TARANT_TX_ID_SEARCH))
_txmeta = connection.run(connection.space("meta_data").select(txid, index="id_search")) _txmeta = connection.run(connection.space(TARANT_TABLE_META_DATA).select(txid, index=TARANT_ID_SEARCH))
_txscript = connection.run(connection.space("scripts").select(txid, index="txid_search")) _txscript = connection.run(connection.space(TARANT_TABLE_SCRIPT).select(txid, index=TARANT_TX_ID_SEARCH))
_txinputs = sorted(_txinputs, key=itemgetter(6), reverse=False) _txinputs = sorted(_txinputs, key=itemgetter(6), reverse=False)
_txoutputs = sorted(_txoutputs, key=itemgetter(8), reverse=False) _txoutputs = sorted(_txoutputs, key=itemgetter(8), reverse=False)
result_map = { result_map = {
"transaction": _txobject, TARANT_TABLE_TRANSACTION: _txobject,
"inputs": _txinputs, TARANT_TABLE_INPUT: _txinputs,
"outputs": _txoutputs, TARANT_TABLE_OUTPUT: _txoutputs,
"keys": _txkeys, TARANT_TABLE_KEYS: _txkeys,
"assets": _txassets, TARANT_TABLE_ASSETS: _txassets,
"metadata": _txmeta, TARANT_TABLE_META_DATA: _txmeta,
"script": _txscript, TARANT_TABLE_SCRIPT: _txscript,
} }
tx_compose = TransactionCompose(db_results=result_map) tx_compose = TransactionCompose(db_results=result_map)
_transaction = tx_compose.convert_to_dict() _transaction = tx_compose.convert_to_dict()
@ -51,7 +54,7 @@ def _group_transaction_by_ids(connection, txids: list):
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_inputs_by_tx_id(connection, tx_id: str) -> list[Input]: def get_inputs_by_tx_id(connection, tx_id: str) -> list[Input]:
_inputs = connection.run(connection.space("inputs").select(tx_id, index="id_search")) _inputs = connection.run(connection.space(TARANT_TABLE_INPUT).select(tx_id, index=TARANT_ID_SEARCH))
_sorted_inputs = sorted(_inputs, key=itemgetter(6)) _sorted_inputs = sorted(_inputs, key=itemgetter(6))
inputs = [] inputs = []
@ -74,7 +77,7 @@ def get_inputs_by_tx_id(connection, tx_id: str) -> list[Input]:
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def store_transaction_inputs(connection, inputs: list[Input]): def store_transaction_inputs(connection, inputs: list[Input]):
for index, input in enumerate(inputs): for index, input in enumerate(inputs):
connection.run(connection.space("inputs").insert(( connection.run(connection.space(TARANT_TABLE_INPUT).insert((
input.tx_id, input.tx_id,
input.fulfillment, input.fulfillment,
input.owners_before, input.owners_before,
@ -91,25 +94,25 @@ def store_transactions(connection, signed_transactions: list):
txprepare = TransactionDecompose(transaction) txprepare = TransactionDecompose(transaction)
txtuples = txprepare.convert_to_tuple() txtuples = txprepare.convert_to_tuple()
try: try:
connection.run(connection.space("transactions").insert(txtuples["transactions"]), only_data=False) connection.run(connection.space(TARANT_TABLE_TRANSACTION).insert(txtuples[TARANT_TABLE_TRANSACTION]), only_data=False)
except: # This is used for omitting duplicate error in database for test -> test_bigchain_api::test_double_inclusion # noqa: E501, E722 except: # This is used for omitting duplicate error in database for test -> test_bigchain_api::test_double_inclusion # noqa: E501, E722
continue continue
for _in in txtuples["inputs"]: for _in in txtuples[TARANT_TABLE_INPUT]:
connection.run(connection.space("inputs").insert(_in), only_data=False) connection.run(connection.space(TARANT_TABLE_INPUT).insert(_in), only_data=False)
for _out in txtuples["outputs"]: for _out in txtuples[TARANT_TABLE_OUTPUT]:
connection.run(connection.space("outputs").insert(_out), only_data=False) connection.run(connection.space(TARANT_TABLE_OUTPUT).insert(_out), only_data=False)
for _key in txtuples["keys"]: for _key in txtuples[TARANT_TABLE_KEYS]:
connection.run(connection.space("keys").insert(_key), only_data=False) connection.run(connection.space(TARANT_TABLE_KEYS).insert(_key), only_data=False)
if txtuples["metadata"] is not None: if txtuples[TARANT_TABLE_META_DATA] is not None:
connection.run(connection.space("meta_data").insert(txtuples["metadata"]), only_data=False) connection.run(connection.space(TARANT_TABLE_META_DATA).insert(txtuples[TARANT_TABLE_META_DATA]), only_data=False)
if txtuples["assets"] is not None: if txtuples[TARANT_TABLE_ASSETS] is not None:
connection.run(connection.space("assets").insert(txtuples["assets"]), only_data=False) connection.run(connection.space(TARANT_TABLE_ASSETS).insert(txtuples[TARANT_TABLE_ASSETS]), only_data=False)
if txtuples["script"] is not None: if txtuples["script"] is not None:
connection.run(connection.space("scripts").insert(txtuples["script"]), only_data=False) connection.run(connection.space(TARANT_TABLE_SCRIPT).insert(txtuples["script"]), only_data=False)
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
@ -128,7 +131,7 @@ def get_transactions(connection, transactions_ids: list):
def store_metadatas(connection, metadata: list[MetaData]): def store_metadatas(connection, metadata: list[MetaData]):
for meta in metadata: for meta in metadata:
connection.run( connection.run(
connection.space("meta_data").insert( connection.space(TARANT_TABLE_META_DATA).insert(
(meta.id, json.dumps(meta.metadata)) (meta.id, json.dumps(meta.metadata))
) # noqa: E713 ) # noqa: E713
) )
@ -138,7 +141,7 @@ def store_metadatas(connection, metadata: list[MetaData]):
def get_metadata(connection, transaction_ids: list) -> list[MetaData]: def get_metadata(connection, transaction_ids: list) -> list[MetaData]:
_returned_data = [] _returned_data = []
for _id in transaction_ids: for _id in transaction_ids:
metadata = connection.run(connection.space("meta_data").select(_id, index="id_search")) metadata = connection.run(connection.space(TARANT_TABLE_META_DATA).select(_id, index=TARANT_ID_SEARCH))
if metadata is not None: if metadata is not None:
if len(metadata) > 0: if len(metadata) > 0:
metadata[0] = list(metadata[0]) metadata[0] = list(metadata[0])
@ -152,7 +155,7 @@ def get_metadata(connection, transaction_ids: list) -> list[MetaData]:
def store_asset(connection, asset: Asset): def store_asset(connection, asset: Asset):
tuple_asset = (json.dumps(asset.data), asset.tx_id, asset.id) tuple_asset = (json.dumps(asset.data), asset.tx_id, asset.id)
try: try:
return connection.run(connection.space("assets").insert(tuple_asset), only_data=False) return connection.run(connection.space(TARANT_TABLE_ASSETS).insert(tuple_asset), only_data=False)
except DatabaseError: except DatabaseError:
pass pass
@ -165,7 +168,7 @@ def store_assets(connection, assets: list):
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_asset(connection, asset_id: str) -> Asset: def get_asset(connection, asset_id: str) -> Asset:
_data = connection.run(connection.space("assets").select(asset_id, index="txid_search")) _data = connection.run(connection.space(TARANT_TABLE_ASSETS).select(asset_id, index=TARANT_TX_ID_SEARCH))
return Asset(_data[0][2], _data[0][1], json.loads(_data[0][0])) return Asset(_data[0][2], _data[0][1], json.loads(_data[0][0]))
@ -173,7 +176,7 @@ def get_asset(connection, asset_id: str) -> Asset:
def get_assets(connection, assets_ids: list) -> list[Asset]: def get_assets(connection, assets_ids: list) -> list[Asset]:
_returned_data = [] _returned_data = []
for _id in list(set(assets_ids)): for _id in list(set(assets_ids)):
res = connection.run(connection.space("assets").select(_id, index="txid_search")) res = connection.run(connection.space(TARANT_TABLE_ASSETS).select(_id, index=TARANT_TX_ID_SEARCH))
_returned_data.append(res[0]) _returned_data.append(res[0])
sorted_assets = sorted(_returned_data, key=lambda k: k[1], reverse=False) sorted_assets = sorted(_returned_data, key=lambda k: k[1], reverse=False)
@ -183,7 +186,7 @@ def get_assets(connection, assets_ids: list) -> list[Asset]:
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_spent(connection, fullfil_transaction_id: str, fullfil_output_index: str): def get_spent(connection, fullfil_transaction_id: str, fullfil_output_index: str):
_inputs = connection.run( _inputs = connection.run(
connection.space("inputs").select([fullfil_transaction_id, str(fullfil_output_index)], index="spent_search") connection.space(TARANT_TABLE_INPUT).select([fullfil_transaction_id, str(fullfil_output_index)], index="spent_search")
) )
_transactions = _group_transaction_by_ids(txids=[inp[0] for inp in _inputs], connection=connection) _transactions = _group_transaction_by_ids(txids=[inp[0] for inp in _inputs], connection=connection)
return _transactions return _transactions
@ -192,7 +195,7 @@ def get_spent(connection, fullfil_transaction_id: str, fullfil_output_index: str
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_latest_block(connection): # TODO Here is used DESCENDING OPERATOR def get_latest_block(connection): # TODO Here is used DESCENDING OPERATOR
_all_blocks = connection.run(connection.space("blocks").select()) _all_blocks = connection.run(connection.space("blocks").select())
block = {"app_hash": "", "height": 0, "transactions": []} block = {"app_hash": "", "height": 0, TARANT_TABLE_TRANSACTION: []}
if _all_blocks is not None: if _all_blocks is not None:
if len(_all_blocks) > 0: if len(_all_blocks) > 0:
@ -200,7 +203,7 @@ def get_latest_block(connection): # TODO Here is used DESCENDING OPERATOR
_txids = connection.run(connection.space("blocks_tx").select(_block[2], index="block_search")) _txids = connection.run(connection.space("blocks_tx").select(_block[2], index="block_search"))
block["app_hash"] = _block[0] block["app_hash"] = _block[0]
block["height"] = _block[1] block["height"] = _block[1]
block["transactions"] = [tx[0] for tx in _txids] block[TARANT_TABLE_TRANSACTION] = [tx[0] for tx in _txids]
else: else:
block = None block = None
return block return block
@ -212,7 +215,7 @@ def store_block(connection, block: dict):
connection.run( connection.run(
connection.space("blocks").insert((block["app_hash"], block["height"], block_unique_id)), only_data=False connection.space("blocks").insert((block["app_hash"], block["height"], block_unique_id)), only_data=False
) )
for txid in block["transactions"]: for txid in block[TARANT_TABLE_TRANSACTION]:
connection.run(connection.space("blocks_tx").insert((txid, block_unique_id)), only_data=False) connection.run(connection.space("blocks_tx").insert((txid, block_unique_id)), only_data=False)
@ -230,21 +233,21 @@ def get_txids_filtered(
_transactions = [] _transactions = []
if actions["sets"][0] == "CREATE": # + if actions["sets"][0] == "CREATE": # +
_transactions = connection.run( _transactions = connection.run(
connection.space("transactions").select([operation, asset_ids[0]], index=actions["index"]) connection.space(TARANT_TABLE_TRANSACTION).select([operation, asset_ids[0]], index=actions["index"])
) )
elif actions["sets"][0] == "TRANSFER": # + elif actions["sets"][0] == "TRANSFER": # +
_assets = connection.run(connection.space("assets").select(asset_ids, index="only_asset_search")) _assets = connection.run(connection.space(TARANT_TABLE_ASSETS).select(asset_ids, index="only_asset_search"))
for asset in _assets: for asset in _assets:
_txid = asset[1] _txid = asset[1]
_tmp_transactions = connection.run( _tmp_transactions = connection.run(
connection.space("transactions").select([operation, _txid], index=actions["index"]) connection.space(TARANT_TABLE_TRANSACTION).select([operation, _txid], index=actions["index"])
) )
if len(_tmp_transactions) != 0: if len(_tmp_transactions) != 0:
_transactions.extend(_tmp_transactions) _transactions.extend(_tmp_transactions)
else: else:
_tx_ids = connection.run(connection.space("transactions").select(asset_ids, index="id_search")) _tx_ids = connection.run(connection.space(TARANT_TABLE_TRANSACTION).select(asset_ids, index=TARANT_ID_SEARCH))
_assets_ids = connection.run(connection.space("assets").select(asset_ids, index="only_asset_search")) _assets_ids = connection.run(connection.space(TARANT_TABLE_ASSETS).select(asset_ids, index="only_asset_search"))
return tuple(set([sublist[1] for sublist in _assets_ids] + [sublist[0] for sublist in _tx_ids])) return tuple(set([sublist[1] for sublist in _assets_ids] + [sublist[0] for sublist in _tx_ids]))
if last_tx: if last_tx:
@ -254,27 +257,27 @@ def get_txids_filtered(
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def text_search(conn, search, table="assets", limit=0): def text_search(conn, search, table=TARANT_TABLE_ASSETS, limit=0):
pattern = ".{}.".format(search) pattern = ".{}.".format(search)
field_no = 1 if table == "assets" else 2 # 2 for meta_data field_no = 1 if table == TARANT_TABLE_ASSETS else 2 # 2 for meta_data
res = conn.run(conn.space(table).call("indexed_pattern_search", (table, field_no, pattern))) res = conn.run(conn.space(table).call("indexed_pattern_search", (table, field_no, pattern)))
to_return = [] to_return = []
if len(res[0]): # NEEDS BEAUTIFICATION if len(res[0]): # NEEDS BEAUTIFICATION
if table == "assets": if table == TARANT_TABLE_ASSETS:
for result in res[0]: for result in res[0]:
to_return.append({"data": json.loads(result[0])["data"], "id": result[1]}) to_return.append({"data": json.loads(result[0])["data"], "id": result[1]})
else: else:
for result in res[0]: for result in res[0]:
to_return.append({"metadata": json.loads(result[1]), "id": result[0]}) to_return.append({TARANT_TABLE_META_DATA: json.loads(result[1]), "id": result[0]})
return to_return if limit == 0 else to_return[:limit] return to_return if limit == 0 else to_return[:limit]
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_owned_ids(connection, owner: str): def get_owned_ids(connection, owner: str):
_keys = connection.run(connection.space("keys").select(owner, index="keys_search")) _keys = connection.run(connection.space(TARANT_TABLE_KEYS).select(owner, index="keys_search"))
if _keys is None or len(_keys) == 0: if _keys is None or len(_keys) == 0:
return [] return []
_transactionids = list(set([key[1] for key in _keys])) _transactionids = list(set([key[1] for key in _keys]))
@ -298,18 +301,20 @@ def get_spending_transactions(connection, inputs):
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_block(connection, block_id=[]): def get_block(connection, block_id=None):
if block_id is None:
block_id = []
_block = connection.run(connection.space("blocks").select(block_id, index="block_search", limit=1)) _block = connection.run(connection.space("blocks").select(block_id, index="block_search", limit=1))
if _block is None or len(_block) == 0: if _block is None or len(_block) == 0:
return [] return []
_block = _block[0] _block = _block[0]
_txblock = connection.run(connection.space("blocks_tx").select(_block[2], index="block_search")) _txblock = connection.run(connection.space("blocks_tx").select(_block[2], index="block_search"))
return {"app_hash": _block[0], "height": _block[1], "transactions": [_tx[0] for _tx in _txblock]} return {"app_hash": _block[0], "height": _block[1], TARANT_TABLE_TRANSACTION: [_tx[0] for _tx in _txblock]}
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_block_with_transaction(connection, txid: str): def get_block_with_transaction(connection, txid: str):
_all_blocks_tx = connection.run(connection.space("blocks_tx").select(txid, index="id_search")) _all_blocks_tx = connection.run(connection.space("blocks_tx").select(txid, index=TARANT_ID_SEARCH))
if _all_blocks_tx is None or len(_all_blocks_tx) == 0: if _all_blocks_tx is None or len(_all_blocks_tx) == 0:
return [] return []
_block = connection.run(connection.space("blocks").select(_all_blocks_tx[0][1], index="block_id_search")) _block = connection.run(connection.space("blocks").select(_all_blocks_tx[0][1], index="block_id_search"))
@ -319,23 +324,23 @@ def get_block_with_transaction(connection, txid: str):
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def delete_transactions(connection, txn_ids: list): def delete_transactions(connection, txn_ids: list):
for _id in txn_ids: for _id in txn_ids:
connection.run(connection.space("transactions").delete(_id), only_data=False) connection.run(connection.space(TARANT_TABLE_TRANSACTION).delete(_id), only_data=False)
for _id in txn_ids: for _id in txn_ids:
_inputs = connection.run(connection.space("inputs").select(_id, index="id_search"), only_data=False) _inputs = connection.run(connection.space(TARANT_TABLE_INPUT).select(_id, index=TARANT_ID_SEARCH), only_data=False)
_outputs = connection.run(connection.space("outputs").select(_id, index="id_search"), only_data=False) _outputs = connection.run(connection.space(TARANT_TABLE_OUTPUT).select(_id, index=TARANT_ID_SEARCH), only_data=False)
_keys = connection.run(connection.space("keys").select(_id, index="txid_search"), only_data=False) _keys = connection.run(connection.space(TARANT_TABLE_KEYS).select(_id, index=TARANT_TX_ID_SEARCH), only_data=False)
for _kID in _keys: for _kID in _keys:
connection.run(connection.space("keys").delete(_kID[0], index="id_search"), only_data=False) connection.run(connection.space(TARANT_TABLE_KEYS).delete(_kID[0], index=TARANT_ID_SEARCH), only_data=False)
for _inpID in _inputs: for _inpID in _inputs:
connection.run(connection.space("inputs").delete(_inpID[5], index="delete_search"), only_data=False) connection.run(connection.space(TARANT_TABLE_INPUT).delete(_inpID[5], index="delete_search"), only_data=False)
for _outpID in _outputs: for _outpID in _outputs:
connection.run(connection.space("outputs").delete(_outpID[5], index="unique_search"), only_data=False) connection.run(connection.space(TARANT_TABLE_OUTPUT).delete(_outpID[5], index="unique_search"), only_data=False)
for _id in txn_ids: for _id in txn_ids:
connection.run(connection.space("meta_data").delete(_id, index="id_search"), only_data=False) connection.run(connection.space(TARANT_TABLE_META_DATA).delete(_id, index=TARANT_ID_SEARCH), only_data=False)
for _id in txn_ids: for _id in txn_ids:
connection.run(connection.space("assets").delete(_id, index="txid_search"), only_data=False) connection.run(connection.space(TARANT_TABLE_ASSETS).delete(_id, index=TARANT_TX_ID_SEARCH), only_data=False)
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
@ -370,13 +375,13 @@ def get_unspent_outputs(connection, query=None): # for now we don't have implem
def store_pre_commit_state(connection, state: dict): def store_pre_commit_state(connection, state: dict):
_precommit = connection.run(connection.space("pre_commits").select([], limit=1)) _precommit = connection.run(connection.space("pre_commits").select([], limit=1))
_precommitTuple = ( _precommitTuple = (
(uuid4().hex, state["height"], state["transactions"]) (uuid4().hex, state["height"], state[TARANT_TABLE_TRANSACTION])
if _precommit is None or len(_precommit) == 0 if _precommit is None or len(_precommit) == 0
else _precommit[0] else _precommit[0]
) )
connection.run( connection.run(
connection.space("pre_commits").upsert( connection.space("pre_commits").upsert(
_precommitTuple, op_list=[("=", 1, state["height"]), ("=", 2, state["transactions"])], limit=1 _precommitTuple, op_list=[("=", 1, state["height"]), ("=", 2, state[TARANT_TABLE_TRANSACTION])], limit=1
), ),
only_data=False, only_data=False,
) )
@ -384,11 +389,11 @@ def store_pre_commit_state(connection, state: dict):
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_pre_commit_state(connection): def get_pre_commit_state(connection):
_commit = connection.run(connection.space("pre_commits").select([], index="id_search")) _commit = connection.run(connection.space("pre_commits").select([], index=TARANT_ID_SEARCH))
if _commit is None or len(_commit) == 0: if _commit is None or len(_commit) == 0:
return None return None
_commit = sorted(_commit, key=itemgetter(1), reverse=False)[0] _commit = sorted(_commit, key=itemgetter(1), reverse=False)[0]
return {"height": _commit[1], "transactions": _commit[2]} return {"height": _commit[1], TARANT_TABLE_TRANSACTION: _commit[2]}
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
@ -456,7 +461,7 @@ def get_validator_set(connection, height: int = None):
@register_query(TarantoolDBConnection) @register_query(TarantoolDBConnection)
def get_election(connection, election_id: str): def get_election(connection, election_id: str):
_elections = connection.run(connection.space("elections").select(election_id, index="id_search")) _elections = connection.run(connection.space("elections").select(election_id, index=TARANT_ID_SEARCH))
if _elections is None or len(_elections) == 0: if _elections is None or len(_elections) == 0:
return None return None
_election = sorted(_elections, key=itemgetter(0), reverse=True)[0] _election = sorted(_elections, key=itemgetter(0), reverse=True)[0]
@ -469,7 +474,7 @@ def get_asset_tokens_for_public_key(
): # FIXME Something can be wrong with this function ! (public_key) is not used # noqa: E501 ): # FIXME Something can be wrong with this function ! (public_key) is not used # noqa: E501
# space = connection.space("keys") # space = connection.space("keys")
# _keys = space.select([public_key], index="keys_search") # _keys = space.select([public_key], index="keys_search")
_transactions = connection.run(connection.space("assets").select([asset_id], index="assetid_search")) _transactions = connection.run(connection.space(TARANT_TABLE_ASSETS).select([asset_id], index="assetid_search"))
# _transactions = _transactions # _transactions = _transactions
# _keys = _keys.data # _keys = _keys.data
_grouped_transactions = _group_transaction_by_ids(connection=connection, txids=[_tx[1] for _tx in _transactions]) _grouped_transactions = _group_transaction_by_ids(connection=connection, txids=[_tx[1] for _tx in _transactions])

83
planetmint/backend/tarantool/transaction/tools.py
View File

@ -4,6 +4,9 @@ import json
from secrets import token_hex from secrets import token_hex
from transactions.common.memoize import HDict from transactions.common.memoize import HDict
from planetmint.backend.tarantool.const import TARANT_TABLE_META_DATA, TARANT_TABLE_ASSETS, TARANT_TABLE_KEYS, \
TARANT_TABLE_TRANSACTION, TARANT_TABLE_INPUT, TARANT_TABLE_OUTPUT, TARANT_TABLE_SCRIPT
def get_items(_list): def get_items(_list):
for item in _list: for item in _list:
@ -12,13 +15,12 @@ def get_items(_list):
def _save_keys_order(dictionary): def _save_keys_order(dictionary):
filter_keys = ["asset", "metadata"] filter_keys = ["asset", TARANT_TABLE_META_DATA]
if type(dictionary) is dict or type(dictionary) is HDict: if type(dictionary) is dict or type(dictionary) is HDict:
keys = list(dictionary.keys()) keys = list(dictionary.keys())
_map = {} _map = {}
for key in keys: for key in keys:
_map[key] = _save_keys_order(dictionary=dictionary[key]) if key not in filter_keys else None _map[key] = _save_keys_order(dictionary=dictionary[key]) if key not in filter_keys else None
return _map return _map
elif type(dictionary) is list: elif type(dictionary) is list:
_maps = [] _maps = []
@ -29,21 +31,20 @@ def _save_keys_order(dictionary):
_map[key] = _save_keys_order(dictionary=_item[key]) if key not in filter_keys else None _map[key] = _save_keys_order(dictionary=_item[key]) if key not in filter_keys else None
_maps.append(_map) _maps.append(_map)
return _maps return _maps
else: return None
return None
class TransactionDecompose: class TransactionDecompose:
def __init__(self, _transaction): def __init__(self, _transaction):
self._transaction = _transaction self._transaction = _transaction
self._tuple_transaction = { self._tuple_transaction = {
"transactions": (), TARANT_TABLE_TRANSACTION: (),
"inputs": [], TARANT_TABLE_INPUT: [],
"outputs": [], TARANT_TABLE_OUTPUT: [],
"keys": [], TARANT_TABLE_KEYS: [],
"script": None, TARANT_TABLE_SCRIPT: None,
"metadata": None, TARANT_TABLE_META_DATA: None,
"assets": None, TARANT_TABLE_ASSETS: None,
} }
def get_map(self, dictionary: dict = None): def get_map(self, dictionary: dict = None):
@ -58,23 +59,23 @@ class TransactionDecompose:
return token_hex(n) return token_hex(n)
def _metadata_check(self): def _metadata_check(self):
metadata = self._transaction.get("metadata") metadata = self._transaction.get(TARANT_TABLE_META_DATA)
if metadata is None: if metadata is None:
return return
self._tuple_transaction["metadata"] = (self._transaction["id"], json.dumps(metadata)) self._tuple_transaction[TARANT_TABLE_META_DATA] = (self._transaction["id"], json.dumps(metadata))
def __asset_check(self): def __asset_check(self):
_asset = self._transaction.get("assets") _asset = self._transaction.get(TARANT_TABLE_ASSETS)
if _asset is None: if _asset is None:
return return
asset_id = _asset[0]["id"] if _asset[0].get("id") is not None else self._transaction["id"] asset_id = _asset[0]["id"] if _asset[0].get("id") is not None else self._transaction["id"]
self._tuple_transaction["assets"] = (json.dumps(_asset), self._transaction["id"], asset_id) self._tuple_transaction[TARANT_TABLE_ASSETS] = (json.dumps(_asset), self._transaction["id"], asset_id)
def __prepare_inputs(self): def __prepare_inputs(self):
_inputs = [] _inputs = []
input_index = 0 input_index = 0
for _input in self._transaction["inputs"]: for _input in self._transaction[TARANT_TABLE_INPUT]:
_inputs.append( _inputs.append(
( (
@ -94,7 +95,7 @@ class TransactionDecompose:
_outputs = [] _outputs = []
_keys = [] _keys = []
output_index = 0 output_index = 0
for _output in self._transaction["outputs"]: for _output in self._transaction[TARANT_TABLE_OUTPUT]:
output_id = self.__create_hash(7) output_id = self.__create_hash(7)
if _output["condition"]["details"].get("subconditions") is None: if _output["condition"]["details"].get("subconditions") is None:
tmp_output = ( tmp_output = (
@ -136,48 +137,48 @@ class TransactionDecompose:
def __prepare_script(self): def __prepare_script(self):
try: try:
return (self._transaction["id"], self._transaction["script"]) return (self._transaction["id"], self._transaction[TARANT_TABLE_SCRIPT])
except KeyError: except KeyError:
return None return None
def convert_to_tuple(self): def convert_to_tuple(self):
self._metadata_check() self._metadata_check()
self.__asset_check() self.__asset_check()
self._tuple_transaction["transactions"] = self.__prepare_transaction() self._tuple_transaction[TARANT_TABLE_TRANSACTION] = self.__prepare_transaction()
self._tuple_transaction["inputs"] = self.__prepare_inputs() self._tuple_transaction[TARANT_TABLE_INPUT] = self.__prepare_inputs()
keys, outputs = self.__prepare_outputs() keys, outputs = self.__prepare_outputs()
self._tuple_transaction["outputs"] = outputs self._tuple_transaction[TARANT_TABLE_OUTPUT] = outputs
self._tuple_transaction["keys"] = keys self._tuple_transaction[TARANT_TABLE_KEYS] = keys
self._tuple_transaction["script"] = self.__prepare_script() self._tuple_transaction[TARANT_TABLE_SCRIPT] = self.__prepare_script()
return self._tuple_transaction return self._tuple_transaction
class TransactionCompose: class TransactionCompose:
def __init__(self, db_results): def __init__(self, db_results):
self.db_results = db_results self.db_results = db_results
self._map = self.db_results["transaction"][3] self._map = self.db_results[TARANT_TABLE_TRANSACTION][3]
def _get_transaction_operation(self): def _get_transaction_operation(self):
return self.db_results["transaction"][1] return self.db_results[TARANT_TABLE_TRANSACTION][1]
def _get_transaction_version(self): def _get_transaction_version(self):
return self.db_results["transaction"][2] return self.db_results[TARANT_TABLE_TRANSACTION][2]
def _get_transaction_id(self): def _get_transaction_id(self):
return self.db_results["transaction"][0] return self.db_results[TARANT_TABLE_TRANSACTION][0]
def _get_asset(self): def _get_asset(self):
_asset = iter(self.db_results["assets"]) _asset = iter(self.db_results[TARANT_TABLE_ASSETS])
_res_asset = next(iter(next(_asset, iter([]))), None) _res_asset = next(iter(next(_asset, iter([]))), None)
return json.loads(_res_asset) return json.loads(_res_asset)
def _get_metadata(self): def _get_metadata(self):
return json.loads(self.db_results["metadata"][0][1]) if len(self.db_results["metadata"]) == 1 else None return json.loads(self.db_results[TARANT_TABLE_META_DATA][0][1]) if len(self.db_results[TARANT_TABLE_META_DATA]) == 1 else None
def _get_inputs(self): def _get_inputs(self):
_inputs = [] _inputs = []
for _input in self.db_results["inputs"]: for _input in self.db_results[TARANT_TABLE_INPUT]:
_in = copy.deepcopy(self._map["inputs"][_input[-1]]) _in = copy.deepcopy(self._map[TARANT_TABLE_INPUT][_input[-1]])
_in["fulfillment"] = _input[1] _in["fulfillment"] = _input[1]
if _in["fulfills"] is not None: if _in["fulfills"] is not None:
_in["fulfills"]["transaction_id"] = _input[3] _in["fulfills"]["transaction_id"] = _input[3]
@ -188,10 +189,10 @@ class TransactionCompose:
def _get_outputs(self): def _get_outputs(self):
_outputs = [] _outputs = []
for _output in self.db_results["outputs"]: for _output in self.db_results[TARANT_TABLE_OUTPUT]:
_out = copy.deepcopy(self._map["outputs"][_output[-1]]) _out = copy.deepcopy(self._map[TARANT_TABLE_OUTPUT][_output[-1]])
_out["amount"] = _output[1] _out["amount"] = _output[1]
_tmp_keys = [(_key[3], _key[4]) for _key in self.db_results["keys"] if _key[2] == _output[5]] _tmp_keys = [(_key[3], _key[4]) for _key in self.db_results[TARANT_TABLE_KEYS] if _key[2] == _output[5]]
_sorted_keys = sorted(_tmp_keys, key=lambda tup: (tup[1])) _sorted_keys = sorted(_tmp_keys, key=lambda tup: (tup[1]))
_out["public_keys"] = [_key[0] for _key in _sorted_keys] _out["public_keys"] = [_key[0] for _key in _sorted_keys]
@ -207,20 +208,20 @@ class TransactionCompose:
return _outputs return _outputs
def _get_script(self): def _get_script(self):
if self.db_results["script"]: if self.db_results[TARANT_TABLE_SCRIPT]:
return self.db_results["script"][0][1] return self.db_results[TARANT_TABLE_SCRIPT][0][1]
else: else:
return None return None
def convert_to_dict(self): def convert_to_dict(self):
transaction = {k: None for k in list(self._map.keys())} transaction = {k: None for k in list(self._map.keys())}
transaction["id"] = self._get_transaction_id() transaction["id"] = self._get_transaction_id()
transaction["assets"] = self._get_asset() transaction[TARANT_TABLE_ASSETS] = self._get_asset()
transaction["metadata"] = self._get_metadata() transaction[TARANT_TABLE_META_DATA] = self._get_metadata()
transaction["version"] = self._get_transaction_version() transaction["version"] = self._get_transaction_version()
transaction["operation"] = self._get_transaction_operation() transaction["operation"] = self._get_transaction_operation()
transaction["inputs"] = self._get_inputs() transaction[TARANT_TABLE_INPUT] = self._get_inputs()
transaction["outputs"] = self._get_outputs() transaction[TARANT_TABLE_OUTPUT] = self._get_outputs()
if self._get_script(): if self._get_script():
transaction["script"] = self._get_script() transaction[TARANT_TABLE_SCRIPT] = self._get_script()
return transaction return transaction