Package org.eclipse.jetty.server.session

Class AbstractSessionCache

java.lang.Object

org.eclipse.jetty.util.component.AbstractLifeCycle

org.eclipse.jetty.util.component.ContainerLifeCycle

org.eclipse.jetty.server.session.AbstractSessionCache

All Implemented Interfaces:

SessionCache, Container, Destroyable, Dumpable, Dumpable.DumpableContainer, LifeCycle

Direct Known Subclasses:

DefaultSessionCache, NullSessionCache

@ManagedObject
public abstract class AbstractSessionCache
extends ContainerLifeCycle
implements SessionCache

AbstractSessionCache A base implementation of the SessionCache interface for managing a set of Session objects pertaining to a context in memory. This implementation ensures that multiple requests for the same session id always return the same Session object. It will delay writing out a session to the SessionDataStore until the last request exits the session. If the SessionDataStore supports passivation then the session passivation and activation listeners are called appropriately as the session is written. This implementation also supports evicting idle Session objects. An idle Session is one that is still valid, has not expired, but has not been accessed by a request for a configurable amount of time. An idle session will be first passivated before it is evicted from the cache.

Nested Class Summary

Nested classes/interfaces inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

AbstractLifeCycle.AbstractLifeCycleListener, AbstractLifeCycle.StopException

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Container

Container.InheritedListener, Container.Listener

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.Dumpable

Dumpable.DumpableContainer

Nested classes/interfaces inherited from interface org.eclipse.jetty.util.component.LifeCycle

LifeCycle.Listener

Field Summary

Fields

Modifier and Type	Field	Description
protected SessionContext	_context	Information about the context to which this SessionCache pertains
protected int	_evictionPolicy	When, if ever, to evict sessions: never; only when the last request for them finishes; after inactivity time (expressed as secs)
protected boolean	_flushOnResponseCommit	If true, when a response is about to be committed back to the client, a dirty session will be flushed to the session store.
protected final SessionHandler	_handler	The SessionHandler related to this SessionCache
protected boolean	_invalidateOnShutdown	If true, when the server shuts down, all sessions in the cache will be invalidated before being removed.
protected boolean	_removeUnloadableSessions	If true, a Session whose data cannot be read will be deleted from the SessionDataStore.
protected boolean	_saveOnCreate	If true, as soon as a new session is created, it will be persisted to the SessionDataStore
protected boolean	_saveOnInactiveEviction	If true, a session that will be evicted from the cache because it has been inactive too long will be saved before being evicted.
protected SessionDataStore	_sessionDataStore	The authoritative source of session data

Fields inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

FAILED, STARTED, STARTING, STOPPED, STOPPING

Fields inherited from interface org.eclipse.jetty.util.component.Dumpable

KEY

Fields inherited from interface org.eclipse.jetty.server.session.SessionCache

EVICT_ON_INACTIVITY, EVICT_ON_SESSION_EXIT, NEVER_EVICT

Constructor Summary

Constructors

Constructor	Description
AbstractSessionCache(SessionHandler handler)

Method Summary

