fixed connection instantiation

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

planetmint/backend/connection_tarantool.py

@@ -1,176 +0,0 @@
-# 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
-
-import logging
-from importlib import import_module
-from itertools import repeat
-
-import tarantool
-import planetmint
-import os
-
-from planetmint.backend.exceptions import ConnectionError
-from planetmint.backend.utils import get_planetmint_config_value, get_planetmint_config_value_or_key_error
-from planetmint.transactions.common.exceptions import ConfigurationError
-
-BACKENDS = {  # This is path to MongoDBClass
-    'tarantool': 'planetmint.backend.connection_tarantool.TarantoolDB',
-}
-
-logger = logging.getLogger(__name__)
-
-
-class TarantoolDB:
-    init_config = {
-        "init_file": "init_db.txt",
-        "relative_path": os.path.dirname(os.path.abspath(__file__)) + "/backend/tarantool/"
-    }
-
-    drop_config = {
-        "drop_file": "drop_db.txt",  # planetmint/backend/tarantool/init_db.txt
-        "relative_path": os.path.dirname(os.path.abspath(__file__)) + "/backend/tarantool/"
-    }
-    
-    def __init__(self, host: str, port: int, user: str, password: str, reset_database: bool = False):
-        self.db_connect = tarantool.connect(host=host, port=port, user=user, password=password)
-        if reset_database:
-            self.drop_database()
-            self.init_database()
-
-    def get_connection(self, space_name: str = None):
-        return self.db_connect if space_name is None else self.db_connect.space(space_name)
-
-    def __read_commands(self, file_path):
-        with open(file_path, "r") as cmd_file:
-            commands = [line.strip() for line in cmd_file.readlines() if len(str(line)) > 1]
-            cmd_file.close()
-        return commands
-
-    def drop_database(self):
-        from planetmint.backend.tarantool.utils import run
-#        config = get_planetmint_config_value_or_key_error("ctl_config")
-#        drop_config = config["drop_config"]
-        f_path = "%s%s" % (self.drop_config["relative_path"], self.drop_config["drop_file"])
-        commands = self.__read_commands(file_path=f_path)
-        run(commands=commands, config=config)
-
-    def init_database(self):
-        from planetmint.backend.tarantool.utils import run
- #       config = get_planetmint_config_value_or_key_error("ctl_config")
- #       init_config = config["init_config"]
-        f_path = "%s%s" % (self.init_config["relative_path"], self.init_config["init_file"])
-        commands = self.__read_commands(file_path=f_path)
-        run(commands=commands, config=config)
-
-
-
-def connect(host: str = None, port: int = None, username: str = None, password: str = None,
-            backend: str = None, reset_database: bool = False, name=None, max_tries=None,
-            connection_timeout=None, replicaset=None, ssl=None, login: str = None, ctl_config=None,
-            ca_cert=None, certfile=None, keyfile=None, keyfile_passphrase=None, reconnect_delay=None,
-            crlfile=None, connect_now=True, encoding=None):
-    backend = backend or get_planetmint_config_value_or_key_error('backend')  # TODO Rewrite Configs
-    host = host or get_planetmint_config_value_or_key_error('host')
-    port = port or get_planetmint_config_value_or_key_error('port')
-    username = username or login or get_planetmint_config_value('login')
-    password = password or get_planetmint_config_value('password')
-
-    try:  # Here we get class using getattr function
-        module_name, _, class_name = BACKENDS[backend].rpartition('.')
-        Class = getattr(import_module(module_name), class_name)
-    except KeyError:
-        raise ConfigurationError('Backend `{}` is not supported. '
-                                 'Planetmint currently supports {}'.format(backend, BACKENDS.keys()))
-    except (ImportError, AttributeError) as exc:
-        raise ConfigurationError('Error loading backend `{}`'.format(backend)) from exc
-    print(host)
-    print(port)
-    print(username)
-    
-    logger.debug('Connection: {}'.format(Class))
-    return Class(host=host, port=port, user=username, password=password, reset_database=reset_database)
-
-
-class Connection:
-    """Connection class interface.
-
-    All backend implementations should provide a connection class that inherits
-    from and implements this class.
-    """
-
-    def __init__(self, host=None, port=None, connection_timeout=None, max_tries=None,
-                 **kwargs):
-        """Create a new :class:`~.Connection` instance.
-
-        Args:
-            host (str): the host to connect to.
-            port (int): the port to connect to.
-            dbname (str): the name of the database to use.
-            connection_timeout (int, optional): the milliseconds to wait
-                until timing out the database connection attempt.
-                Defaults to 5000ms.
-            max_tries (int, optional): how many tries before giving up,
-                if 0 then try forever. Defaults to 3.
-            **kwargs: arbitrary keyword arguments provided by the
-                configuration's ``database`` settings
-        """
-
-        dbconf = planetmint.config['database']
-
-        self.host = host or dbconf['host']
-        self.port = port or dbconf['port']
-        self.connection_timeout = connection_timeout if connection_timeout is not None \
-            else dbconf['connection_timeout']
-        self.max_tries = max_tries if max_tries is not None else dbconf['max_tries']
-        self.max_tries_counter = range(self.max_tries) if self.max_tries != 0 else repeat(0)
-        self._conn = None
-
-    @property
-    def conn(self):
-        pass
-        if self._conn is None:
-            self.connect()
-        return self._conn
-
-    def run(self, query):
-        pass
-        """Run a query.
-
-        Args:
-            query: the query to run
-        Raises:
-            :exc:`~DuplicateKeyError`: If the query fails because of a
-                duplicate key constraint.
-            :exc:`~OperationFailure`: If the query fails for any other
-                reason.
-            :exc:`~ConnectionError`: If the connection to the database
-                fails.
-        """
-
-        raise NotImplementedError()
-
-    def connect(self):
-        pass
-        """Try to connect to the database.
-
-        Raises:
-            :exc:`~ConnectionError`: If the connection to the database
-                fails.
-        """
-
-        attempt = 0
-        for i in self.max_tries_counter:
-            attempt += 1
-            try:
-                self._conn = self._connect()
-            except ConnectionError as exc:
-                logger.warning('Attempt %s/%s. Connection to %s:%s failed after %sms.',
-                               attempt, self.max_tries if self.max_tries != 0 else '∞',
-                               self.host, self.port, self.connection_timeout)
-                if attempt == self.max_tries:
-                    logger.critical('Cannot connect to the Database. Giving up.')
-                    raise ConnectionError() from exc
-            else:
-                break

planetmint/lib.py

@@ -73,9 +73,7 @@ class Planetmint(object):
             self.validation = config_utils.load_validation_plugin(validationPlugin)
         else:
             self.validation = BaseValidationRules
-        # planetmint.backend.tarantool.connection_tarantool.connect(**Config().get()['database'])
+        self.connection = connection if connection is not None else planetmint.backend.connect()
-        self.connection = connection if connection is not None else planetmint.backend.Connection()
-        print(f"PLANETMINT self.connection {self.connection} !!!!")
 
     def post_transaction(self, transaction, mode):
         """Submit a valid transaction to the mempool."""