Apache-Session-Wrapper
view release on metacpan or search on metacpan
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
{
my $jar = Apache2::Cookie::Jar->new( @{ $self->{fetch_cookie_args} } );
my $c = $jar->cookies( $self->{cookie_name} );
return $c->value if $c;
}
else
{
my %c = $self->{cookie_class}->fetch( @{ $self->{fetch_cookie_args} } );
return $c{ $self->{cookie_name} }->value
if exists $c{ $self->{cookie_name} };
}
return undef;
}
sub _try_session_id
{
my $self = shift;
my $session_id = shift;
return 1 if ( $self->{session} &&
defined $session_id &&
$self->{session_id} eq $session_id );
my %s;
{
local $SIG{__DIE__};
eval
{
tie %s, "Apache::Session::$self->{session_class_piece}",
$session_id, $self->{params};
};
if ( $@ || ! tied %s || ! $s{_session_id} )
{
$self->_handle_tie_error( $@, $session_id );
return;
}
}
untie %{ $self->{session} } if $self->{session};
$self->{session} = \%s;
$self->{session_id} = $s{_session_id};
$self->{cookie_is_baked} = 0;
return 1;
}
sub _handle_tie_error
{
my $self = shift;
my $err = shift;
my $session_id = shift;
if ( $err =~ /Object does not exist/ && defined $session_id )
{
return if $self->{allow_invalid_id};
Apache::Session::Wrapper::Exception::NonExistentSessionID->throw
( error => "Invalid session id: $session_id",
session_id => $session_id );
}
else
{
my $error =
$err ? $err : "Tying to Apache::Session::$self->{session_class_piece} failed but did not throw an exception";
die $error;
}
}
sub _bake_cookie
{
my $self = shift;
my $expires = shift || $self->{cookie_expires};
$expires = undef if defined $expires && $expires =~ /^session$/i;
my $domain = $self->{cookie_domain};
my $cookie =
$self->{cookie_class}->new
( @{ $self->{new_cookie_args} },
-name => $self->{cookie_name},
# Apache2::Cookie will return undef if we pass undef for
# -value.
-value => ( $self->{session_id} || '' ),
( defined $expires
? ( -expires => $expires )
: ()
),
( defined $domain
? ( -domain => $domain )
: ()
),
-path => $self->{cookie_path},
-secure => $self->{cookie_secure},
);
# If not running under mod_perl, CGI::Cookie->bake() will call
# print() to send a cookie header right now, which may not be what
# the user wants.
if ( $cookie->can('bake') && ! $cookie->isa('CGI::Cookie') )
{
$cookie->bake( @{ $self->{bake_cookie_args} } );
}
else
{
my $header_object = $self->{header_object};
for my $meth (@HeaderMethods)
{
if ( $header_object->can($meth) )
{
$header_object->$meth->add( 'Set-Cookie' => $cookie );
last;
}
}
}
# always set this even if we skipped actually setting the cookie
# to avoid resending it. this keeps us from entering this method
# over and over
$self->{cookie_is_baked} = 1
unless $self->{cookie_resend};
}
sub session
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
{
$self->{session}{___force_a_write___} = 0;
}
else
{
$self->{session}{___force_a_write___} = 1;
}
}
undef $self->{session};
}
sub DESTROY { $_[0]->cleanup_session }
1;
__END__
=head1 NAME
Apache::Session::Wrapper - A simple wrapper around Apache::Session
=head1 SYNOPSIS
my $wrapper =
Apache::Session::Wrapper->new( class => 'MySQL',
handle => $dbh,
cookie_name => 'example-dot-com-cookie',
);
# will get an existing session from a cookie, or create a new session
# and cookie if needed
$wrapper->session->{foo} = 1;
=head1 DESCRIPTION
This module is a simple wrapper around Apache::Session which provides
some methods to simplify getting and setting the session id.
It can uses cookies to store the session id, or it can look in a
provided object for a specific parameter. Alternately, you can simply
provide the session id yourself in the call to the C<session()>
method.
If you're using Mason, you should probably take a look at
C<MasonX::Request::WithApacheSession> first, which integrates this
module directly into Mason.
=head1 METHODS
This class provides the following public methods:
=over 4
=item * new
This method creates a new C<Apache::Session::Wrapper> object.
If the parameters you provide are not correct (wrong type, missing
parameters, etc.), this method throws an
C<Apache::Session::Wrapper::Exception::Params> exception. You can
treat this exception as a string if you want.
=item * session
This method returns a hash tied to the C<Apache::Session> class.
This method accepts an optional "session_id" parameter.
=item * delete_session
This method deletes the existing session from persistent storage. If
you are using the built-in cookie handling, it also deletes the cookie
in the browser.
=back
=head1 CONFIGURATION
This module accepts quite a number of parameters, most of which are
simply passed through to C<Apache::Session>. For this reason, you are
advised to familiarize yourself with the C<Apache::Session>
documentation before attempting to configure this module.
You can also register C<Apache::Session> classes, or the classes used
for doing the work in C<Apache::Session::Flex>. See L<REGISTERING
CLASSES> for details.
=head2 Supported Classes
The following classes are already supported and do not require
registration:
=over 4
=item * Apache::Session::MySQL
=item * Apache::Session::Postgres
=item * Apache::Session::Oracle
=item * Apache::Session::Informix
=item * Apache::Session::Sybase
=item * Apache::Session::File
=item * Apache::Session::DB_File
=item * Apache::Session::PHP
=item * Apache::Session::Flex
=back
The following classes can be used with C<Apache::Session::Flex>:
=over 4
=item * Apache::Session::Store::MySQL
lib/Apache/Session/Wrapper.pm view on Meta::CPAN
=item * Apache::Session::Store::Oracle
=item * Apache::Session::Store::Sybase
=item * Apache::Session::Store::File
=item * Apache::Session::Store::DB_File
=item * Apache::Session::Store::PHP
=item * Apache::Session::Lock::MySQL
=item * Apache::Session::Lock::File
=item * Apache::Session::Lock::Null
=item * Apache::Session::Lock::Semaphore
=item * Apache::Session::Generate::MD5
=item * Apache::Session::Generate::ModUsertrack
=item * Apache::Session::Serialize::Storable
=item * Apache::Session::Serialize::Base64
=item * Apache::Session::Serialize::Sybase
=item * Apache::Session::Serialize::UUEncode
=item * Apache::Session::Serialize::PHP
=back
=head2 Generic Parameters
=over 4
=item * class => class name
The name of the C<Apache::Session> subclass you would like to use.
This module will load this class for you if necessary.
This parameter is required.
=item * always_write => boolean
If this is true, then this module will ensure that C<Apache::Session>
writes the session. If it is false, the default C<Apache::Session>
behavior is used instead.
This defaults to true.
=item * allow_invalid_id => boolean
If this is true, an attempt to create a session with a session id that
does not exist in the session storage will be ignored, and a new
session will be created instead. If it is false, a
C<Apache::Session::Wrapper::Exception::NonExistentSessionID> exception
will be thrown instead.
This defaults to true.
=item * session_id => string
Try this session id first and use it if it exist. If the session does
not exist, it will ignore this parameter and make a new session.
=back
=head2 Cookie-Related Parameters
=over 4
=item * use_cookie => boolean
If true, then this module will use one of C<Apache::Cookie>,
C<Apache2::Cookie> or C<CGI::Cookie> (as appropriate) to set and read
cookies that contain the session id.
=item * cookie_name => name
This is the name of the cookie that this module will set. This
defaults to "Apache-Session-Wrapper-cookie".
Corresponds to the C<Apache::Cookie> "-name" constructor parameter.
=item * cookie_expires => expiration
How long before the cookie expires. This defaults to 1 day, "+1d".
Corresponds to the "-expires" parameter.
As a special case, you can set this value to "session" to have the
"-expires" parameter set to undef, which gives you a cookie that
expires at the end of the session.
=item * cookie_domain => domain
This corresponds to the "-domain" parameter. If not given this will
not be set as part of the cookie.
If it is undefined, then no "-domain" parameter will be given.
=item * cookie_path => path
Corresponds to the "-path" parameter. It defaults to "/".
=item * cookie_secure => boolean
Corresponds to the "-secure" parameter. It defaults to false.
=item * cookie_resend => boolean
By default, this parameter is true, and the cookie will be sent for
I<every request>. If it is false, then the cookie will only be sent
when the session is I<created>. This is important as resending the
cookie has the effect of updating the expiration time.
=item * header_object => object
When running outside of mod_perl, you must provide an object to which
( run in 1.457 second using v1.01-cache-2.11-cpan-cdf2f3d4e48 )