Modifier and Type	Method	Description
void	add(String id, Session session)	Add an entirely new session (created by the application calling Request.getSession(true)) to the cache.
Set<String>	checkExpiration(Set<String> candidates)	Check a list of session ids that belong to potentially expired sessions.
void	checkInactiveSession(Session session)	Check a session for being inactive and thus being able to be evicted, if eviction is enabled.
void	commit(Session session)	A response that has accessed this session is about to be returned to the client.
boolean	contains(String id)	Check to see if this cache contains an entry for the session corresponding to the session id.
Session	delete(String id)	Remove a session object from this store and from any backing store.
protected abstract Session	doComputeIfAbsent(String id, Function<String,Session> mappingFunction)	Compute the mappingFunction to create a Session object iff the session with the given id isn't already in the map, otherwise return the existing Session.
abstract Session	doDelete(String id)	Remove the session with this identity from the store
protected abstract Session	doGet(String id)	Get the session matching the key from the cache.
protected abstract Session	doPutIfAbsent(String id, Session session)	Put the session into the map if it wasn't already there
protected abstract boolean	doReplace(String id, Session oldValue, Session newValue)	Replace the mapping from id to oldValue with newValue
protected void	doStart()	Starts the managed lifecycle beans in the order they were added.
protected void	doStop()	Stops the managed lifecycle beans in the reverse order they were added.
boolean	exists(String id)	Check to see if a session corresponding to the id exists.
Session	get(String id)	Get a session object.
protected Session	getAndEnter(String id, boolean enter)	Get a session object.
int	getEvictionPolicy()
SessionDataStore	getSessionDataStore()
SessionHandler	getSessionHandler()
void	initialize(SessionContext context)
boolean	isFlushOnResponseCommit()
boolean	isInvalidateOnShutdown()
boolean	isRemoveUnloadableSessions()
boolean	isSaveOnCreate()
boolean	isSaveOnInactiveEviction()	Whether we should save a session that has been inactive before we boot it from the cache.
Session	newSession(jakarta.servlet.http.HttpServletRequest request, String id, long time, long maxInactiveMs)	Create an entirely new Session.
abstract Session	newSession(jakarta.servlet.http.HttpServletRequest request, SessionData data)	Create a new Session for a request.
abstract Session	newSession(SessionData data)	Create a new Session object from pre-existing session data
void	put(String id, Session session)	Deprecated. use release(String, Session) instead
void	release(String id, Session session)	Finish using the Session object.
Session	renewSessionId(String oldId, String newId, String oldExtendedId, String newExtendedId)	Change the id of a Session.
protected void	renewSessionId(Session session, String newId, String newExtendedId)	Swap the id on a session.
void	setEvictionPolicy(int evictionTimeout)	-1 means we never evict inactive sessions.
void	setFlushOnResponseCommit(boolean flushOnResponseCommit)	If true, a dirty session will be written to the SessionDataStore just before a response is returned to the client.
void	setInvalidateOnShutdown(boolean invalidateOnShutdown)	If true, all existing sessions in the cache will be invalidated when the server shuts down.
void	setRemoveUnloadableSessions(boolean removeUnloadableSessions)	If a session's data cannot be loaded from the store without error, remove it from the persistent store.
void	setSaveOnCreate(boolean saveOnCreate)	Whether or not a session that is newly created should be immediately saved.
void	setSaveOnInactiveEviction(boolean saveOnEvict)	Whether or not a a session that is about to be evicted should be saved before being evicted.
void	setSessionDataStore(SessionDataStore sessionStore)	A SessionDataStore that is the authoritative source of session information.
String	toString()

Methods inherited from class org.eclipse.jetty.util.component.ContainerLifeCycle

addBean, addBean, addEventListener, addManaged, contains, destroy, dump, dump, dump, dumpObjects, dumpStdErr, getBean, getBeans, getBeans, getContainedBeans, getContainedBeans, isAuto, isManaged, isUnmanaged, manage, removeBean, removeBeans, removeEventListener, setBeans, start, stop, unmanage, updateBean, updateBean, updateBeans, updateBeans

Methods inherited from class org.eclipse.jetty.util.component.AbstractLifeCycle

getEventListeners, getState, getState, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, setEventListeners, start, stop

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.eclipse.jetty.util.component.Container

getCachedBeans, getEventListeners

Methods inherited from interface org.eclipse.jetty.util.component.Dumpable

dumpSelf

Methods inherited from interface org.eclipse.jetty.util.component.Dumpable.DumpableContainer

isDumpable

Methods inherited from interface org.eclipse.jetty.util.component.LifeCycle

addEventListener, isFailed, isRunning, isStarted, isStarting, isStopped, isStopping, removeEventListener, start, stop

Methods inherited from interface org.eclipse.jetty.server.session.SessionCache

shutdown

Field Details

_sessionDataStore

protected SessionDataStore _sessionDataStore

The authoritative source of session data

_handler

protected final SessionHandler _handler

The SessionHandler related to this SessionCache

_context

protected SessionContext _context

Information about the context to which this SessionCache pertains

_evictionPolicy

protected int _evictionPolicy

When, if ever, to evict sessions: never; only when the last request for them finishes; after inactivity time (expressed as secs)

_saveOnCreate

protected boolean _saveOnCreate

If true, as soon as a new session is created, it will be persisted to the SessionDataStore

_saveOnInactiveEviction

protected boolean _saveOnInactiveEviction

If true, a session that will be evicted from the cache because it has been inactive too long will be saved before being evicted.

_removeUnloadableSessions

