Session refactoring ideas

Here are my ideas for refactoring Nette's session implementation. I start with problems of current implementation,
then summarize all current requirements on new imlementation and also add some new ones. Then, I propose new interfaces and briefly discuss their usage.
These interfaces are then shown in details with some notes. Finally, I show outcomes of this implementation and also present some new extensions, which will be now possible to implement
and which weren't possible in old implementation.

Problems with current session:

• difficult mocking
• serializes requests – more requests cannot run in paralell
• almost no possibility for different storages

Paralell access

PHP's implementation of session opens session file when we call sesssion_start() and locks it, so until we finish working with session and close it, another request cannot be processed.
It could be good to implement session storage, where paralell access is possible, e.g. by locking individual namespaces and not whole session object.

All methods which are required:

Here is brief list of all features/methods in current implementation, which should be supported in new one.

get+set cookie_params
start
write_close
destroy
get+set name (session_name)
regenerateId
get+set id
configure - Nette\Session::configure
init storage - _SESSION['__NF']
send cookies - SESS_ID + Browser Key
pre-clean - before session is started, remove all expired data
clean
get+set+has+remove namespace
get namespace iterator
get+set parameters - like Counter, BrowserKey, ...
set+get+has+remove values from namespaces

Additional requirements:

• easy change of storage backend (classic, mysql, memcache, …)
• concurrent access – allow multiple simultaneous requests to work with different namespaces
• allow storage with locking – acquire lock for namespace
• storage can or can not rely on PHP's session implementation, e.g. it can set dummy methods for session_set_handler and load/write data when loading individual namespaces
• removing expired values lazily, i.e. not in all namespaces at once, but when namespace is loaded

Proposed interfaces:

• ISessionStorage – given session_id, handles requests for namespaces and/or parameters
• ISessionNamespace – manipulation of variables within namespace, can support locking; has data + its metadata + parameters (misc metadata not dependent on data)
• ISession – configures session, dispatches calls and events and retrieves namespaces

ISessionStorage:

• constructor($sessionId) – receives session id (but I think constructor shouldn't be in interfaces, any ideas?)
• basic features
  • open/start() – loads session data and initializes structures (if needed)
  • close() – write data to disk (if needed)
  • destroy() – removes all session data
  • clean() – clean structures (like remove empty namespaces)
  • gc() – remove all old existing sessions (not just mine)
• global parameter handling
  • {get+set+has+remove}Parameter(…)
• namespace handling
  • {get+set+has+remove}Namespace(…)
  • getAllNamespaces()
• misc
  • changeId($newId) – after regenerateId has been called, it moves data to another sessionId

ISessionNamespace:

• constructor($storage, $name) – loads data from storage
• destructor – flushes data to storage
• flush()
• reload() – reloads data from storage
• manipulation with variables, like it is now
• set+get Expiration
• {get+set+has+remove}Parameter – namespace's metadata

ISession:

• start() – populaes BrowserKey + Counter + …
• close()
• destroy()
• configure()
• sendCookie()
• {get+set}CookieParams
• regenerateId
• {get+set}{Id+Name}
• {get+set+has+remove}Namespace
• gc() – removes expired values

Outcomes

• simple implementation of different storages by just implementing ISessionStorage
• mocking storage with e.g. just static variables
• mocking Session not to send any cookies, but allowing all storages to be used
• namespaces can be overriden and thus support locking (if it is supported by storage)

Future work

ILockableSessionStorage: (pesimistic locking, will not be part of Nette)

• get($namespace, bool $lock = false)
• set($namespace, $data, $metadata, bool $unlock = false)

Loclable namespace will then loads data with lock and in __destruct() call set() and unlock it

IVersionableSessionStorage: (optimistic locking, will not be part of Nette)

• get($namespace) → data, meta, version
• set($namespace, $data, $medatada, $prevVersion) – can throw exception when data has been modified

Not solved problems

• how to pass sessionId to SessionStorage?
• should cookie methods be in Session or rather in HttpRequest/HttpResponse? (as proposed by Ondra Mirtes)

Please discuss and provide your ideas.

Editoval juzna.cz (5. 3. 2011 0:06)