Free poe session gladexml2 software for linux

POE::Session is a Perl module for event driven abstract state machine.

SYNOPSIS

# Import POE::Session constants.
use POE::Session;

POE::Session->create(

# Inline or coderef states.
inline_states => {
state_one => &coderef_one,
state_two => sub { ... },
},

# Plain and mapped object states.
object_states => [
$object_one => [ state_three, state_four, state_five ],
$object_two => { state_nine => method_nine },
],

# Plain and mapped package states.
package_states => [
$package_one => [ state_six, state_seven, state_eight ],
$package_two => { state_ten => method_ten },
],

# Parameters for the sessions _start state.
args => [ argument_zero, argument_one, ... ],

# Initial options. See the option() method.
options => %options,

# Change the sessions heap representation.
heap => [ ],
);
Other methods:
# Retrieve a sessions unique identifier.
$session_id = $session->ID;

# Retrieve a reference to the sessions heap.
$session_heap = $session->get_heap();

# Set or clear session options.
$session->option( trace => 1, default => 1 );
$session->option( trace );

# Create a postback, then invoke it and pass back additional
# information.
$postback_coderef = $session->postback( $state_name, @state_args );
$postback_coderef->( @additional_args );

# Or do the same thing synchronously
$callback_coderef = $session->callback( $state_name, @state_args );
$retval = $callback_coderef->( @additional_args );

POE::Session combines a runtime context with an event driven state machine. Together they implement a simple cooperatively timesliced thread.
Sessions receive their timeslices as events from POE::Kernel. Each event has two fields, a state name and a session identifier. These fields describe the code to run and the context to run it in, respectively.

Events carry several other fields which will be discussed in the "Predefined Event Fields" section.

States are re-entrant since they are invoked with their runtime contexts. Although its not usually necessary, this re-entrancy allows a single function to be bound to several different sessions, under several different state names.
As sessions run, they post new events through the Kernel. These events may be for themselves or other sessions, in which case they act as a form of inter-session communications. The Kernel can also generate events based on external conditions such as file activity or the passage of time.

POE provides some convenient built-in states with special meanings. They will be covered later on in the "Predefined States" section.

PHP::Session is a Perl module to read / write PHP session files.

SYNOPSIS

use PHP::Session;

my $session = PHP::Session->new($id);

# session id
my $id = $session->id;

# get/set session data
my $foo = $session->get(foo);
$session->set(bar => $bar);

# remove session data
$session->unregister(foo);

# remove all session data
$session->unset;

# check if data is registered
$session->is_registered(bar);

# save session data
$session->save;

# destroy session
$session->destroy;

# create session file, if not existent
$session = PHP::Session->new($new_sid, { create => 1 });

PHP::Session provides a way to read / write PHP4 session files, with which you can make your Perl application session shared with PHP4.

If you like Apache::Session interface for session management, there is a glue for Apache::Session of this module, Apache::Session::PHP.

POE::Session::Cascading is a Perl module with stack-like POE sessions.

SYNOPSIS

POE::Session::Cascading->new(
name => foo,
events => [
state1 => &state1,
state2 => &state2,
],
);

sub state1 {
my %args = @_;
$args{KERNEL}->post(somewhere,somestate);
# [ snip ]

}

sub state2 {
my %args = @_;
# [ snip ]

$args{SESSION}->stop;
}

POE::Session::Cascading provides a stack-like session for POE. Another way of saying it is that a Cascading session is like a big switch statement. In the above example, when state1 is called in session foo, &state1 gets executed. When it finishes, state2 gets fired and &state2 gets executed. If state2 is called in session foo, only state2 will get executed.

Session Directory Tool provides a multicast session directory manager.
SDR is a session directory tool designed to allow the advertisement and joining of multicast conferences on the Mbone. It was originally modelled on sd written by Van Jacobson at LBNL, but implements a later version of the session description protocol than sd does.
SDR was originally written under the MICE and MERCI projects at UCL by Mark Handley who now works for ISI. SDR will continue to be maintained on a limited basis as part of the infrastructure for conferencing on the CAIRN testbed network and the EC MECCANO project.
Many many fixes and improvements to SDR have been contributed by Bill Fenner and Van Jacobson. Security features were implemented by Edmund Whelan and Goli Montasser-Kohsari at UCL.
Enhancements:
- new application media type for session directories
- fixed byte ordering of headers on intel machines
- fixed IP6 address allocation for unix IP6 stacks
- Authentication and encryption code fixed to allow for extra space for IPv6 addresses
- Added IPv6 flags to configure scripts "--enable-ipv6"

PHP Sessions Management Class is a php class to handle sessions by using a mySQL database for session related data storage providing better security then the default session handler used by PHP.
If you are not familiar with what php sessions are and what are they good for, check out the dedicated chapter in the php manual
If you are familiar with php sessions and you want to use this php class in your projects then remember that to prevent session hijacking, you must not forget to use the regenerate_id() method whenever you do a privilege change in your application
Before usage, make sure you use the session_data.sql file (which is a sql dump file generated with phpMyAdmin) from the install_sql folder to set up the table used by the class
You dont need to modify anything in your previous applications: after instantiating the php class, just use sessions as you would normally.
Note:
The class assumes that there is an active connection to a mySQL database and it does not attempt to create one. This is due to the fact that, usually, there is a config file that holds the database connection related information and another class, or function that handles database connection. If this is not how you do it, you can easily adapt the code by putting the database connection related code in the "open" method of the class.
Enhancements:
- The get_users_online() method is now more accurate as it now runs the garbage collector before getting the number of online users.
- The structure of the MySQL table used by the class was tweaked in so that the "http_user_agent" field was changed from VARCHAR(255) to TEXT to accomodate user agent strings that are longer than 255 characters.
- The "session_data" field was also changed from TEXT to BLOB to help users who store a large amount of data in sessions.

gnome-session package is free software and is part of the GNOME project.
Contained here are
- the GNOME session manager
- the GNOME session manager configuration program
- and several other session management related utilities.

Sessinfo is a Gnome Session Information Display.

This is a Gnome application thats intended to be a semi-graphical equivalent of the messages that you normally get with a command-line login session.

So far, its not very graphical. Future versions might include such things as a graphical banner and graphical panes.