Connection between WebUi Client & Session started

lodel/auth/client.py

@@ -1,14 +1,123 @@
 #-*- Coding: utf-8 -*-
 
 import copy
+import sys
+import warnings
 
 from lodel.settings import Settings
 from lodel import logger
 from lodel.plugin.hooks import LodelHook
 from lodel.plugin import SessionHandlerPlugin as SessionHandler
 
+##@brief Class designed to handle sessions and its datas
+class LodelSession(object):
+    
+    ##@brief Try to restore or to create a session
+    #@param token None | mixed : If None no session will be loaded nor created
+    #restore an existing session
+    #@throw  ClientAuthenticationFailure if a session restore fails
+    def __init__(self, token = None):
+        ##@brief Stores the session token
+        self.__token = token
+        ##@brief Stores the session datas
+        self.__datas = dict()
+        if token is not None:
+            self.restore(token)
+    
+    ##@brief A token reference checker to ensure token deletion at the end of
+    #a session
+    #@warning Cause maybe a performance issue !
+    def __token_checker(self):
+        refcount = sys.getrefcount(self.__token)
+        if refcount > 1:
+            warnings.warn("More than one reference to the session token \
+exists !")
+
+    ##@brief Property. Equals True if a session is started else False
+    @property
+    def started(self):
+        res = self.__token is None
+        if res:
+            self.__token_checker()
+        return res
+    
+    ##@brief Property that ensure ro acces to sessions datas
+    @property
+    def datas(self):
+        return copy.copy(self.__datas)
+    
+    ##@brief Return the session token
+    def retrieve_token(self):
+        # DO NOT COPY THE TOKEN TO ENSURE THAT NOT MORE THAN ONE REFERENCE TO
+        # IT EXISTS
+        return self.__token
+
+    ##@brief Late restore of a session
+    #@param token mixed : the session token
+    #@throw ClientAuthenticationError if a session was allready started
+    #@throw ClientAuthenticationFailure if no session exists with this token
+    def restore(self, token):
+        if self.started:
+            raise ClientAuthenticationError("Trying to restore a session, but \
+a session is allready started !!!")
+        self.__datas = SessionHandler.restore(token)
+        return self.datas
+
+    ##@brief Save the current session state
+    def save(self):
+        if not self.started:
+            raise ClientAuthenticationError(
+                "Trying to save a non started session")
+        SessionHandler.save(self.__token)
+    
+    ##@brief Destroy a session
+    def destroy(self):
+        if not self.started:
+            logger.debug("Destroying a session that is not started")
+        SessionHandler.destroy(self.__token)
+        self.__token = None
+        self.__datas = dict()
+    
+    ##@brief Destructor
+    def __del__(self):
+        del(self.__token)
+        del(self.__datas)
+
+    ##@brief Implements setter for dict access to instance
+    #@todo Custom exception throwing
+    def __setitem__(self, key, value):
+        self.__init_session() #Start the sesssion
+        self.__datas[key] = value
+    
+    ##@brief Implements destructor for dict access to instance
+    #@todo Custom exception throwing
+    def __delitem__(self, key):
+        if not self.started:
+            raise ClientAuthenticationError(
+                "Data read access to a non started session is not possible")
+        del(self.__datas[key])
+    
+    ##@brief Implements getter for dict acces to instance
+    #@todo Custom exception throwing
+    def __getitem__(self, key):
+        if not self.started:
+            raise ClientAuthenticationError(
+                "Data read access to a non started session is not possible")
+        return self.__datas[key]
+
+    ##@brief Start a new session
+    #@note start a new session only if no session started yet
+    def __init_session(self):
+        if self.__token is not None:
+            return
+        self.__token = SessionHandler.start()
+            
+        
+
 ##@brief Client metaclass designed to implements container accessor on 
 #Client Class
+#
+#@todo Maybe we can delete this metaclass....
 class ClientMetaclass(type):
     
     SESSION_ID_NAME = '__SESSION_ID__'
@@ -27,11 +136,14 @@ class ClientMetaclass(type):
             self.__session[SESSION_ID_NAME] = SessionHandler.start_session()
         self.__session[key] = value
     
