refactor validation
[tiramisu.git] / tiramisu / storage / __init__.py
index e9a1b1a..e62bf19 100644 (file)
@@ -1,4 +1,4 @@
-# Copyright (C) 2013 Team tiramisu (see AUTHORS for all contributors)
+# Copyright (C) 2013-2014 Team tiramisu (see AUTHORS for all contributors)
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU Lesser General Public License as published by the
@@ -27,6 +27,8 @@ configurator ``set_storage()``.
 
 
 from time import time
+from random import randint
+import os
 from tiramisu.error import ConfigError
 from tiramisu.i18n import _
 
@@ -36,11 +38,11 @@ class StorageType(object):
     default storage is store as selected storage. You cannot change it
     after.
     """
-    default_storage = 'dictionary'
+    default_storage = os.environ.get('TIRAMISU_STORAGE', 'dictionary')
     storage_type = None
     mod = None
 
-    def set(self, name):
+    def set(self, name):  # pragma: optional cover
         if self.storage_type is not None:
             if self.storage_type == name:
                 return
@@ -50,10 +52,13 @@ class StorageType(object):
     def get(self):
         if self.storage_type is None:
             self.storage_type = self.default_storage
-        storage = self.storage_type
         if self.mod is None:
-            modulepath = 'tiramisu.storage.{0}'.format(storage)
-            mod = __import__(modulepath)
+            modulepath = 'tiramisu.storage.{0}'.format(self.storage_type)
+            try:
+                mod = __import__(modulepath)
+            except ImportError:
+                raise SystemError(_('cannot import the storage {0}').format(
+                    self.default_storage))
             for token in modulepath.split(".")[1:]:
                 mod = getattr(mod, token)
             self.mod = mod
@@ -61,9 +66,12 @@ class StorageType(object):
 
 
 storage_type = StorageType()
+storage_option_type = StorageType()
+storage_validation = StorageType()
+storage_validation.set('dictionary')
 
 
-def set_storage(name, **kwargs):
+def set_storage(type_, name, **kwargs):  # pragma: optional cover
     """Change storage's configuration
 
     :params name: is the storage name. If storage is already set, cannot
@@ -71,8 +79,12 @@ def set_storage(name, **kwargs):
 
     Other attributes are differents according to the selected storage's name
     """
-    storage_type.set(name)
-    setting = storage_type.get().setting
+    if type_ == 'option':
+        storage_option_type.set(name)
+        setting = storage_option_type.get().setting
+    else:
+        storage_type.set(name)
+        setting = storage_type.get().setting
     for option, value in kwargs.items():
         try:
             getattr(setting, option)
@@ -91,35 +103,63 @@ def _impl_getstate_setting():
     return state
 
 
-def get_storage(session_id, persistent, test):
+def get_storage(type_, session_id, persistent, test):  # pragma: optional cover
     """all used when __setstate__ a Config
     """
-    return storage_type.get().Storage(session_id, persistent, test)
+    if type_ == 'option':
+        return storage_option_type.get().Storage(session_id, persistent, test)
+    elif type_ == 'config':
+        return storage_type.get().Storage(session_id, persistent, test)
+    else:
+        return storage_validation.get().Storage(session_id, persistent, test)
 
 
 def get_storages(context, session_id, persistent):
     def gen_id(config):
-        return str(id(config)) + str(time())
+        return str(id(config)) + str(time()) + str(randint(0, 500))
 
     if session_id is None:
         session_id = gen_id(context)
     imp = storage_type.get()
     storage = imp.Storage(session_id, persistent)
+    try:
+        return imp.Settings(storage), imp.Values(storage)
+    except Exception, err:
+        raise Exception(_('unable to get storages:') + str(err))
+
+
+def get_storages_option(type_):
+    imp = storage_option_type.get()
+    if type_ == 'base':
+        return imp.StorageBase
+    else:
+        return imp.StorageOptionDescription
+
+
+def get_storages_validation():
+    imp = storage_validation.get()
+    storage = imp.Storage('pouet', persistent=False, test=True)
     return imp.Settings(storage), imp.Values(storage)
 
 
-def list_sessions():
+def list_sessions(type_):  # pragma: optional cover
     """List all available session (persistent or not persistent)
     """
-    return storage_type.get().list_sessions()
+    if type_ == 'option':
+        return storage_option_type.get().list_sessions()
+    else:
+        return storage_type.get().list_sessions()
 
 
-def delete_session(session_id):
+def delete_session(type_, session_id):  # pragma: optional cover
     """Delete a selected session, be careful, you can deleted a session
     use by an other instance
     :params session_id: id of session to delete
     """
-    return storage_type.get().delete_session(session_id)
+    if type_ == 'option':
+        return storage_option_type.get().delete_session(session_id)
+    else:
+        return storage_type.get().delete_session(session_id)
 
 
 __all__ = (set_storage, list_sessions, delete_session)