protected boolean _removeUnloadableSessions

If true, a Session whose data cannot be read will be deleted from the SessionDataStore.

_flushOnResponseCommit

protected boolean _flushOnResponseCommit

If true, when a response is about to be committed back to the client, a dirty session will be flushed to the session store.

_invalidateOnShutdown

protected boolean _invalidateOnShutdown

If true, when the server shuts down, all sessions in the cache will be invalidated before being removed.

Constructor Details

AbstractSessionCache

public AbstractSessionCache(SessionHandler handler)

Parameters:

handler - the SessionHandler to use

Method Details

newSession

public abstract Session newSession(SessionData data)

Create a new Session object from pre-existing session data

Specified by:

newSession in interface SessionCache

Parameters:

data - the session data

Returns:

a new Session object

newSession

public abstract Session newSession(jakarta.servlet.http.HttpServletRequest request,
 SessionData data)

Create a new Session for a request.

Parameters:

request - the request

data - the session data

Returns:

the new session

doGet

protected abstract Session doGet(String id)

Get the session matching the key from the cache. Does not load the session.

Parameters:

id - session id

Returns:

the Session object matching the id

doPutIfAbsent

protected abstract Session doPutIfAbsent(String id,
 Session session)

Put the session into the map if it wasn't already there

Parameters:

id - the identity of the session

session - the session object

Returns:

null if the session wasn't already in the map, or the existing entry otherwise

doComputeIfAbsent

protected abstract Session doComputeIfAbsent(String id,
 Function<String,Session> mappingFunction)

Compute the mappingFunction to create a Session object iff the session with the given id isn't already in the map, otherwise return the existing Session. This method is expected to have precisely the same behaviour as ConcurrentHashMap.computeIfAbsent(K, java.util.function.Function<? super K, ? extends V>)

Parameters:

id - the session id

mappingFunction - the function to load the data for the session

Returns:

an existing Session from the cache

doReplace

protected abstract boolean doReplace(String id,
 Session oldValue,
 Session newValue)

Replace the mapping from id to oldValue with newValue

Parameters:

id - the id

oldValue - the old value

newValue - the new value

Returns:

true if replacement was done

doDelete

public abstract Session doDelete(String id)

Remove the session with this identity from the store

Parameters:

id - the id

Returns:

Session that was removed or null

getSessionHandler

public SessionHandler getSessionHandler()

Specified by:

getSessionHandler in interface SessionCache

Returns:

the SessionManger

initialize

public void initialize(SessionContext context)

Specified by:

initialize in interface SessionCache

Parameters:

context - the SessionContext to use for this cache

doStart

protected void doStart()
                throws Exception

Description copied from class: ContainerLifeCycle

Starts the managed lifecycle beans in the order they were added.

Overrides:

doStart in class ContainerLifeCycle

Throws:

Exception - If there was a problem starting. Will cause a transition to FAILED state

doStop

protected void doStop()
               throws Exception

Description copied from class: ContainerLifeCycle

Stops the managed lifecycle beans in the reverse order they were added.

Overrides:

doStop in class ContainerLifeCycle

Throws:

Exception - If there was a problem stopping. Will cause a transition to FAILED state

getSessionDataStore

public SessionDataStore getSessionDataStore()

Specified by:

getSessionDataStore in interface SessionCache

Returns:

the SessionDataStore or null if there isn't one

setSessionDataStore

public void setSessionDataStore(SessionDataStore sessionStore)

Description copied from interface: SessionCache

A SessionDataStore that is the authoritative source of session information.

Specified by:

setSessionDataStore in interface SessionCache

Parameters:

sessionStore - the SessionDataStore to use

getEvictionPolicy

@ManagedAttribute(value="session eviction policy",
                  readonly=true)
public int getEvictionPolicy()

Specified by:

getEvictionPolicy in interface SessionCache

Returns:

the eviction policy

See Also:

• SessionCache.getEvictionPolicy()

setEvictionPolicy

public void setEvictionPolicy(int evictionTimeout)

-1 means we never evict inactive sessions. 0 means we evict a session after the last request for it exits >0 is the number of seconds after which we evict inactive sessions from the cache

Specified by:

setEvictionPolicy in interface SessionCache

Parameters:

