Merge branch 'session-class' into newlodel

lodel/auth/session.py

@@ -0,0 +1,112 @@
+# -*- coding; utf-8 -*-
+
+from abc import ABC, abstractmethod
+from uuid import uuid1
+
+from lodel.auth.exceptions import AuthenticationError
+from lodel.utils.datetime import get_utc_timestamp
+
+
+class SessionStore(ABC):
+
+    expiration_limit = 900
+
+    # === ABSTRACT METHODS === #
+
+    ## @brief Destroys a session
+    # @param sid str : session id
+    @abstractmethod
+    def delete_session(self, sid):
+        pass
+
+    ## @brief Reads a session content
+    # @param sid str : session id
+    # @return dict
+    @abstractmethod
+    def read_session(self, sid):
+        return {}
+
+    ## @brief lists all the sessions ids
+    # @return list
+    @abstractmethod
+    def list_all_sessions(self):
+        return []
+
+    ## @brief saves a session to a file
+    # @param sid str : session id
+    # @param session dict : content to be saved
+    @abstractmethod
+    def save_session(self, sid, session):
+        pass
+
+    ## @brief checks if a session exists
+    # @param sid str : session id
+    # @return bool
+    @abstractmethod
+    def is_session_existing(self, sid):
+        return True
+
+    ## @brief gets a session's last modified timestamp
+    # @param sid str: session id
+    # @return float
+    @abstractmethod
+    def get_session_last_modified(self, sid):
+        pass
+
+    # === IMPLEMENTED METHODS === #
+
+    ## @brief Generates a session unique ID
+    # @param cls
+    # @return str
+    @classmethod
+    def generate_new_sid(cls):
+        return uuid1()
+
+    ## @brief Creates a new session
+    # @param content dict : session content (default: {})
+    # @return str
+    def create_new_session(self, content={}):
+        sid = self.__class__.generate_new_sid()
+        self.save_session(sid, content)
+        return sid
+
+    ## @brief checks if a session has expired
+    # @param sid str: session id
+    # @return bool
+    def has_session_expired(self, sid):
+        session_last_modified = self.get_session_last_modified(sid)
+        expiration_timestamp = session_last_modified + self.expiration_limit
+        now_timestamp = get_utc_timestamp()
+        return now_timestamp > expiration_timestamp
+
+    ## @brief cleans the session store's by destroying the expired sessions
+    def clean(self):
+        sessions_list = self.list_all_sessions()
+        for sid in sessions_list:
+            if self.has_session_expired(sid):
+                self.delete_session(sid)
+
+    ## @brief updates a session's content
+    # @param sid str : session's id
+    # @param content dict : items to update with their new value
+    def update_session(self, sid, content):
+        session = self.get_session(sid)
+        for key, value in content.items():
+            if key != 'sid':
+                session[key] = value
+        self.save_session(sid, session)
+
+    ## @brief gets a session's content
+    # @param sid str : id of the session to read
+    # @return dict
+    def get_session(self, sid):
+        if self.is_session_existing(sid):
+            if not self.has_session_expired(sid):
+                session = self.read_session(sid)
+            else:
+                self.delete_session(sid)
+                session = {}
+        else:
+            raise AuthenticationError("No session file found for the sid %s" % sid)
+
+        return session

