Jifty::Web::Session - A Jifty session handler

Jifty documentation Contained in the Jifty distribution.

Index

Code Index:

NAME

Top

Jifty::Web::Session - A Jifty session handler

SYNOPSIS

Top

In your etc/config.yml (optional):

  framework:
    Web:
      # The default ($PORT is replaced by the port the app is running on)
      SessionCookieName: JIFTY_SID_$PORT

new

Returns a new, empty session.

id

Returns the session's id if it has been loaded, or undef otherwise.

create

Assign a new ID, and store it server-side if necessary.

load [ID]

Load up the current session from the given ID, or the appropriate cookie (see cookie_name) otherwise. If both of those fail, creates a session in the database.

load_by_kv key => value

Load up the current session from the given (key, value) pair. If no matching session could be found, it will create a new session with the key, value set. Be sure that what you're loading by is unique. If you're loading a session based on, say, a timestamp, then you're asking for trouble.

unload

Flush the session, and leaves the session object blank.

loaded

Returns true if the session has already been loaded.

get KEY [TYPE]

Returns the value for KEY for the current user's session. TYPE, which defaults to "key", allows accessing of other namespaces in the session, including "metadata" and "continuation".

set KEY => VALUE, [TYPE]

Sets the value VALUE for KEY for the session. TYPE, which defaults to "key", allows values to be set in other namespaces, including "metadata" and "continuation". VALUE can be an arbitrary perl data structure -- Jifty::Web::Session will serialize it for you.

remove KEY, [TYPE]

Remove key KEY from the cache. TYPE defaults to "key".

remove_all

Removes the session from the database entirely.

set_continuation ID CONT

Stores a continuation in the session.

get_continuation ID

Pulls a continuation from the current session. Expects a continuation ID.

remove_continuation ID

Removes a continuation with id ID from the store.

continuations

Return a hash of all the continuations in this session, keyed by the continuations' id.

Sets the session cookie.

Returns the current session's cookie_name -- it is the same for all users, but varies according to the port the server is running on.

expires [VALUE]

Get or set the session's expiration date, in a format expected by Cache::Cache.

Jifty documentation Contained in the Jifty distribution. 
use warnings;
use strict;

package Jifty::Web::Session;
use base qw/Jifty::Object/;
use DateTime    ();


sub new {
    my $class = shift;

    my $session_class = Jifty->config->framework('Web')->{'SessionClass'} || 'Jifty::Web::Session::JDBI';
    my $cookie_name = Jifty->config->framework('Web')->{'SessionCookieName'};
        Jifty::Util->require($session_class);
        return $session_class->new(@_);
}


sub id {
    die "Subclass must implement 'id'";
}


sub create {
    die "Subclass must implement 'create'";
}


sub load {
    die "Subclass must implement 'load'";
}


sub load_by_kv {
    die "Subclass must implement load_by_kv";
}


sub unload {
    my $self = shift;

    return unless $self->loaded;
    $self->_session(undef);
}


sub loaded {
    my $self = shift;
    return $self->_session;
}

sub _session {
    my $self = shift;
    $self->{'_session'} = shift if (@_);
    return ( $self->{'_session'} );
}


sub get {

    die "subclass must implement 'get'"
}


sub set {
    die "subclass must implement 'set'"
}


sub remove {
    die "subclass must implement 'remove'"
}


sub remove_all {
    die "Subclass must implement 'remove_all'"
}


sub set_continuation {
    my $self = shift;
    $self->set( @_, "continuation" );
}


sub get_continuation {
    my $self = shift;
    $self->get( @_, "continuation" );

}


sub remove_continuation {
    my $self = shift;
    $self->remove( @_, "continuation" );
}


sub continuations {
    die "Subclass must implement 'continuations'";
}


sub set_cookie {
    my $self = shift;

    # never send a cookie with cached content. misbehaving proxies cause
    # terrific problems
    return if Jifty->web->response->header('Expires');

    $self->load unless $self->loaded;

    my $cookie_name = $self->cookie_name;
    my $cookies     = Jifty->web->request ? Jifty->web->request->cookies : {};
    my $cookie      = {
        value   => $self->id,
        path    => '/',
        expires => $self->expires,
    };
    # XXX: do we every need to check the existing cookie to decide if
    # we want to set the cookie this time?
    Jifty->web->response->cookies->{$cookie_name} = $cookie;
}


sub cookie_name {
    my $self        = shift;
    my $cookie_name = $self->{'_cookie_name'};
    my $port        = ( ( Jifty->web->request && Jifty->web->request->port) || 'NOPORT' );
    $cookie_name =~ s/\$PORT/$port/g;
    return ($cookie_name);
}


sub expires {
    my $self = shift;
    $self->set( 'expires' => shift, "metadata" ) if @_;
    return ( $self->get( 'expires', "metadata" ) );
}

1;