evictionTimeout - -1 is never evict; 0 is evict-on-exit; and any other positive value is the time in seconds that a session can be idle before it can be evicted.

See Also:

• SessionCache.setEvictionPolicy(int)

isSaveOnCreate

@ManagedAttribute(value="immediately save new sessions",
                  readonly=true)
public boolean isSaveOnCreate()

Specified by:

isSaveOnCreate in interface SessionCache

Returns:

if true the newly created session will be saved immediately

setSaveOnCreate

public void setSaveOnCreate(boolean saveOnCreate)

Description copied from interface: SessionCache

Whether or not a session that is newly created should be immediately saved. If false, a session that is created and invalidated within a single request is never persisted.

Specified by:

setSaveOnCreate in interface SessionCache

Parameters:

saveOnCreate - true to immediately save the newly created session

isRemoveUnloadableSessions

@ManagedAttribute(value="delete unreadable stored sessions",
                  readonly=true)
public boolean isRemoveUnloadableSessions()

Specified by:

isRemoveUnloadableSessions in interface SessionCache

Returns:

true if sessions that can't be loaded are deleted from the store

setRemoveUnloadableSessions

public void setRemoveUnloadableSessions(boolean removeUnloadableSessions)

If a session's data cannot be loaded from the store without error, remove it from the persistent store.

Specified by:

setRemoveUnloadableSessions in interface SessionCache

Parameters:

removeUnloadableSessions - if true unloadable sessions will be removed from session store

setFlushOnResponseCommit

public void setFlushOnResponseCommit(boolean flushOnResponseCommit)

Description copied from interface: SessionCache

If true, a dirty session will be written to the SessionDataStore just before a response is returned to the client. This ensures that subsequent requests to either the same node or a different node see the changed session data.

Specified by:

setFlushOnResponseCommit in interface SessionCache

isFlushOnResponseCommit

public boolean isFlushOnResponseCommit()

Specified by:

isFlushOnResponseCommit in interface SessionCache

Returns:

true if dirty sessions should be written before the response is committed.

get

public Session get(String id)
            throws Exception

Get a session object. If the session object is not in this session store, try getting the data for it from a SessionDataStore associated with the session manager. The usage count of the session is incremented.

Specified by:

get in interface SessionCache

Parameters:

id - the session id

Returns:

the Session if one exists, null otherwise

Throws:

Exception - if any error occurred

See Also:

• SessionCache.get(java.lang.String)

getAndEnter

protected Session getAndEnter(String id,
 boolean enter)
                       throws Exception

Get a session object. If the session object is not in this session store, try getting the data for it from a SessionDataStore associated with the session manager.

Parameters:

id - The session to retrieve

enter - if true, the usage count of the session will be incremented

Returns:

the session if it exists, null otherwise

Throws:

Exception - if the session cannot be loaded

add

public void add(String id,
 Session session)
         throws Exception

Add an entirely new session (created by the application calling Request.getSession(true)) to the cache. The usage count of the fresh session is incremented.

Specified by:

add in interface SessionCache

Parameters:

id - the id

session -

Throws:

Exception

commit

public void commit(Session session)
            throws Exception

A response that has accessed this session is about to be returned to the client. Pass the session to the store to persist, so that any changes will be visible to subsequent requests on the same node (if using NullSessionCache), or on other nodes.

Specified by:

commit in interface SessionCache

Throws:

Exception

put

@Deprecated
public void put(String id,
 Session session)
         throws Exception

Deprecated.

use release(String, Session) instead

Description copied from interface: SessionCache

Finish using a Session. This is called by the SessionHandler once a request is finished with a Session. SessionCache implementations may want to delay writing out Session contents until the last request exits a Session.

Specified by:

put in interface SessionCache

Parameters:

id - the session id

session - the current session object

Throws:

Exception - if any error occurred

release

public void release(String id,
 Session session)
             throws Exception

Finish using the Session object. This should be called when a request exists the session. Only when the last simultaneous request exists the session will any action be taken. If there is a SessionDataStore write the session data through to it. If the SessionDataStore supports passivation, call the passivate/active listeners. If the evictionPolicy == SessionCache.EVICT_ON_SESSION_EXIT then after we have saved the session, we evict it from the cache.

Specified by:

release in interface SessionCache

Parameters:

id - the session id

session - the current session object

Throws:

Exception - if any error occurred

