private support for your internal/customer projects ... custom extensions and distributions ... versioned snapshots for indefinite support ... scalability guidance for your apps and Ajax/Comet projects ... development services from 1 day to full product delivery
Jetty can support session clustering by persisting sessions to a shared database. Each Jetty instance locally caches sessions for which it has received requests, writing any changes to the session through to the database as the request exits the server. Sessions must obey the Serialization contract, and servlets must call the Session.setAttribute() method to ensure that changes are persisted.
The persistent session mechanism works in conjunction with a load balancer that supports stickiness. Stickiness can be based on various data items, such as source IP address or characteristics of the session ID or a load-balancer specific mechanism. For those load balancers that examine the session ID, the Jetty persistent session mechanism appends a node ID to the session ID, which can be used for routing.
In this type of solution, the database can become both a bottleneck and a single point of failure. Jetty takes steps to reduce the load on the database (discussed below), but in a heavily loaded environment you might need to investigate other optimization strategies such as local caching and database replication. You should also consult your database vendor's documentation for information on how to ensure high availability and failover of your database.
There are two components to session management in Jetty: a session ID manager and a session manager.
The session ID manager ensures that session IDs are unique across all webapps hosted on a Jetty instance, and thus there can only be one session ID manager per Jetty instance.
The session manager handles the session lifecycle (create/update/invalidate/expire) on behalf of a web application, so there is one session manager per web application instance.
These managers also cooperate and collaborate with the
org.eclipse.jetty.server.session.SessionHandler to enable
You need to configure an
instance, either in embedded code or in a
file. Here is an example of a jetty.xml setup:
Notice that the JDBCSessionIdManager needs access to a database. The
jetty.xml above configures it with the name of a
javax.sql.DataSource that is defined elsewhere. Consult Jetty
Naming Resources for more information on how to configure database access
with Jetty. If you don't want to use a DataSource, you can configure JDBC
Driver information instead. Here's an example:
As Jetty configuration files are direct mappings of XML to Java, it is straightforward to see how to do this in code, but here's an example anyway:
You must configure the JDBCSessionIdManager with a workerName that is unique across the cluster. Typically the name relates to the physical node on which the instance is executing. If this name is not unique, your load balancer might fail to distribute your sessions correctly.
You can also configure how often the persistent session mechanism sweeps the database looking for old, expired sessions with the scavengeInterval setting. The default value is 10mins. We recommend that you not increase the frequency because doing so increases the load on the database with very little gain; old, expired sessions can harmlessly sit in the database.
The way you configure a JDBCSessionManager depends on whether you're
configuring from a context xml file or a
jetty-web.xml file or code. The basic difference is
how you get a reference to the Jetty
From a context xml file, you reference the Server instance as a Ref:
WEB-INF/jetty-web.xml file, you can
reference the Server instance directly:
If you're embedding this in code: