Delayed closing of db connection

So it seems like the session is being closed after the objects have been destroyed. What about passing fSession::close() to register_shutdown_function()? I think this will force the session to close before the objects are destroyed.

register_shutdown_function(array('fSession', 'close'));

For anyone interested, I ended up doing something like this.

Code left out to keep it simple.

First a base class with a persist method. It could just as well be an interface. The important element is the persist() method invoked from the SessionManager below.

class PersistentObject
{
	public function persist()
	{
		fSession::set(get_class($this), urlencode(serialize($this)));
		return TRUE;
	}
}

The SessionManager that registers objects for persistens and serializes them before writing the session to storage:

class SessionManager
{
	private static $singleton;

	private $db;
	private $objects_to_persist = array();
	
	public static function &get()
	{
		if (self::$singleton == NULL) {
			self::$singleton = new SessionManager();
		}
		return self::$singleton;
	}
	
	function registerPersistentObject($object)
	{
		$this->objects_to_persist[] = $object;
	}
	
	public static function persistObjects()
	{
		foreach (self::$singleton->objects_to_persist as $object) {
			call_user_func_array(array(&$object, 'persist'), array());
		}
	}
	
	public static function getPersistedObject($className)
	{
		$serialized_object = fSession::get($className);
		if (isset($serialized_object) === TRUE) { 
			return unserialize(urldecode(fSession::get($serialized_object)));	
		}
		return FALSE;
	}
	
	function __construct()
	{
		session_set_save_handler( 
			array( &$this, "open" ), 
			array( &$this, "close" ),
			array( &$this, "read" ),
			array( &$this, "write"),
			array( &$this, "destroy"),
			array( &$this, "gc" )
			);
	}
	
	function setStorage(&$storage)
		{
			if ($storage instanceof fDatabase) {
				$this->db = $storage; 
			} else if (is_string($storage)) {
				fSession::setPath($storage);
			}
		}
	
	function open($session_path, $session_name)	{ ... }

	function close() { ... } // $db is automatically closed

	function read($id) { ... }

	function write($id, $data) { ... }

	function destroy($id) { ... }
	
	function gc() { ... }
}

A class extending PersistentObject:

class Application extends PersistentObject
{
        private static $singleton;

	public $universe;

	public static function &get()
	{
		if(!isset(self::$singleton)) {
			self::$singleton = SessionManager::getPersistedObject(__CLASS__);
			if(self::$singleton === FALSE) {
				self::$singleton = new Application();
			}
		}
		return self::$singleton;
	}
	
	public function __construct()
	{
		SessionManager::get()->registerPersistentObject($this);
	}

	public function __sleep()
	{
		return array('universe');
	}
	
	public function __wakeup()
	{
		SessionManager::get()->registerPersistentObject($this);
	}
        
        ...
}

And last, your init file:

// First SessionManager::persistObjects is registered to that is called before the session is closed.
register_shutdown_function(array('SessionManager', 'persistObjects'));
// Second fSession::close is registed to ensure that the session is written to database before the connection is closed in fDatabase::__destruct().
register_shutdown_function(array('fSession', 'close'));
$session_db = new fDatabase( ... );
SessionManager::get()->setStorage($session_db);
fSession::open();