Added a Ram based session manager

lodel/session/lodel_ram_session/lodel_ram_session.py

@@ -0,0 +1,24 @@
+from collections import MutableMapping
+from flask.sessions import SessionMixin
+
+class LodelRamSession(MutableMapping, SessionMixin):
+    
+    def __init__(self, sid, *args, **kwargs):
+        self.sid = sid
+        self.data = dict()
+    
+    def __getitem__(self, key):
+        return self.data[key]
+    
+    def __setitem__(self, key, value):
+        self.data[key] = value
+
+    def __delitem__(self, key):
+        del self.data[key]
+    
+    def __iter__(self):
+        return iter(self.data)
+    
+    def __len__(self):
+        return len(self.data)
+    

lodel/session/lodel_ram_session/lodel_ram_session_interface.py

@@ -0,0 +1,57 @@
+from flask.sessions import SessionInterface
+import binascii
+import os
+from lodel.session.lodel_ram_session.lodel_ram_session import LodelRamSession
+import copy
+
+
+class LodelRamSessionInterface(SessionInterface):
+    __sessions = dict()
+    
+    def open_session(self, app, request):
+        self.session_tokensize = int(app.config['lodel.sessions']['tokensize'])
+        sid = request.cookies.get(app.session_cookie_name) or self.generate_token()
+        session = LodelRamSession(sid)
+        if self.__class__.__sessions.get(sid, None) is None:
+            self.__class__.__sessions[sid] = session 
+        return session
+
+    
+    def save_session(self, app, session, response):
+        domain = self.get_cookie_domain(app)
+        
+        if not session:
+            del(self.__class__.__sessions[session.sid])
+            response.delete_cookie(app.session_cookie_name, domain=domain)
+            return
+        
+        cookie_exp = self.get_expiration_time(app, session)
+        response.set_cookie(app.session_cookie_name, session.sid, expires=cookie_exp, httponly=False, domain=domain)
+    
+    ## @brief generates a new session token
+    #
+    # @return str
+    #
+    # @remarks There is no valid reason for checking the generated token uniqueness:
+    #        - checking for uniqueness is slow ;
+    #        - keeping a dict with a few thousand keys of hundred bytes also is
+    #            memory expensive ;
+    #        - should the system get distributed while sharing session storage, there
+    #            would be no reasonable way to efficiently check for uniqueness ;
+    #        - sessions do have a really short life span, drastically reducing
+    #            even more an already close to inexistent risk of collision. A 64 bits
+    #            id would perfectly do the job, or to be really cautious, a 128 bits
+    #            one (actual size of UUIDs) ;
+    #        - if we are still willing to ensure uniqueness, then simply salt it
+    #            with a counter, or a timestamp, and hash the whole thing with a 
+    #            cryptographically secured method such as sha-2 if we are paranoids
+    #            and trying to avoid what will never happen, ever ;
+    #        - sure, two hexadecimal characters is one byte long. Simply go for 
+    #            bit length, not chars length.
+    def generate_token(self):
+        token = binascii.hexlify(os.urandom(self.session_tokensize))
+        if self.__class__.__sessions.get(token, None) is not None:
+            token = self.generate_token()
+        return token.decode('utf-8')
+    
+    

lodel_app/__init__.py

@@ -4,6 +4,7 @@ import os
 from lodel.lodelsites.utils import register_lodelsites
 from lodel.utils.ini_files import ini_to_dict
 from lodel.session.lodel_filesystem_session.lodel_filesystem_session_interface import LodelFileSystemSessionInterface
+from lodel.session.lodel_ram_session.lodel_ram_session_interface import LodelRamSessionInterface
 
 
 lodel_app = Flask(__name__)
@@ -13,7 +14,7 @@ lodel_app.config.update(ini_to_dict(os.path.join(os.path.dirname(os.path.abspath
 
 lodel_app.session_cookie_name = lodel_app.config['lodel.sessions']['session_cookie_name']
 lodel_app.permanent_session_lifetime = int(lodel_app.config['lodel.sessions']['session_lifetime'])
-lodel_app.session_interface = LodelFileSystemSessionInterface(lodel_app.config['lodel.filesystem_sessions']['path'])
+lodel_app.session_interface = LodelRamSessionInterface()  # LodelFileSystemSessionInterface(lodel_app.config['lodel.filesystem_sessions']['path'])
 
 # Main Hooks
 from .hooks import *