1 files changed, 179 insertions, 266 deletions

diff --git a/dodai/config/databases/__init__.py b/dodai/config/databases/__init__.py
index da317e8..ba6b9a9 100644
--- a/dodai/config/databases/__init__.py
+++ b/dodai/config/databases/__init__.py
@@ -16,56 +16,35 @@
 # along with Dodai.  If not, see <http://www.gnu.org/licenses/>.
 
 
+from dodai.exception import DatabaseEmptyOptionException
+from dodai.exception import DatabasePortException
+from dodai.exception import DatabaseHostnameException
+from dodai.exception import DatabaseProtocolException
+from dodai.exception import DatabaseConnectionException
+from dodai.exception import UnknownDatabaseConnectionException
+from dodai.tools import list_to_english
+
 class ConfigDatabases(object):
     """An object that is used for creating database connection objects
 
     """
-    def __init__(self):
-        self.sections = {}
+    def __init__(self, default_handler, default_name):
+        self.connections = {}
         self._handlers = {}
+        DatabaseConnection.DEFAULT_HANDLER = default_name
+        self.add_handler(default_name, default_handler)
 
     def add(self, sections):
-        """Adds a dictionary of section (objects) to this object that could
-        be used for creating database connection objects
-
-        """
-        self._build_default_handler()
-        for name, section in sections.items():
-            self.sections[name] = DatabaseConnectionValidator(
-                    name, section, self._handlers)
+        """Adds a dictionary of sections to this object that could
+        be used for creating database connection objects.  The dictionary
+        should be formatted as follows:
 
-    def load(self, section_name):
-        """Returns a database connection object of the given section_name.
-        Throws Exceptions for any type of configuration errors or missing
-        configuration data
+            sections[name] = {option: value, option: value, ....}
 
-        """
-        if section_name in self.sections:
-            return self.sections[section_name].load()
-        else:
-            raise UnknownDatabaseConnectionException(section_name)
+        The 'name' is the section name.  It is an identifier that is used
+        to load the database:
 
-    def _build_default_handler(self):
-        # Creates the default sqlalchemy handler
-        if 'sa' not in self._handlers:
-            from dodai.config.databases.sa import Sa
-            from sqlalchemy.orm import sessionmaker
-            from sqlalchemy import create_engine
-            from dodai.db import Db
-            sa = Sa(create_engine, sessionmaker, Db)
-            self._handlers['sa'] = sa
-
-    def add_handler(self, name, handler):
-        """Adds the given handler and name to this objects handlers
-
-        """
-        self._handlers[name] = obj
-
-
-class DatabaseConnectionValidator(object):
-    """Database validation object that is used to validate a section
-    object which is basically a python object that can have the following
-    properties:
+        The options and values can have the following:
 
               protocol: The database engine (postgresql, mysql, sqlite,
                         oracle, mssql etc..)
@@ -97,276 +76,210 @@ class DatabaseConnectionValidator(object):
                handler: The handler used to build the orm object. Dodai
                         only works with sqlalchemy so the default 'sa'
                         is used.
-    Not all of the above options are required.
 
-    """
-    OPTIONS_REQUIRED = {
-    'server':['protocol', 'hostname', 'port', 'username', 'password',
-              'database'],
-    'file'  :['protocol', 'filename']
-    }
-    OPTIONS_EXTRA = ['protocol_extra', 'handler', 'schema']
-    SERVER_PROTOCOLS = ['postgresql', 'mysql', 'sqlite', 'mssql', 'oracle']
-    FILE_PROTOCOLS = ['sqlite']
-    DEFAULT_HANDLER = 'sa'
-
-    def __init__(self, name, section, handlers):
+        """
+        for name, section in sections.items():
+            self.connections[name] = DatabaseConnection(section, name,
+                                                        self._handlers)
+
+    def load(self, section_name):
+        """Returns a database connection object of the given section_name.
+        Throws Exceptions for any type of configuration errors or missing
+        configuration data
+
+        """
+        if section_name in self.connections:
+            return self.connections[section_name].load()
+        else:
+            raise UnknownDatabaseConnectionException(section_name)
+
+    def add_handler(self, name, handler):
+        """Adds the given handler and name to this objects handlers
+
+        """
+        self._handlers[name] = handler
+
+class DatabaseConnection(object):
+
+    DEFAULT_HANDLER = None
+
+    def __init__(self, section, name, handlers):
         self.section = section
         self.name = name