See Also:

• SessionCache.release(java.lang.String, org.eclipse.jetty.server.session.Session)

exists

public boolean exists(String id)
               throws Exception

Check to see if a session corresponding to the id exists. This method will first check with the object store. If it doesn't exist in the object store (might be passivated etc), it will check with the data store.

Specified by:

exists in interface SessionCache

Parameters:

id - the session id

Returns:

true if the session exists, false otherwise

Throws:

Exception - the Exception

See Also:

• SessionCache.exists(java.lang.String)

contains

public boolean contains(String id)
                 throws Exception

Check to see if this cache contains an entry for the session corresponding to the session id.

Specified by:

contains in interface SessionCache

Parameters:

id - the session id

Returns:

true if a Session object matching the id is present in the cache, false otherwise

Throws:

Exception - if any error occurred

See Also:

• SessionCache.contains(java.lang.String)

delete

public Session delete(String id)
               throws Exception

Remove a session object from this store and from any backing store.

Specified by:

delete in interface SessionCache

Parameters:

id - the session id

Returns:

the Session that was removed, null otherwise

Throws:

Exception - if any error occurred

See Also:

• SessionCache.delete(java.lang.String)

checkExpiration

public Set<String> checkExpiration(Set<String> candidates)

Description copied from interface: SessionCache

Check a list of session ids that belong to potentially expired sessions. The Session in the cache should be checked, but also the SessionDataStore, as that is the authoritative source of all session information.

Specified by:

checkExpiration in interface SessionCache

Parameters:

candidates - the session ids to check

Returns:

the set of session ids that have actually expired: this can be a superset of the original candidate list.

checkInactiveSession

public void checkInactiveSession(Session session)

Check a session for being inactive and thus being able to be evicted, if eviction is enabled.

Specified by:

checkInactiveSession in interface SessionCache

Parameters:

session - session to check

renewSessionId

public Session renewSessionId(String oldId,
 String newId,
 String oldExtendedId,
 String newExtendedId)
                       throws Exception

Description copied from interface: SessionCache

Change the id of a Session.

Specified by:

renewSessionId in interface SessionCache

Parameters:

oldId - the current session id

newId - the new session id

oldExtendedId - the current extended session id

newExtendedId - the new extended session id

Returns:

the Session after changing its id

Throws:

Exception - if any error occurred

renewSessionId

protected void renewSessionId(Session session,
 String newId,
 String newExtendedId)
                       throws Exception

Swap the id on a session.

Parameters:

session - the session for which to do the swap

newId - the new id

newExtendedId - the full id plus node id

Throws:

Exception - if there was a failure saving the change

setSaveOnInactiveEviction

public void setSaveOnInactiveEviction(boolean saveOnEvict)

Description copied from interface: SessionCache

Whether or not a a session that is about to be evicted should be saved before being evicted.

Specified by:

setSaveOnInactiveEviction in interface SessionCache

Parameters:

saveOnEvict - true if the session should be saved before being evicted

setInvalidateOnShutdown

public void setInvalidateOnShutdown(boolean invalidateOnShutdown)

Description copied from interface: SessionCache

If true, all existing sessions in the cache will be invalidated when the server shuts down. Default is false.

Specified by:

setInvalidateOnShutdown in interface SessionCache

Parameters:

invalidateOnShutdown -

isInvalidateOnShutdown

public boolean isInvalidateOnShutdown()

Specified by:

isInvalidateOnShutdown in interface SessionCache

isSaveOnInactiveEviction

@ManagedAttribute(value="save sessions before evicting from cache",
                  readonly=true)
public boolean isSaveOnInactiveEviction()

Whether we should save a session that has been inactive before we boot it from the cache.

Specified by:

isSaveOnInactiveEviction in interface SessionCache

Returns:

true if an inactive session will be saved before being evicted

newSession

public Session newSession(jakarta.servlet.http.HttpServletRequest request,
 String id,
 long time,
 long maxInactiveMs)

Description copied from interface: SessionCache

Create an entirely new Session.

Specified by:

newSession in interface SessionCache

Parameters:

request - the request

id - the unique id associated to the session

time - the timestamp of the session creation

maxInactiveMs - the max inactive time in milliseconds

Returns:

a new Session

toString

public String toString()

Overrides:

toString in class AbstractLifeCycle