+    def __token(self):
+        return None if SESSION_ID_NAME not in self.__sessions else self.__session[SESSION_ID_NAME]
+
     ##@brief Return a copy of sessions infos
     def session_dump(self): 
+        #first set all sessions values
+        SessionHandler.save_session(self.__session)
         return copy.copy(self.__session)
-        
-            
 
 
 ##@brief Abstract singleton class designed to handle client informations
@@ -55,6 +167,10 @@ class Client(object, metaclass = ClientMetaclass):
     #- password typle contains (LeObjectChild, FieldName)
     _infos_fields = None
     
+    ##@brief Constant that stores the session key that stores authentication
+    #informations
+    _AUTH_DATANAME = '__auth_user_infos'
+    
 
     ##@brief Constructor
     #@param ui_instance Lodel2Ui child class instance
@@ -79,6 +195,8 @@ class Client(object, metaclass = ClientMetaclass):
         self.__user = None
         ##@brief Stores the session handler
         Client._instance = self
+        ##@brief Stores LodelSession instance
+        self.__session = LodelSession(token)
         logger.debug("New client : %s" % self)
     
     ##@brief Attempt to restore a session given a session token
@@ -87,11 +205,13 @@ class Client(object, metaclass = ClientMetaclass):
     #@throw ClientAuthenticationFailure if token is not valid or not
     #existing
     def _restore_session(self, token):
-        res = self._session_handler.restore_session(token)
-        if res is False:
-            raise ClientAuthenticationFailure(client = self,
-                msg = "Invalid or not existing session token provided")
-        pass
+        return self.__session.restore(token)
+    
+    ##@brief Return the current session token or None
+    #@return A session token or None
+    @classmethod
+    def session_token(cls):
+        return self.__session.retrieve_token()
 
     ##@brief Try to authenticate a user with a login and a password
     #@param login str : provided login
@@ -216,5 +336,7 @@ login EmClass '%s' and password EmClass '%s'. Abording..." % (
     #@return None
     def __set_authenticated(self, leo, uid):
         self.__user = {'classname': leo.__name__, 'uid': uid, 'leoclass': leo}
+        #Store auth infos in session
+        self.__session[self.__class__._AUTH_DATANAME] = copy.copy(self.__user)
         
     

lodel/auth/session.py

