view release on metacpan or  search on metacpan

lib/Apache/AppSamurai/Session.pm  view on Meta::CPAN

package Apache::AppSamurai::Session;
use strict;
use warnings;

use vars qw($VERSION @ISA $incl);
$VERSION = substr(q$Revision: 1.9 $, 10, -1);

use Apache::Session;

@ISA = qw( Apache::Session );
$incl = {};

sub populate {
    my $self = shift;

    # Allow standard Apache::Session syntax, special AppSamurai/<ITEM>
    # syntax, or specifying a full module path.
    my ($store, $lock, $gen, $ser);
    if ($self->{args}->{Store} =~ /^AppSamurai\/([\w\d\_]+?)\s*$/i) {
	$store = "Apache::AppSamurai::Session::Store::$1";
    } elsif ($self->{args}->{Store} =~ /::/) {
	$store = $self->{args}->{Store};
    } else {
	$store = "Apache::Session::Store::$self->{args}->{Store}";
    }
    if ($self->{args}->{Lock} =~ /^AppSamurai\/([\w\d\_]+?)\s*$/i) {
	$lock = "Apache::AppSamurai::Session::Lock::$1";
    } elsif ($self->{args}->{Lock} =~ /::/) {
	$lock = $self->{args}->{Lock};
    } else {
	$lock  = "Apache::Session::Lock::$self->{args}->{Lock}";
    }
    if ($self->{args}->{Generate} =~ /^AppSamurai\/([\w\d\_]+?)\s*$/i) {
	$gen  = "Apache::AppSamurai::Session::Generate::$1";
    } elsif ($self->{args}->{Generate} =~ /::/) {
	$gen  = $self->{args}->{Generate};
    } else {
	$gen = "Apache::Session::Generate::$self->{args}->{Generate}";
    }
    if ($self->{args}->{Serialize} =~ /^AppSamurai\/([\w\d\_]+?)\s*$/i) {
	$ser  = "Apache::AppSamurai::Session::Serialize::$1";
    } elsif ($self->{args}->{Serialize} =~ /::/) {
	$ser  = $self->{args}->{Serialize};
    } else {
	$ser = "Apache::Session::Serialize::$self->{args}->{Serialize}";
    }

    if (!exists $incl->{$store}) {
        eval "require $store" || die $@;
        $incl->{$store} = 1;
    }
    
    if (!exists $incl->{$lock}) {
        eval "require $lock" || die $@;
        $incl->{$lock} = 1;
    }
    
    if (!exists $incl->{$gen}) {
        eval "require $gen" || die $@;
        eval '$incl->{$gen}->[0] = \&' . $gen . '::generate' || die $@;
        eval '$incl->{$gen}->[1] = \&' . $gen . '::validate' || die $@;
    }
    
    if (!exists $incl->{$ser}) {
        eval "require $ser" || die $@;
        eval '$incl->{$ser}->[0] = \&' . $ser . '::serialize'   || die $@;
        eval '$incl->{$ser}->[1] = \&' . $ser . '::unserialize' || die $@;
    }
    
    $self->{object_store} = new $store $self;
    $self->{lock_manager} = new $lock  $self;
    $self->{generate}     = $incl->{$gen}->[0];
    $self->{validate}     = $incl->{$gen}->[1];
    $self->{serialize}    = $incl->{$ser}->[0];
    $self->{unserialize}  = $incl->{$ser}->[1];

    return $self;
}


1; # End of Apache::AppSamurai::Session

__END__

=head1 NAME

Apache::AppSamurai::Session - Apache::AppSamurai wrapper for Apache::Session

=head1 SYNOPSIS

 use Apache::AppSamurai::Session;
 
 # Equivalent to Apache::Session::Flex use:

 tie %hash, 'Apache::AppSamurai::Session', $id, {
    Store     => 'DB_File',
    Lock      => 'Null',
    Generate  => 'MD5',
    Serialize => 'Storable'
 };
 
 # Postgress backend with AppSamurai HMAC-SHA265 generator and
 # AES (Rijndael) encrypting serializer.

 tie %hash, 'Apache::AppSamurai::Session', $id, {
    Store     => 'Postgress',
    Lock      => 'Null',
    Generate  => 'AppSamurai/HMAC_SHA',
    Serialize => 'AppSamurai/CryptBase64'
 };
 
 # Wacky setup with imaginary Thinger::Thing::File storage module
 # and very real Apache::AppSamurai::Session::Serialize::CryptBase64
 # serializer.  (This shows the alternate module syntaxes.)

 tie %hash 'Apache::AppSamurai::Session', $id, {
    Store     => 'Thinger::Thing::File',
    Lock      => 'Null',
    Generate  => 'Ranom::Garbage',
    Serialize => 'AppSamurai/CryptBase64'
 };

 # you decide!

=head1 DESCRIPTION

This module is a overload of Apache::Session which allows you to specify the
backing store, locking scheme, ID generator, and data serializer at runtime.
You do this by passing arguments in the usual Apache::Session style (see
SYNOPSIS).  You may use any of the modules included in this distribution, or
a module of your own making.

In addition to the standard Apache::Session setup, this module allows for