plugins/filesystem_session/filesystem_session_store.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+
+import os
+import pickle
+import re
+
+from lodel.auth.exceptions import AuthenticationError
+from lodel.auth.session import SessionStore
+from lodel.settings import Settings
+
+
+class FileSystemSessionStore(SessionStore):
+
+    ## @brief instanciates a FileSystemSessionStore
+    # @param base_directory str : path to the base directory containing the session files (default: session.directory param of the settings)
+    # @param file_name_template str : template for the session files name (default : session.file_template param of the settings)
+    # @param expiration_limit int : duration of a session validity without any action made (defaut : session.expiration param of the settings)
+    def __init__(self, base_directory=Settings.session.directory, file_name_template=Settings.session.file_template, expiration_limit=Settings.session.expiration):
+        self.expiration_limit = expiration_limit
+        self.base_directory = base_directory
+        self.file_name_template = file_name_template
+
+    # === CRUD === #
+
+    ## @brief delete a session
+    # @param sid str : id of the session to be deleted
+    def delete_session(self, sid):
+        if self.is_session_existing(sid):
+            os.unlink(self.get_session_file_path(sid))
+        else:
+            raise AuthenticationError("No session file found for the sid %s" % sid)
+
+    ## @brief reads the content of a session
+    # @param sid str : session id
+    def read_session(self, sid):
+        session_file_path = self.get_session_file_path(sid)
+        with open(session_file_path, 'rb') as session_file:
+            session_content = pickle.load(session_file)
+        return session_content
+
+    ## @brief saves a session to a file
+    # @param sid str : session id
+    # @param session dict : content to be saved
+    def save_session(self, sid, session):
+        session_file_path = self.get_session_file_path(sid)
+        pickle.dump(session, open(session_file_path, "wb"))
+
+    # === UTILS === #
+    ## @brief returns the session id from the filename
+    # @param filename str : session file's name (not the complete path)
+    # @return str
+    # @raise AuthenticationError : in case the sid could not be found for the given filename
+    def filename_to_sid(self,filename):
+        sid_regex = self.file_name_template % '(?P<sid>.*)'
+        sid_regex_compiled = re.compile(sid_regex)
+        sid_searching_result = sid_regex_compiled.match(filename)
+        if sid_searching_result is not None:
+            return sid_searching_result.groupdict()['sid']
+        else:
+            raise AuthenticationError('No session id could be found for this filename')
+
+    ## @brief lists all the session files paths
+    # @return list
+    def list_all_sessions(self):
+        session_files_directory = os.path.abspath(self.base_directory)
+        sid_list = [self.filename_to_sid(file_object) for file_object in os.listdir(session_files_directory) if os.path.isfile(os.path.join(session_files_directory, file_object))]
+        return sid_list
+
+    ## @brief returns the file path for a given session id
+    # @param sid str : session id
+    # @return str
+    def get_session_file_path(self, sid):
+        return os.path.join(self.base_directory, self.file_name_template) % sid
+
+    ## @brief checks if a session exists
+    # @param sid str : session id
+    # @return bool
+    def is_session_existing(self, sid):
+        session_file = self.get_session_file_path(sid)
+        return os.path.is_file(session_file)
+
+    ## @brief gets a session's last modified timestamp
+    # @param sid str: session id
+    # @return float
+    def get_session_last_modified(self, sid):
+        session_file = self.get_session_file_path(sid)
+        return os.stat(session_file).st_mtime

plugins/filesystem_session/main.py

@@ -1,58 +1,11 @@
 # -*- coding: utf-8 -*-
 
-import os
-import pickle
-import uuid
-
 from lodel.auth.exceptions import AuthenticationError
 from lodel.plugin import LodelHook
-from lodel.settings import Settings
-from lodel.utils.datetime import get_utc_timestamp
-
-SESSION_FILES_BASE_DIR = Settings.sessions.directory
-SESSION_FILES_TEMPLATE = Settings.sessions.file_template
-SESSION_EXPIRATION_LIMIT = Settings.sessions.expiration
-
-
-## @brief generates a new session id
-def generate_new_sid():
-    return uuid.uuid1()
-
-
-## @brief gets the session file path, given a session id
-# @param sid str : session id
-# @return str
-def get_session_file_path(sid):
-    return os.path.join(SESSION_FILES_BASE_DIR, SESSION_FILES_TEMPLATE) % sid
-
-
-## @brief saves the session content to a session file
-# @param sid str: session id
-# @param session dict : session content to be saved
-def save_session(sid, session):
-    session_file_path = get_session_file_path(sid)
-    pickle.dump(session, open(session_file_path, "wb"))
 
