A Session is a long-lasting relationship between a client and server or between peers. Within a session the two parties may exchange messages and the history of that exchange may create session state. Maintaining session state is considered architecturally expensive because it consumes resources and it binds a client to a specific server reducing the ability of a system to scale. In contrast, the REST architectural style moves all state to the client and with each request, the client transfers all necessary state for the execution of the request. Despite its cost, there are situations when the best architectural decision is to maintain session state.

NetKernel provides services to capture and maintain session state in the ext_session module. The ext-session module provides a session management framework that provides the illusion of a stateful relationship on top of an inherently stateless system. The ext-session module has two parts, the session mapper and the session manager. The session mapper uses a cookie mechanism (similar to the capability provided by the J2EE Servlet Session context).

Services

The ext-session module provides the session: scheme which supports an independent address space. All URI addresses in the session: address space have the form session:{GUID} where GUID is an Globally Unique Identifier encoded as a string such as AB134534652AF56321545.

In NetKernel session management the session GUID is the cookie. When information is stored to, delete or retrieved from the session: address space it is always identified with the GUID. With the GUID state is stored within and retrieved from the session: address space.

For example to store information about a customer in a session the following URI can be used: session:AB134534652AF56321545+customer@customer-resource With this URI the normal request verbs can be used: SOURCE, SINK, NEW, EXISTS and DELETE.

Creating a session

New sessions are created by issuing a NEW resource request to the session scheme. In DPML use new to issue such a request.

When passed the null value the NEW request to session: returns a new GUID value. In this DPML example the new GUID value is stored in the local variable var:session.

Creating a session in NKF

When using the NKF API issue a NEW request through the context object.

String mysession = context.requestNew("session:null", null);

In this example, the variable mysession will be set to a URI identifying the new session address space.

Storing a session resource

Once a session is created with its associated GUID, a compound key is used to identify specific information stored in the space using the general form:

where key@resource is a URI argument identifying a resource within the specific session identified by the specific GUID value.

Session resource URI's can be constructed with a custom accessor or with the provided buildSessionResourceURI accessor. The following DPML code

will store the URI session:AB134534652AF56321545+key@myresource in the variable var:mySessionResourceURI.

NKF

With NKF the tools are available to create the key'ed session URI request directly - see the next sections.

Using a session resource

After establishing the session GUID and creating a compound key for a specific resource, using the session: address space is easy and straightforward. The only trick in DPML is to use indirection with the curi accessor. curi causes an operation to use the associated value as an indirect address. For example, this DPML code will store the XML fragment into the location stored in var:mySessionResourceURI instead of storing in the variable itself.

Retrieval of information using indrection is also straight forward:

Sourcing and Sinking to a Session with NKF

To sink a resource to a session using NKF use code such as this:

//Sink aResource to our session with key 'myresource'
context.sinkAspect(mysession.getURI().toString()+"+key@myresource", aResource);

To source a resource from a session using NKF use code such as this:

//Source the resource representation for our session with key 'myresource'
res=context.source(mysession.getURI().toString()+"+key@myresource");

Deleting a session

Session resources use up available system resources. Its generally good practice to clean up unused session resources when they are no longer needed.

To delete a resource in a session using NKF use code such as this:

//Delete the 'myresource' from the session.
res=context.delete(mysession.getURI().toString()+"+key@myresource");

The whole session can be deleted in a single request by not specifying the key argument.

//Delete the 'myresource' from the session.
res=context.delete(mysession.getURI().toString());

Deleting with DPML

Deleting session from DPML is done like this. Where var:mySessionResourceURI contains a canonical URI for the session resource.

Summary

The ext-session module creates and supports the session: address space. In this address space, session contexts can be created with associated GUIDs. Individual resource can be associated with a session by building a compound key. Resources are then stored and retrieved in the session: address space through indirection.

The session mechanism is transport independent and may be used to create email or web-service session as easily as a web-site session. Next we'll discuss automatic session affinity with the HTTP transport.