-        self.database_type = self._database_type()
-        self._handlers = handlers
+        self.handlers = handlers
+        self.validate = DatabaseConnectionValidator.load(section, name)
         self.obj = None
 
     def load(self):
         if not self.obj:
-            self._validate()
+            self.validate()
             handler = self._get_handler()
             self.obj = handler(self.name, self.section)
         return self.obj
 
     def _get_handler(self):
-        if hasattr(self.section, 'handler'):
-            name = self.section.handler.lower()
-            if handler in self._handlers.keys():
-                return self._handlers[name]
-        return self._handlers[self.DEFAULT_HANDLER]
-
-    def _validate(self):
-        if self.database_type == 'server':
-            self._validate_protocol()
-            self._validate_port()
-            self._validate_option('username')
-            self._validate_option('password')
-            self._validate_option('database')
-        elif self.database_type == 'file':
-            self._validate_protocol()
-            self._validate_option('filename')
-        else:
-            raise DatabaseConnectionException(self.name, self.OPTIONS_REQUIRED)
+        if self.section.has_key('handler'):
+            name = self.section['handler']
+            if name in self.handlers:
+                return self.handlers[name]
+        return self.handlers[self.DEFAULT_HANDLER]
+
+
+class DatabaseConnectionValidator(object):
+
+    def __init__(self, section, name, validators=[]):
+        self.section = section
+        self.name = name
+        self.validators = validators
+
+    def __call__(self):
+        return self.validate()
+
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
+
+        """
+        raise NotImplementedError()
 
     def _validate_option(self, name):
-        if not self.section[name]:
+        try:
+            value = self.section[name]
+        except KeyError:
+            value = None
+
+        if not value:
             raise DatabaseEmptyOptionException(self.name, name)
         return True
 
-    def _validate_hostname(self):
-        if not self.section.hostname:
-            raise DatabaseHostnameException(self.name, self.section.hostname)
-        return True
+    def _validate_protocol(self):
 
-    def _validate_port(self):
-        try:
-            port = int(self.section.port)
-        except ValueError:
-            pass
-        else:
-            if port >=1 and port <=65535:
-                return True
-        raise DatabasePortException(self.name, self.section.port)
+        self._validate_option('protocol')
 
-    def _validate_protocol(self):
-        if self.database_type == 'server':
-            if self.section.protocol not in self.SERVER_PROTOCOLS:
-                raise DatabaseProtocolException(self.name,
-                        self.section.protocol, self.database_type,
-                        self.SERVER_PROTOCOLS)
-            else:
-                return True
-        elif self.database_type == 'file':
-            if self.section.protocol not in self.FILE_PROTOCOLS:
-                raise DatabaseProtocolException(self.name,
-                        self.section.protocol, self.database_type,
-                        self.FILE_PROTOCOLS)
-            else:
-                return True
-        else:
-            return False
+        if self.section['protocol'] not in self.PROTOCOLS:
+            raise DatabaseProtocolException(self.name,
+                        self.section['protocol'], self.DB_TYPE,
+                        self.PROTOCOLS)
+        return True
 
-    def _database_type(self):
-        keys = self.section.___options___.keys()
-        for type_, pool in self.OPTIONS_REQUIRED.items():
-            out = True
-            for key in keys:
-                if key not in pool:
-                    out = False
-            if out:
-                return type_
-        return False
+    @staticmethod
+    def load(section, name):
+        """Static method (factory) that loads the correct database
+        validation class.
 
+        Attributes:
+            section:    Dictionary of key val connection information
+            name:       String name of the section
 
-class DatabaseEmptyOptionException(Exception):
-    """Exception raised for an emption option in the config
+        """
+        action = None
+        validators = [DatabaseConnectionValidatorServer,
+                      DatabaseConnectionValidatorFile]
 
