public __construct( [ array $config = NULL , string $id = NULL ] ) (defined in Kohana_Session_Database)

Parameters

• array $config = NULL - Configuration
• string $id = NULL - Session id

Tags

• Uses - Session::read

Return Values

• void

public function __construct(array $config = NULL, $id = NULL)
{
	if ( ! isset($config['group']))
	{
		// Use the default group
		$config['group'] = Database::$default;
	}

	// Load the database
	$this->_db = Database::instance($config['group']);

	if (isset($config['table']))
	{
		// Set the table name
		$this->_table = (string) $config['table'];
	}

	if (isset($config['gc']))
	{
		// Set the gc chance
		$this->_gc = (int) $config['gc'];
	}

	if (isset($config['columns']))
	{
		// Overload column names
		$this->_columns = $config['columns'];
	}

	parent::__construct($config, $id);

	if (mt_rand(0, $this->_gc) === $this->_gc)
	{
		// Run garbage collection
		// This will average out to run once every X requests
		$this->_gc();
	}
}

public id( ) (defined in Kohana_Session_Database)

$id = $session->id();

Tags

• Since - 3.0.8

Return Values

• string

public function id()
{
	return $this->_session_id;
}

public __toString( ) (defined in Kohana_Session)

echo $session;

Tags

• Uses - Encrypt::encode

Return Values

• string

public function __toString()
{
	// Serialize the data array
	$data = serialize($this->_data);

	if ($this->_encrypted)
	{
		// Encrypt the data using the default key
		$data = Encrypt::instance($this->_encrypted)->encode($data);
	}
	else
	{
		// Obfuscate the data with base64 encoding
		$data = base64_encode($data);
	}

	return $data;
}

public as_array( ) (defined in Kohana_Session)

// Get a copy of the current session data
$data = $session->as_array();

// Assign by reference for modification
$data =& $session->as_array();

Return Values

• array

public function & as_array()
{
	return $this->_data;
}

public bind( string $key , mixed & $value ) (defined in Kohana_Session)

$session->bind('foo', $foo);

Parameters

• string $key required - Variable name
• byref mixed $value required - Referenced value

Return Values

• $this

public function bind($key, & $value)
{
	$this->_data[$key] =& $value;

	return $this;
}

public delete( string $key ) (defined in Kohana_Session)

$session->delete('foo');

Parameters

• string $key required - ,... variable name

Return Values

• $this

public function delete($key)
{
	$args = func_get_args();

	foreach ($args as $key)
	{
		unset($this->_data[$key]);
	}

	return $this;
}

public destroy( ) (defined in Kohana_Session)

$success = $session->destroy();

Return Values

• boolean

public function destroy()
{
	if ($this->_destroyed === FALSE)
	{
		if ($this->_destroyed = $this->_destroy())
		{
			// The session has been destroyed, clear all data
			$this->_data = array();
		}
	}

	return $this->_destroyed;
}

public get( string $key [, mixed $default = NULL ] ) (defined in Kohana_Session)

$foo = $session->get('foo');

Parameters

• string $key required - Variable name
• mixed $default = NULL - Default value to return

Return Values

• mixed

public function get($key, $default = NULL)
{
	return array_key_exists($key, $this->_data) ? $this->_data[$key] : $default;
}

public get_once( string $key [, mixed $default = NULL ] ) (defined in Kohana_Session)

$bar = $session->get_once('bar');

Parameters

• string $key required - Variable name
• mixed $default = NULL - Default value to return

Return Values

• mixed

public function get_once($key, $default = NULL)
{
	$value = $this->get($key, $default);

	unset($this->_data[$key]);

	return $value;
}

public static instance( [ string $type = NULL , string $id = NULL ] ) (defined in Kohana_Session)

$session = Session::instance();

Parameters

• string $type = NULL - Type of session (native, cookie, etc)
• string $id = NULL - Session identifier

Tags

• Uses - Kohana::config

Return Values

• Session

public static function instance($type = NULL, $id = NULL)
{
	if ($type === NULL)
	{
		// Use the default type
		$type = Session::$default;
	}

	if ( ! isset(Session::$instances[$type]))
	{
		// Load the configuration for this type
		$config = Kohana::config('session')->get($type);

		// Set the session class name
		$class = 'Session_'.ucfirst($type);

		// Create a new session instance
		Session::$instances[$type] = $session = new $class($config, $id);

		// Write the session at shutdown
		register_shutdown_function(array($session, 'write'));
	}

	return Session::$instances[$type];
}

public name( ) (defined in Kohana_Session)

$name = $session->name();

Tags

• Since - 3.0.8

Return Values

• string

public function name()
{
	return $this->_name;
}

public read( [ string $id = NULL ] ) (defined in Kohana_Session)

$session->read();

Parameters

• string $id = NULL - Session id

Return Values

• void

