• For single-server configurations
• Useful in development when classes change often

Persistent sessions are configured in the web-app. File-based sessions use file-store

<web-app> <session-config> <file-store>WEB-INF/sessions</file-store> </session-config> </web-app>

Sessions are stored as files in the file-store directory. When the session changes, the updates will be written to the file. After Resin loads an Application, it will load the stored sessions.

In general, file-based persistence is less useful in multi-server environments. Although a network filesystem such as NFS will allow all the servers to access the same filesystem, it's not designed for the fine-grained access. For example, NFS will cache pages. So if one server modifies the page, e.g. a session value, the other servers may not see the change for several seconds.

Load balancing with multiple machines either uses sticky sessions or symmetrical sessions. Sticky sessions put more intelligence on the load balancer, and symmetrical sessions puts more intelligence on the JVMs. The choice of which to use depends on what kind of hardware you have, how many machines you're using and how you use sessions.

Distributed sessions can use a database as a backing store, or they can distribute the backup among all the servers using TCP.

Symmetrical sessions happen with dumb load balancers like DNS round-robin. A single session may bounce from machine A to machine B and back to machine B. The symmetrical session case needs the always-load-session attribute described below. Each request must load the most up-to-date version of the session.

Distributed sessions in a symmetrical environment are required to make sessions work at all. Otherwise the state will end up spread across the JVMs. However, because each request must update its session information, it is less efficient than sticky sessions.

Sticky sessions require more intelligence on the load-balancer, but are easier for the JVM. Once a session starts, the load-balancer will always send it to the same JVM. Resin's load balancing, for example, encodes the session id as 'aaaXXX' and 'baaXXX'. The 'aaa' session will always go to JVM-a and 'baa' will always go to JVM-b.

Distributed sessions with a sticky session environment add reliability. If JVM-a goes down, JVM-b can pick up the session without the user noticing any change. In addition, distributed sticky sessions are more efficient. The distributor only needs to update sessions when they change. So if you update the session once when the user logs in, the distributed sessions can be very efficient.

Database backed sessions are the easiest to understand. Session data gets serialized and stored in a database. The advantage of database-backed sessions is it's simplicity. The disadvantage is that the database is often the performance bottleneck of the system. By adding load to an already-loaded system, you may harm performance. One way around that bottleneck is to use a small, quick database like MySQL for your session store and save the "Big Iron" database like Oracle for your core database needs.

The database must be specified using a resource-ref. The database store will automatically create a session table.

<web-app> <session-config> <jdbc-store>test</jdbc-store> <always-save-session/> </session-config> </web-app>

data-source	data source name for the table
table-name	database table for the session data
blob-type	database type for a blob
timestamp-type	database type for a blob
session-timeout	cleanup time

CREATE TABLE session ( id VARCHAR(64) NOT NULL, data BLOB, mod_time TIMESTAMP, PRIMARY KEY(id) )

Symmetrical sessions must use the 'always-load-session' flag to update each session data on each request. The always-load-session attribute forces sessions to check the store for each request. By default, sessions are only loaded from persistent store when they are created. In a configuration with multiple symmetric web servers, sessions can be loaded on each request to ensure consistency.

By default, Resin only saves session data when you add new values to the session object, i.e. if the request calls setAttribute. This may be insufficient when storing large objects. For example, if you change an internal field of a large object, Resin will not automatically detect that change and will not save the session object.

With always-save-session Resin will always write the session to the store at the end of each request. Although this is less efficient, it guarantees that updates will get stored in the backup after each request.

The configuration is in the web-app

<web-app> <session-config> <tcp-store/> </session-config> </web-app>

The <srun> and <srun-backup> hosts are treated as a ring. Each host will use the following host as a backup. When the session changes, the updates will be sent to the following host. When the host starts, it looks up old sessions in the following host before using its own saved state.

In conjunction with the always-load-session flag, symmetric (non-sticky) load-balanced servers can now use the tcp-ring.

Symmetric load-balanced servers

<http-server> <http id='a' port='80'/> <srun id='a' host='host-a' port='6802'/> <http id='b' port='80'/> <srun id='b' host='host-b' port='6802'/> <host id=''> <web-app id=''> <session-config> <tcp-store/> <always-load-session/> </session-config> </web-app> </host> </http-server>