@@ -1,142 +0,0 @@
-# -*- coding; utf-8 -*-
-
-from abc import ABC, abstractmethod
-from uuid import uuid1
-
-from werkzeug.contrib.sessions import generate_key, Session
-
-#from lodel.auth.exceptions import AuthenticationError
-from lodel.utils.datetime import get_utc_timestamp
-
-
-class LodelSession(ABC):
-    expiration_limit = 900
-
-    __sessions = {}
-
-    ## @brief creates a session
-    # @param contests dict : session initialization keys
-    def __init__(self, contents={}):
-
-        self.sid = self.__class__.generate_new_sid()
-
-        for key, value in contents.items():
-            self.set_key(key, value)
-
-        self.store()
-        self.register_session()
-
-    ## @brief stores the session
-    @abstractmethod
-    def store(self):
-        pass
-
-    ## @brief registers the session
-    @abstractmethod
-    def register_session(self):
-        pass
-
-    ## @brief saves a session
-    @abstractmethod
-    def save(self):
-        pass
-
-    ## @brief loads a session
-    # @param sid str : session id
-    # @return LodelSession
-    @classmethod
-    @abstractmethod
-    def load(cls, sid):
-        return None
-
-    ## @brief cleans the session store
-    @classmethod
-    @abstractmethod
-    def clean(cls):
-        pass
-
-    ## @brief destroys a session
-    # @param sid str : session id
-    @classmethod
-    def destroy(cls, sid):
-        cls.delete_session(sid)
-        cls.unregister_session(sid)
-
-    ## @brief deletes a session
-    # @param sid str : session id
-    @classmethod
-    @abstractmethod
-    def delete_session(cls, sid):
-        pass
-
-    ## @brief unregisters a session from the session store list
-    # @param sid str : session id
-    @classmethod
-    def unregister_session(cls, sid):
-        if sid in cls.__sessions:
-            del cls.__sessions[sid]
-
-    ## @brief checks if a session if registered
-    # @param sid str : session id
-    # @return bool
-    @classmethod
-    def is_registered(cls, sid):
-        return (sid in cls.__sessions)
-
-
-    ## @brief checks if a session is expired
-    # @param sid str : session id
-    @classmethod
-    def is_expired(cls, sid):
-        expiration_timestamp = cls.get_last_modified(sid) + cls.EXPIRATION_LIMIT
-        now_timestamp = get_utc_timestamp()
-        return now_timestamp > expiration_timestamp
-
-    ## @brief gets the timestamp of the last modification
-    # @param sid str : session id
-    # @return float
-    @classmethod
-    @abstractmethod
-    def get_last_modified(cls, sid):
-        return 0.0
-
-    ## @brief generates a new session id
-    # @return sid
-    # @todo find a more secure way of building a session id
-    @classmethod
-    def generate_new_sid(cls):
-        return uuid1()
-
-    ## @brief sets a key's value in the session
-    # @param key str
-    # @param value unknown
-    def set_key(self, key, value):
-        setattr(self, key, value)
-        self.save()
-
-    ## @brief gets a key's value from the session
-    # @param key str
-    # @return unknown
-    def get_key(self, key):
-        return getattr(object=self, name=key, default=None)
-
-    ## @brief deletes a given key in the session
-    # @param key str
-    def delete_key(self, key):
-        delattr(self, key)
-        self.save()
-
-    ## @brief lists all the sessions in the session store
-    # @return list
-    @classmethod
-    @abstractmethod
-    def list_all_sessions(cls):
-        return []
-
-    ## @brief checks if a given session id corresponds to an existing session
-    # @param sid str: session id
-    # @return bool
-    @classmethod
-    @abstractmethod
-    def exists(cls, sid):
-        return True

lodel/plugin/sessionhandler.py

@@ -1,7 +1,32 @@
-from .plugins import Plugin
+from .plugins import Plugin, MetaPlugType
 from .exceptions import *
 from lodel.settings.validator import SettingValidator
 
+##@brief SessionHandlerPlugin metaclass designed to implements a wrapper
+#between SessionHandlerPlugin classmethod and plugin loader functions
+class SessionPluginWrapper(MetaPlugType):
+    ##@brief Constant that stores all possible session actions
+    #
+    #Key is the SessionHandlerPlugin method name and value is SessionHandler
+    #plugin function name
+    _ACTIONS = {
+        'start': 'start_session',
+        'destroy': 'destroy_session', 
+        'restore': 'restore_session',
+        'save': 'save_session'}
+
+    def __init__(self, name, bases, attrs):
+        super().__init__(name, bases, attrs)
+        
+    ##@brief Handles wrapper between class method and plugin loader functions
+    def __get_attribute__(self, name):
+        if name in SessionPluginWrapper._Actions:
+            return getattr(
+                self._instance.loader_module(),
+                SessionPluginWrapper._Actions[name])
+        return super().__get_attribute__(name)
+
+
 ##@page lodel2_plugins Lodel2 plugins system
 #
 # @par Plugin structure
@@ -11,18 +36,19 @@ from lodel.settings.validator import SettingValidator
 # - an _activate() method that returns True if the plugin can be activated (
 # optionnal)
 #
-class SessionHandlerPlugin(Plugin):
-    __instance = None
+class SessionHandlerPlugin(Plugin, metaclass=SessionPluginWrapper): 
+    ##@brief Stores the singleton instance
+    _instance = None
+
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'session_handler',
         'default': None,
         'validator': SettingValidator('string', none_is_valid=False)}
-        
+            
     def __init__(self, plugin_name):
-        if self.__instance is None:
+        if self._instance is None:
             super(Plugin, self).__init__(plugin_name)
-            self.__instance = True
+            self._instance = self
         else:
             raise RuntimeError("A SessionHandler Plugin is already plug")
-

plugins/webui/client.py

@@ -1,4 +1,4 @@
-from lodel.auth.auth import Client
+from lodel.auth.client import Client
 
 class WebUiClient(Client):