-    Attributes:
-        section_name:       The section of the config file that contains
-                            the invalid protocol
-        option_name:        The name of the empty option
+        for validator in validators:
+            obj = validator.load(section, name)
+            if obj:
+                return obj
 
-    """
-    MESSAGE = "In the '{section_name}' section, the '{option_name}' "\
-              "was not set.  Please set this option."
+        return DatabaseConnectionValidatorUnknown(section, name, validators)
 
-    def __init__(self, section_name, option_name):
-        self.section_name = section_name
-        self.option_name = option_name
-        self.msg = self._build_message()
+class DatabaseConnectionValidatorServer(DatabaseConnectionValidator):
 
-    def _build_message(self):
-        return self.MESSAGE.format(section_name=self.section_name,
-                                   option_name=self.option_name)
+    DB_TYPE = 'server'
+    REQUIRED = ['protocol', 'hostname', 'port', 'username', 'password',
+                'database']
+    PROTOCOLS = ['postgresql', 'mysql', 'mssql', 'oracle']
 
+    def _validate_port(self):
+        self._validate_option('port')
 
-class DatabasePortException(Exception):
-    """Exception raised for invalid database port connection
+        try:
+            port = int(self.section['port'])
+        except ValueError:
+            port = self.section['port']
+        else:
+            if port >=1 and port <=65535:
+                return True
+        raise DatabasePortException(self.name, port)
 
-    Attributes:
-        section_name:       The section of the config file that contains
-                            the invalid protocol
-        section_port:       The port value that was listed in the
-                            config file
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
 
-    """
-    MESSAGE = "In the '{section_name}' section, the port of "\
-              "'{section_port}' is invalid.  The port must be a "\
-              "number between 1 and 65535"
+        """
+        self._validate_protocol()
+        self._validate_port()
+        self._validate_option('hostname')
+        self._validate_option('username')
+        self._validate_option('password')
+        self._validate_option('database')
+        return True
 
-    def __init__(self, section_name, section_port):
-        self.section_name = section_name
-        self.section_port = section_port
-        self.msg = self._build_message()
+    @classmethod
+    def load(cls, section, name):
+        """Return this validation class if it is possible that the
+        given connection information contains enough data to make
+        a database server connection.
 
-    def _build_message(self):
-        return self.MESSAGE.format(section_name=self.section_name,
-                                   section_port=self.section_port)
+        Attributes:
+            section:    Dictionary of key val connection information
+            name:       String name of the section
 
+        """
+        if section.has_key('protocol'):
+            if section['protocol'] in cls.PROTOCOLS:
+                return cls(section, name)
+        keys = section.keys()
+        for key in keys:
+            if key in ['hostname', 'port']:
+                return cls(section, name)
 
-class DatabaseHostnameException(Exception):
-    """Exception raised for invalid database hostname
 
-    Attributes:
-        section_name:       The section of the config file that contains
-                            the invalid protocol
-        section_hostname:   The hostname value that was listed in the
-                            config file
+class DatabaseConnectionValidatorFile(DatabaseConnectionValidator):
 
-    """
-    MESSAGE = "In the '{section_name}' section, the hostname of "\
-              "'{section_hostname}' is invalid.  Please use a valid "\
-              "hostname."
-
-    MSG_NON = "In the '{section_name}' section, the hostname was "\
-              "not set.  Please set the hostname."
-
-    def __init__(self, section_name, section_hostname):
-        self.section_name = section_name
-        self.section_hostname = section_hostname
-        self.msg = self._build_message()
-
-    def _build_message(self):
-        if self.section_hostname:
-            return self.MESSAGE.format(section_name=self.section_name,
-                                       section_hostname=self.section_hostname)
-        else:
-            return self.MSG_NON.format(section_name=self.section_name)
+    DB_TYPE = 'file'
+    REQUIRED = ['protocol', 'filename']
+    PROTOCOLS = ['sqlite']
 
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
 
-class DatabaseProtocolException(Exception):
-    """Exception raised for invalid database connection protocols
+        """
+        self._validate_protocol()
+        self._validate_option('filename')
+        return True
 
