fixed some imports, refactored TarantoolDBConnection.conn handling

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>

planetmint/backend/tarantool/connection.py

@@ -16,21 +16,14 @@ logger = logging.getLogger(__name__)
 class TarantoolDBConnection(Connection):
     def __init__(self, host: str = "localhost", port: int = 3303, user: str = None, password: str = None,  **kwargs):
         try:
+            super().__init__(**kwargs)
             self.host = host
             self.port = port
             # TODO add user support later on
             print(f"host : {host}")
             print(f"port : {port}")
-            # self.db_connect = tarantool.connect(host=host, port=port, user=user, password=password)
-            # TODO : raise configuraiton error if the connection cannot be established
-            self.db_connect = tarantool.connect(host=self.host, port=self.port)
             self.init_path = Config().get()["database"]["init_config"]["absolute_path"]
             self.drop_path = Config().get()["database"]["drop_config"]["absolute_path"]
-            # args_reset_db = kwargs.get("kwargs").get("reset_database") if "kwargs" in kwargs else None
-            # if reset_database or args_reset_db is True:
-            #     self.drop_database()
-            #     self.init_database()
-            #     self._reconnect()
             self.SPACE_NAMES = ["abci_chains", "assets", "blocks", "blocks_tx",
                                 "elections", "meta_data", "pre_commits", "validators",
                                 "transactions", "inputs", "outputs", "keys"]
@@ -47,24 +40,22 @@ class TarantoolDBConnection(Connection):
             f.close()
         return "".join(execute).encode()
 
-    def _reconnect(self):
+    def _connect(self):
-        self.db_connect = tarantool.connect(host=self.host, port=self.port)
+        return tarantool.connect(host=self.host, port=self.port)
 
     def space(self, space_name: str):
-        return self.db_connect.space(space_name)
+        return self.conn.space(space_name)
 
     def get_connection(self):
-        return self.db_connect
+        return self.conn
 
     def drop_database(self):
         db_config = Config().get()["database"]
         cmd_resp = self.run_command(command=self.drop_path, config=db_config)
-        self._reconnect()
 
     def init_database(self):
         db_config = Config().get()["database"]
         cmd_resp = self.run_command(command=self.init_path, config=db_config)
-        self._reconnect()
 
     def run_command(self, command: str, config: dict):
         from subprocess import run

planetmint/backend/tarantool/schema.py

@@ -1,10 +1,11 @@
-import warnings
+import logging
 
 import tarantool
 from planetmint.backend.utils import module_dispatch_registrar
 from planetmint import backend
 from planetmint.backend.tarantool.connection import TarantoolDBConnection
 
+logger = logging.getLogger(__name__)
 register_schema = module_dispatch_registrar(backend.schema)
 
 SPACE_NAMES = ("abci_chains", "assets", "blocks", "blocks_tx",
@@ -162,14 +163,15 @@ def drop_database(connection, not_used=None):
 
 
 @register_schema(TarantoolDBConnection)
-def create_database(connection, not_used=None):
+def create_database(connection, dbname):
     '''
 
     For tarantool implementation, this function runs
     create_tables, to initiate spaces, schema and indexes.
 
     '''
-    create_tables(None, None)
+    logger.info('Create database `%s`.', dbname)
+    create_tables(connection, dbname)
 
 
 def run_command_with_output(command):

planetmint/web/websocket_server.py

@@ -24,7 +24,7 @@ import aiohttp
 
 from uuid import uuid4
 from concurrent.futures import CancelledError
-from planetmint import config
+from planetmint.config import Config
 from planetmint.web.websocket_dispatcher import Dispatcher
 
 
@@ -146,6 +146,6 @@ def start(sync_event_source, loop=None):
 
     app = init_app(tx_source, blk_source, loop=loop)
     aiohttp.web.run_app(app,
-                        host=config['wsserver']['host'],
+                        host=Config().get()['wsserver']['host'],
-                        port=config['wsserver']['port'],
+                        port=Config().get()['wsserver']['port'],
                         loop=loop)

setup.py

@@ -94,8 +94,8 @@ install_requires = [
     'requests==2.25.1',
     'setproctitle==1.2.2',
     'werkzeug==2.0.3',
-    'nest-asyncio==1.5.5'
+    'nest-asyncio==1.5.5',
-
+    'protobuf==3.20'
 ]
 
 if sys.version_info < (3, 9):

tests/conftest.py

@@ -123,21 +123,21 @@ def _configure_planetmint(request):
 
 @pytest.fixture(scope='session')
 def _setup_database(_configure_planetmint):  # TODO Here is located setup database
-    from planetmint.backend.connection import Connection
+    from planetmint.backend.connection import connect
     from planetmint.config import Config
 
     print('Initializing test db')
     dbname = Config().get()['database']['name']
-    conn = Connection()
+    conn = connect()
 
     _drop_db(conn, dbname)
-    schema.init_database(conn)
+    schema.init_database(conn, dbname)
     print('Finishing init database')
 
     yield
 
     print('Deleting `{}` database'.format(dbname))
-    conn = Connection()
+    conn = connect()
     _drop_db(conn, dbname)
 
     print('Finished deleting `{}`'.format(dbname))
@@ -146,12 +146,12 @@ def _setup_database(_configure_planetmint):  # TODO Here is located setup databa
 @pytest.fixture
 def _bdb(_setup_database, _configure_planetmint):
     print(f"BDB CALL")
-    from planetmint.backend import Connection
+    from planetmint.backend import connect
     from planetmint.transactions.common.memoize import to_dict, from_dict
     from planetmint.models import Transaction
     from .utils import flush_db
     from planetmint.config import Config
-    conn = Connection()
+    conn = connect()
     yield
     dbname = Config().get()['database']['name']
     flush_db(conn, dbname)

tests/utils.py

@@ -10,7 +10,7 @@ import random
 from functools import singledispatch
 
 from planetmint.backend.localmongodb.connection import LocalMongoDBConnection
-from planetmint.backend.tarantool.connection import TarantoolDB
+from planetmint.backend.tarantool.connection import TarantoolDBConnection
 from planetmint.backend.schema import TABLES, SPACE_NAMES
 from planetmint.transactions.common import crypto
 from planetmint.transactions.common.transaction_mode_types import BROADCAST_TX_COMMIT
@@ -30,7 +30,7 @@ def flush_localmongo_db(connection, dbname):
         getattr(connection.conn[dbname], t).delete_many({})
 
 
-@flush_db.register(TarantoolDB)
+@flush_db.register(TarantoolDBConnection)
 def flush_tarantool_db(connection, dbname):
     for s in SPACE_NAMES:
         _space = connection.space(space_name=s)