Finished implementation of session and one-time-key stores for RDBMS backends.

Refactored the API of sessions and their interaction with the
backend database a fair bit too.

Added some session tests. Nothing testing ageing yet, 'cos that's a pain
inna ass to test :)

Note: metakit backend still uses the *dbm implementation. It might
want to implement its own session store some day, as it'll be faster than
the *dbm one.

Author: Richard Jones

CHANGES.txt

@@ -13,6 +13,7 @@ Feature:
 - added postgresql backend (originally from sf patch 761740, many changes
   since)
 - all RDBMS backends now have indexes on several columns
+- RDBMS backends implement their session and one-time-key stores
 - change nosymessage and send_message to accept msgid=None (RFE #707235).
 - handle Resent-From: headers (sf bug 841151)
 - always sort MultilinkHTMLProperty in the correct order, usually

roundup/backends/back_anydbm.py

@@ -15,7 +15,7 @@
 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 # 
-#$Id: back_anydbm.py,v 1.137 2004-03-15 05:50:20 richard Exp $
+#$Id: back_anydbm.py,v 1.138 2004-03-18 01:58:45 richard Exp $
 '''This module defines a backend that saves the hyperdatabase in a
 database chosen by anydbm. It is guaranteed to always be available in python
 versions >2.1.1 (the dumbdbm fallback in 2.1.1 and earlier has several
@@ -36,7 +36,7 @@
 import whichdb, os, marshal, re, weakref, string, copy
 from roundup import hyperdb, date, password, roundupdb, security
 from blobfiles import FileStorage
-from sessions import Sessions, OneTimeKeys
+from sessions_dbm import Sessions, OneTimeKeys
 from roundup.indexer import Indexer
 from roundup.backends import locking
 from roundup.hyperdb import String, Password, Date, Interval, Link, \
@@ -79,8 +79,6 @@ def __init__(self, config, journaltag=None):
         self.destroyednodes = {}# keep track of the destroyed nodes by class
         self.transactions = []
         self.indexer = Indexer(self.dir)
-        self.sessions = Sessions(self.config)
-        self.otks = OneTimeKeys(self.config)
         self.security = security.Security(self)
         # ensure files are group readable and writable
         os.umask(0002)
@@ -103,6 +101,12 @@ def refresh_database(self):
         """
         self.reindex()
 
+    def getSessionManager(self):
+        return Sessions(self)
+
+    def getOTKManager(self):
+        return OneTimeKeys(self)
+
     def reindex(self):
         for klass in self.classes.values():
             for nodeid in klass.list():

roundup/backends/back_metakit.py

@@ -1,4 +1,4 @@
-# $Id: back_metakit.py,v 1.61 2004-03-12 05:36:26 richard Exp $
+# $Id: back_metakit.py,v 1.62 2004-03-18 01:58:45 richard Exp $
 '''Metakit backend for Roundup, originally by Gordon McMillan.
 
 Known Current Bugs:
@@ -43,7 +43,7 @@
 
 from roundup import hyperdb, date, password, roundupdb, security
 import metakit
-from sessions import Sessions, OneTimeKeys
+from sessions_dbm import Sessions, OneTimeKeys
 import re, marshal, os, sys, time, calendar
 from roundup import indexer
 import locking
@@ -81,8 +81,6 @@ def __init__(self, config, journaltag=None):
         self.lockfile = None
         self._db = self.__open()
         self.indexer = Indexer(self.config.DATABASE, self._db)
-        self.sessions = Sessions(self.config)
-        self.otks = OneTimeKeys(self.config)
         self.security = security.Security(self)
 
         os.umask(0002)
@@ -101,6 +99,12 @@ def reindex(self):
                 klass.index(nodeid)
         self.indexer.save_index()
 
+    def getSessionManager(self):
+        return Sessions(self)
+
+    def getOTKManager(self):
+        return OneTimeKeys(self)
+
     # --- defined in ping's spec
     def __getattr__(self, classname):
         if classname == 'transactions':

roundup/backends/back_mysql.py

@@ -86,22 +86,25 @@ class Database(Database):
     # use BDB to pass all unit tests.
     mysql_backend = 'InnoDB'
     #mysql_backend = 'BDB'
-    
-    def sql_open_connection(self):
-        # make sure the database actually exists
-        if not db_exists(self.config):
-            db_create(self.config)
 
+    def sql_open_connection(self):
         db = getattr(self.config, 'MYSQL_DATABASE')
         try:
-            self.conn = MySQLdb.connect(*db)
+            conn = MySQLdb.connect(*db)
         except MySQLdb.OperationalError, message:
             raise DatabaseError, message
+        cursor = conn.cursor()
+        cursor.execute("SET AUTOCOMMIT=0")
+        cursor.execute("BEGIN")
+        return (conn, cursor)
+    
+    def open_connection(self):
+        # make sure the database actually exists
+        if not db_exists(self.config):
+            db_create(self.config)
+
+        self.conn, self.cursor = self.sql_open_connection()
 
-        self.cursor = self.conn.cursor()
-        # start transaction
-        self.sql("SET AUTOCOMMIT=0")
-        self.sql("BEGIN")
         try:
             self.load_dbschema()
         except MySQLdb.OperationalError, message:
@@ -124,9 +127,10 @@ def create_version_2_tables(self):
         self.cursor.execute('CREATE TABLE otks (otk_key VARCHAR(255), '
             'otk_value VARCHAR(255), otk_time FLOAT(20))')
         self.cursor.execute('CREATE INDEX otks_key_idx ON otks(otk_key)')
-        self.cursor.execute('CREATE TABLE sessions (s_key VARCHAR(255), '
-            's_last_use FLOAT(20), s_user VARCHAR(255))')
-        self.cursor.execute('CREATE INDEX sessions_key_idx ON sessions(s_key)')
+        self.cursor.execute('CREATE TABLE sessions (session_key VARCHAR(255), '
+            'session_time FLOAT(20), session_value VARCHAR(255))')
+        self.cursor.execute('CREATE INDEX sessions_key_idx ON '
+            'sessions(session_key)')
 
     def add_actor_column(self):
         # update existing tables to have the new actor column

roundup/backends/back_postgresql.py

@@ -83,19 +83,24 @@ class Database(rdbms_common.Database):
     arg = '%s'
 
     def sql_open_connection(self):
+        db = getattr(self.config, 'POSTGRESQL_DATABASE')
+        try:
+            conn = psycopg.connect(**db)
+        except psycopg.OperationalError, message:
+            raise hyperdb.DatabaseError, message
+
+        cursor = conn.cursor()
+
+        return (conn, cursor)
+
+    def open_connection(self):
         if not db_exists(self.config):
             db_create(self.config)
 
         if __debug__:
             print >>hyperdb.DEBUG, '+++ open database connection +++'
 
-        db = getattr(self.config, 'POSTGRESQL_DATABASE')
-        try:
-            self.conn = psycopg.connect(**db)
-        except psycopg.OperationalError, message:
-            raise hyperdb.DatabaseError, message
-
-        self.cursor = self.conn.cursor()
+        self.conn, self.cursor = self.sql_open_connection()
 
         try:
             self.load_dbschema()
@@ -111,9 +116,10 @@ def create_version_2_tables(self):
         self.cursor.execute('CREATE TABLE otks (otk_key VARCHAR(255), '
             'otk_value VARCHAR(255), otk_time FLOAT(20))')
         self.cursor.execute('CREATE INDEX otks_key_idx ON otks(otk_key)')
-        self.cursor.execute('CREATE TABLE sessions (s_key VARCHAR(255), '
-            's_last_use FLOAT(20), s_user VARCHAR(255))')
-        self.cursor.execute('CREATE INDEX sessions_key_idx ON sessions(s_key)')
+        self.cursor.execute('CREATE TABLE sessions (session_key VARCHAR(255), '
+            'session_time FLOAT(20), session_value VARCHAR(255))')
+        self.cursor.execute('CREATE INDEX sessions_key_idx ON '
+            'sessions(session_key)')
 
     def add_actor_column(self):
         # update existing tables to have the new actor column

roundup/backends/back_sqlite.py

@@ -1,4 +1,4 @@
-# $Id: back_sqlite.py,v 1.16 2004-03-15 05:50:20 richard Exp $
+# $Id: back_sqlite.py,v 1.17 2004-03-18 01:58:45 richard Exp $
 '''Implements a backend for SQLite.
 
 See https://pysqlite.sourceforge.net/ for pysqlite info
@@ -17,18 +17,24 @@ class Database(rdbms_common.Database):
     arg = '%s'
 
     def sql_open_connection(self):
+        db = os.path.join(self.config.DATABASE, 'db')
+        conn = sqlite.connect(db=db)
+        cursor = conn.cursor()
+        return (conn, cursor)
+
+    def open_connection(self):
         # ensure files are group readable and writable
         os.umask(0002)
-        db = os.path.join(self.config.DATABASE, 'db')
 
-        # lock it
+        # lock the database
+        db = os.path.join(self.config.DATABASE, 'db')
         lockfilenm = db[:-3] + 'lck'
         self.lockfile = locking.acquire_lock(lockfilenm)
         self.lockfile.write(str(os.getpid()))
         self.lockfile.flush()
 
-        self.conn = sqlite.connect(db=db)
-        self.cursor = self.conn.cursor()
+        (self.conn, self.cursor) = self.sql_open_connection()
+
         try:
             self.load_dbschema()
         except sqlite.DatabaseError, error:
@@ -40,13 +46,24 @@ def sql_open_connection(self):
             self.cursor.execute('create index ids_name_idx on ids(name)')
             self.create_version_2_tables()
 
+    def close(self):
+        ''' Close off the connection.
+        '''
+        self.sql_close()
+        if self.lockfile is not None:
+            locking.release_lock(self.lockfile)
+        if self.lockfile is not None:
+            self.lockfile.close()
+            self.lockfile = None
+
     def create_version_2_tables(self):
         self.cursor.execute('create table otks (otk_key varchar, '
-            'otk_value varchar, otk_time varchar)')
+            'otk_value varchar, otk_time integer)')
         self.cursor.execute('create index otks_key_idx on otks(otk_key)')
-        self.cursor.execute('create table sessions (s_key varchar, '
-            's_last_use varchar, s_user varchar)')
-        self.cursor.execute('create index sessions_key_idx on sessions(s_key)')
+        self.cursor.execute('create table sessions (session_key varchar, '
+            'session_time integer, session_value varchar)')
+        self.cursor.execute('create index sessions_key_idx on '
+                'sessions(session_key)')
 
     def add_actor_column(self):
         # update existing tables to have the new actor column

roundup/backends/rdbms_common.py

@@ -1,4 +1,4 @@
-# $Id: rdbms_common.py,v 1.80 2004-03-17 22:01:37 richard Exp $
+# $Id: rdbms_common.py,v 1.81 2004-03-18 01:58:45 richard Exp $
 ''' Relational database (SQL) backend common code.
 
 Basics:
@@ -40,7 +40,7 @@
 # support
 from blobfiles import FileStorage
 from roundup.indexer import Indexer
-from sessions import Sessions, OneTimeKeys
+from sessions_rdbms import Sessions, OneTimeKeys
 from roundup.date import Range
 
 # number of rows to keep in memory
@@ -60,8 +60,6 @@ def __init__(self, config, journaltag=None):
         self.dir = config.DATABASE
         self.classes = {}
         self.indexer = Indexer(self.dir)
-        self.sessions = Sessions(self.config)
-        self.otks = OneTimeKeys(self.config)
         self.security = security.Security(self)
 
         # additional transaction support for external files and the like
@@ -76,13 +74,19 @@ def __init__(self, config, journaltag=None):
         self.lockfile = None
 
         # open a connection to the database, creating the "conn" attribute
-        self.sql_open_connection()
+        self.open_connection()
 
     def clearCache(self):
         self.cache = {}
         self.cache_lru = []
 
-    def sql_open_connection(self):
+    def getSessionManager(self):
+        return Sessions(self)
+
+    def getOTKManager(self):
+        return OneTimeKeys(self)
+
+    def open_connection(self):
         ''' Open a connection to the database, creating it if necessary.
 
             Must call self.load_dbschema()
@@ -1069,11 +1073,6 @@ def close(self):
         ''' Close off the connection.
         '''
         self.sql_close()
-        if self.lockfile is not None:
-            locking.release_lock(self.lockfile)
-        if self.lockfile is not None:
-            self.lockfile.close()
-            self.lockfile = None
 
 #
 # The base Class class

roundup/backends/sessions.py roundup/backends/sessions_dbm.pyroundup/backends/sessions.py renamed to roundup/backends/sessions_dbm.py

@@ -1,4 +1,4 @@
-#$Id: sessions.py,v 1.10 2004-02-26 04:20:45 drkorg Exp $
+#$Id: sessions_dbm.py,v 1.1 2004-03-18 01:58:45 richard Exp $
 """This module defines a very basic store that's used by the CGI interface
 to store session and one-time-key information.
 
@@ -16,9 +16,9 @@ class BasicDatabase:
     '''
     _db_type = None
 
-    def __init__(self, config):
-        self.config = config
-        self.dir = config.DATABASE
+    def __init__(self, db):
+        self.config = db.config
+        self.dir = db.config.DATABASE
         # ensure files are group readable and writable
         os.umask(0002)
 
@@ -45,13 +45,16 @@ def cache_db_type(self, path):
             db_type = 'dbm'
         self.__class__._db_type = db_type
 
-    def get(self, infoid, value):
+    _marker = []
+    def get(self, infoid, value, default=_marker):
         db = self.opendb('c')
         try:
             if db.has_key(infoid):
                 values = marshal.loads(db[infoid])
             else:
-                return None
+                if default != self._marker:
+                    return default
+                raise KeyError, 'No such %s "%s"'%(self.name, infoid)
             return values.get(value, None)
         finally:
             db.close()
@@ -62,7 +65,7 @@ def getall(self, infoid):
             try:
                 return marshal.loads(db[infoid])
             except KeyError:
-                raise KeyError, 'No such One Time Key "%s"'%infoid
+                raise KeyError, 'No such %s "%s"'%(self.name, infoid)
         finally:
             db.close()
 
@@ -72,7 +75,7 @@ def set(self, infoid, **newvalues):
             if db.has_key(infoid):
                 values = marshal.loads(db[infoid])
             else:
-                values = {}
+                values = {'__timestamp': time.time()}
             values.update(newvalues)
             db[infoid] = marshal.dumps(values)
         finally:
@@ -115,23 +118,24 @@ def opendb(self, mode):
     def commit(self):
         pass
 
+    def close(self):
+        pass
+
     def updateTimestamp(self, sessid):
-        self.set(sessid, **{self.timestamp: time.time()})
+        self.set(sessid, __timestamp=time.time())
 
     def clean(self, now):
         """Age sessions, remove when they haven't been used for a week.
         """
         week = 60*60*24*7
         for sessid in self.list():
-            interval = now - self.get(sessid, self.timestamp)
+            interval = now - self.get(sessid, '__timestamp')
             if interval > week:
                 self.destroy(sessid)
 
 class Sessions(BasicDatabase):
     name = 'sessions'
-    timestamp = 'last_use'
 
 class OneTimeKeys(BasicDatabase):
     name = 'otks'
-    timestamp = '__time'