+from .filesystem_session_store import FileSystemSessionStore
 
-## @brief checks if a session file has expired
-# @param sid str : session id
-# @return bool
-def is_session_expired(sid):
-    session_file = get_session_file_path(sid)
-    if not os.path.isfile(session_file):
-        raise AuthenticationError("No session file found for the sid : %s" % sid)
-
-    expiration_timestamp = os.stat(session_file).st_mtime + SESSION_EXPIRATION_LIMIT
-    now_timestamp = get_utc_timestamp()
-    return now_timestamp >= expiration_timestamp
-
-
-## @brief reads a session content
-# @param sid str: session id
-# @return dict
-def get_session_content(sid):
-    session_file_path = get_session_file_path(sid)
-    return pickle.load(open(session_file_path), 'rb')
+session_store = FileSystemSessionStore()
 
 
 ## @brief starts a new session and returns its sid
@@ -61,66 +14,41 @@ def get_session_content(sid):
 # @return str
 @LodelHook('session_start')
 def start_session(caller, payload):
-    sid = generate_new_sid()
-    session_file = get_session_file_path(sid)
-    session = dict()
-    for key, value in payload.items():
-        session[key] = value
-    save_session(sid, session)
-    return sid
+    return session_store.create_new_session(payload)
 
-## @brief stops a session
+
+## @brief destroys a session
 # @param caller *
 # @param sid str : session id
 @LodelHook('session_destroy')
 def stop_session(caller, sid):
-    session_file_path = get_session_file_path(sid)
-    if os.path.isfile(session_file_path):
-        os.unlink(session_file_path)
-    else:
-        raise AuthenticationError("No session file found for the sid %s" % sid)
+    session_store.delete_session(sid)
 
 
 ## @brief reads a session content
 # @param caller *
 # @param sid str: session id
+# @return dict
 @LodelHook('session_load')
 def read_session(caller, sid):
-    session_file = get_session_file_path(sid)
-    if os.path.isfile(session_file):
-        if not is_session_expired(sid):
-            session = get_session_content(sid)
-        else:
-            LodelHook.call_hook('session_stop', __file__, sid)
-            session = {}
-    else:
-        raise AuthenticationError("No session file found for the sid %s" % sid)
-    return session
+    return session_store.get_session(sid)
 
 
-## @brief deletes all old session files (expired ones)
+## @brief destroys all the old sessions (expired ones)
 # @param caller *
 @LodelHook('session_clean')
 def clean_sessions(caller):
-    session_files_path = os.path.abspath(SESSION_FILES_BASE_DIR)
-    session_files = [os.path.join(session_files_path, file_object) for file_object in os.listdir(session_files_path) if os.path.isfile(os.path.join(session_files_path, file_object))]
-    now_timestamp = get_utc_timestamp()
-    for session_file in session_files:
-        last_modified = os.stat(session_file).st_mtime
-        expiration_timestamp = last_modified + SESSION_EXPIRATION_LIMIT
-        if now_timestamp > expiration_timestamp:
-            os.unlink(session_file)
+    session_store.clean()
+
 
-## @brief updates the content session
+## @brief updates the content of the session
 # @param caller *
-# @param payload dict: datas to insert/update in the session
+# @param payload dict : datas to insert/update in the session
 @LodelHook('update_session')
 def update_session_content(caller, payload):
     if 'sid' in payload:
         sid = payload['sid']
-        session = LodelHook.call_hook('session_load', __file__, sid)
-        for key, value in payload.items():
-            session[key] = value
-        save_session(sid, session)
+        del payload['sid']
+        session_store.update_session(sid, payload)
     else:
-        raise AuthenticationError("Missing session id in the request")
+        raise AuthenticationError("Session Update: Missing sid (session id) in the given payload argument")