public function read($id = NULL)
{
	$data = NULL;

	try
	{
		if (is_string($data = $this->_read($id)))
		{
			if ($this->_encrypted)
			{
				// Decrypt the data using the default key
				$data = Encrypt::instance($this->_encrypted)->decode($data);
			}
			else
			{
				// Decode the base64 encoded data
				$data = base64_decode($data);
			}

			// Unserialize the data
			$data = unserialize($data);
		}
		else
		{
			// Ignore these, session is valid, likely no data though.
		}
	}
	catch (Exception $e)
	{
		// Ignore all reading errors, but log them
		Kohana::$log->add(Log::ERROR, 'Error reading session data: '.$id);
	}

	if (is_array($data))
	{
		// Load the data locally
		$this->_data = $data;
	}
}

public regenerate( ) (defined in Kohana_Session)

$id = $session->regenerate();

Return Values

• string

public function regenerate()
{
	return $this->_regenerate();
}

public set( string $key , mixed $value ) (defined in Kohana_Session)

$session->set('foo', 'bar');

Parameters

• string $key required - Variable name
• mixed $value required - Value

Return Values

• $this

public function set($key, $value)
{
	$this->_data[$key] = $value;

	return $this;
}

public write( ) (defined in Kohana_Session)

$session->write();

Tags

• Uses - Kohana::$log

Return Values

• boolean

public function write()
{
	if (headers_sent() OR $this->_destroyed)
	{
		// Session cannot be written when the headers are sent or when
		// the session has been destroyed
		return FALSE;
	}

	// Set the last active timestamp
	$this->_data['last_active'] = time();

	try
	{
		return $this->_write();
	}
	catch (Exception $e)
	{
		// Log & ignore all errors when a write fails
		Kohana::$log->add(Log::ERROR, Kohana_Exception::text($e))->write();

		return FALSE;
	}
}

protected _destroy( ) (defined in Kohana_Session_Database)

Return Values

• boolean

protected function _destroy()
{
	if ($this->_update_id === NULL)
	{
		// Session has not been created yet
		return TRUE;
	}

	// Delete the current session
	$query = DB::delete($this->_table)
		->where($this->_columns['session_id'], '=', ':id')
		->param(':id', $this->_update_id);

	try
	{
		// Execute the query
		$query->execute($this->_db);

		// Delete the cookie
		Cookie::delete($this->_name);
	}
	catch (Exception $e)
	{
		// An error occurred, the session has not been deleted
		return FALSE;
	}

	return TRUE;
}

protected _gc( ) (defined in Kohana_Session_Database)

protected function _gc()
{
	if ($this->_lifetime)
	{
		// Expire sessions when their lifetime is up
		$expires = $this->_lifetime;
	}
	else
	{
		// Expire sessions after one month
		$expires = Date::MONTH;
	}

	// Delete all sessions that have expired
	DB::delete($this->_table)
		->where($this->_columns['last_active'], '<', ':time')
		->param(':time', time() - $expires)
		->execute($this->_db);
}

protected _read( [ string $id = NULL ] ) (defined in Kohana_Session_Database)

Parameters

• string $id = NULL - Session id

Return Values

• string

protected function _read($id = NULL)
{
	if ($id OR $id = Cookie::get($this->_name))
	{
		$result = DB::select(array($this->_columns['contents'], 'contents'))
			->from($this->_table)
			->where($this->_columns['session_id'], '=', ':id')
			->limit(1)
			->param(':id', $id)
			->execute($this->_db);

		if ($result->count())
		{
			// Set the current session id
			$this->_session_id = $this->_update_id = $id;

			// Return the contents
			return $result->get('contents');
		}
	}

	// Create a new session id
	$this->_regenerate();

	return NULL;
}

protected _regenerate( ) (defined in Kohana_Session_Database)

Return Values

• string

protected function _regenerate()
{
	// Create the query to find an ID
	$query = DB::select($this->_columns['session_id'])
		->from($this->_table)
		->where($this->_columns['session_id'], '=', ':id')
		->limit(1)
		->bind(':id', $id);

	do
	{
		// Create a new session id
		$id = str_replace('.', '-', uniqid(NULL, TRUE));

		// Get the the id from the database
		$result = $query->execute($this->_db);
	}
	while ($result->count());

	return $this->_session_id = $id;
}

protected _write( ) (defined in Kohana_Session_Database)

Return Values

• boolean

protected function _write()
{
	if ($this->_update_id === NULL)
	{
		// Insert a new row
		$query = DB::insert($this->_table, $this->_columns)
			->values(array(':new_id', ':active', ':contents'));
	}
	else
	{
		// Update the row
		$query = DB::update($this->_table)
			->value($this->_columns['last_active'], ':active')
			->value($this->_columns['contents'], ':contents')
			->where($this->_columns['session_id'], '=', ':old_id');

		if ($this->_update_id !== $this->_session_id)
		{
			// Also update the session id
			$query->value($this->_columns['session_id'], ':new_id');
		}
	}

	$query
		->param(':new_id',   $this->_session_id)
		->param(':old_id',   $this->_update_id)
		->param(':active',   $this->_data['last_active'])
		->param(':contents', $this->__toString());

	// Execute the query
	$query->execute($this->_db);

	// The update and the session id are now the same
	$this->_update_id = $this->_session_id;

	// Update the cookie with the new session id
	Cookie::set($this->_name, $this->_session_id, $this->_lifetime);

	return TRUE;
}