-    Attributes:
-        section_name:       The section of the config file that contains
-                            the invalid protocol
-        section_protocol:   The protocol value that was listed in the
-                            config file
-        database_type:      Usually 'server' or 'file'
-        protocols:          List of valid protocols
+    @classmethod
+    def load(cls, section, name):
+        """Return this validation class if it is possible that the
+        given connection information contains enough data to make
+        a database file connection.
 
-    """
-    MESSAGE = "In the '{section_name}' section, the protocol of "\
-              "'{section_protocol}' is invalid.  The valid protocols "\
-              "for a '{database_type}' connection are: {protocols}"
-
-    def __init__(self, section_name, section_protocol, database_type,
-                 protocols):
-        self.section_name = section_name
-        self.section_protocol = section_protocol
-        self.database_type = database_type
-        self.protocols = protocols
-        self.msg = self._build_message()
-
-    def _build_message(self):
-        protocols = ', '.join(self.protocols)
-        return self.MESSAGE.format(section_name=self.section_name,
-                                   section_protocol=self.section_protocol,
-                                   database_type=self.database_type,
-                                   protocols=protocols)
-
-
-class DatabaseConnectionException(Exception):
-    """Exception raised for missing database connection parameters
-
-    Attributes:
-        section_name:       The section of the config file that contains
-                            the invalid connection information
-        options_required:   A dictionary containing the database_type
-                            as the key and a list of required options
-                            as the value
+        Attributes:
+            section:    Dictionary of key val connection information
+            name:       String name of the section
 
-    """
-    MESSAGE =  "The '{section_name}' section does not contain all of the "\
-               "correct information needed to make a database connection."
-    MSG_TYPE = "To make a '{database_type}' connection please make sure "\
-               "To have all of the following options: {options}."
-    MSG_END =  "Please remember that the option names are case sensitive."
-
-    def __init__(self, section_name, options_required):
-        self.section_name = section_name
-        self.options_required = options_required
-        self.msg = self._build_message()
-
-    def _build_message(self):
-        out = []
-        out.append(self.MESSAGE.format(section_name=self.section_name))
-        for database_type, options in self.options_required.items():
-            options = list_to_english(options)
-            out.append(self.MSG_TYPE.format(database_type=database_type,
-                                            options=options))
-        out.append(self.MSG_END)
-        return '  '.join(out)
-
-
-class UnknownDatabaseConnectionException(Exception):
-    """Exception raised for missing database connection parameters
-
-    Attributes:
-        section:  The requested section of the config file that can not
-                  be found.
+        """
+        if section.has_key('protocol'):
+            if section['protocol'] in cls.PROTOCOLS:
+                return cls(section, name)
+        keys = section.keys()
+        for key in keys:
+            if key in ['filename']:
+                return cls(section, name)
 
-    """
-    MESSAGE = "Unable to find the '{section}' section to create a "\
-              "database connection."
 
-    def __init__(self, section):
-        self.section = section
-        self.msg = self._build_message()
+class DatabaseConnectionValidatorUnknown(DatabaseConnectionValidator):
 
-    def _build_message(self):
-        return self.MESSAGE.format(section=self.section)
+    DB_TYPE = 'unkonwn'
+    REQUIRED = []
+    PROTOCOLS = []
 
+    def validate(self):
+        """Validates the connection.  Returns true if valid.  Throws
+        DodaiDatabaseConnectionConfigurationError on any errors
 
-def list_to_english(data):
-    """Takes the input list and creates a string with each option
-    encased in single quotes and seperated by a comma with exception
-    of the last option which is prefixed with the word 'and'
+        """
 
-    """
-    if data:
-        if len(data) > 1:
-            out = []
-            last = "'{0}'".format(data.pop())
-            for row in data:
-                out.append("'{0}'".format(row))
-            out = ', '.join(out)
-            return "{0} and {1}".format(out, last)
-        else:
-            return "'{0}'".format(data.pop())
+        raise DatabaseConnectionException(self.name, self.validators)