| Methods Summary |
|---|
| public void | addLifecycleListener(org.apache.catalina.LifecycleListener listener)Add a lifecycle event listener to this component.
lifecycle.addLifecycleListener(listener);
|
| public void | addToInvalidatedSessions(java.lang.String sessionId)Add this Session id to the set of invalidated Session ids for this
Manager.
invalidatedSessions.put(sessionId,
Long.valueOf(System.currentTimeMillis()));
|
| public void | backgroundProcess()Perform the background processes for this Manager
// END SJSAS 6406580
// ------------------------------------------------------------- Properties
this.processExpires();
this.processPersistenceChecks();
// START SJSAS 6406580
this.processInvalidatedSessions();
// END SJSAS 6406580
if ((this.getStore() != null)
&& (this.getStore() instanceof StoreBase)) {
((StoreBase) this.getStore()).processExpires();
}
|
| public void | clearStore()Clear all sessions from the Store.
if (store == null)
return;
try {
if (SecurityUtil.isPackageProtectionEnabled()){
try{
AccessController.doPrivileged(new PrivilegedStoreClear());
}catch(PrivilegedActionException ex){
Exception exception = ex.getException();
log.error("Exception clearing the Store: " + exception);
exception.printStackTrace();
}
} else {
store.clear();
}
} catch (IOException e) {
log.error("Exception clearing the Store: " + e);
e.printStackTrace();
}
|
| public org.apache.catalina.Session | createSession()Return a new session object as long as the number of active
sessions does not exceed maxActiveSessions. If there
aren't too many active sessions, or if there is no limit,
a session is created or retrieved from the recycled pool.
if ((maxActiveSessions >= 0) &&
(sessions.size() >= maxActiveSessions))
throw new IllegalStateException
(sm.getString("standardManager.createSession.ise"));
return (super.createSession());
|
| private org.apache.catalina.Session | doSwapIn(java.lang.String id, java.lang.String version)Look for a session in the Store and, if found, restore
it in the Manager's list of active sessions if appropriate.
The session will be removed from the Store after swapping
in, but will not be added to the active session list if it
is invalid or past its expiration.
if (store == null)
return null;
Session session = null;
try {
if (SecurityUtil.isPackageProtectionEnabled()){
try{
session = (Session) AccessController.doPrivileged(new PrivilegedStoreLoad(id));
}catch(PrivilegedActionException ex){
Exception exception = ex.getException();
log.error("Exception in the Store during swapIn: " + exception);
if (exception instanceof IOException){
throw (IOException)exception;
} else if (exception instanceof ClassNotFoundException) {
throw (ClassNotFoundException)exception;
}
}
} else {
if (version != null) {
session = ((StoreBase) store).load(id, version);
} else {
session = store.load(id);
}
}
} catch (ClassNotFoundException e) {
log.error(sm.getString("persistentManager.deserializeError", id, e));
throw new IllegalStateException
(sm.getString("persistentManager.deserializeError", id, e));
}
if (session == null)
return (null);
if (!session.isValid()) {
log.error("session swapped in is invalid or expired");
//6406580 START
/* - these lines are calling remove on store redundantly
session.expire();
removeSession(id);
*/
//6406580 END
return (null);
}
if(log.isDebugEnabled())
log.debug(sm.getString("persistentManager.swapIn", id));
session.setManager(this);
// make sure the listeners know about it.
((StandardSession)session).tellNew();
add(session);
((StandardSession)session).activate();
return (session);
|
| public org.apache.catalina.LifecycleListener[] | findLifecycleListeners()Get the lifecycle listeners associated with this lifecycle. If this
Lifecycle has no listeners registered, a zero-length array is returned.
return lifecycle.findLifecycleListeners();
|
| public org.apache.catalina.Session | findSession(java.lang.String id)Return the active Session, associated with this Manager, with the
specified session id (if any); otherwise return null.
This method checks the persistence store if persistence is enabled,
otherwise just uses the functionality from ManagerBase.
//6406580 START
if(!this.isSessionIdValid(id)) {
return null;
}
//6406580 END
Session session = super.findSession(id);
if (session != null)
return (session);
// See if the Session is in the Store
session = swapIn(id);
return (session);
|
| public org.apache.catalina.Session | findSession(java.lang.String id, boolean removeCachedCopy)Return the active Session, associated with this Manager, with the
specified session id (if any); otherwise return null.
This method first removes the cached copy if removeCachedCopy = true.
Then this method checks the persistence store if persistence is enabled,
otherwise just uses the functionality from ManagerBase.
Session theSession = super.findSession(id);
if (theSession != null) {
if(removeCachedCopy) {
//remove from manager cache
removeSuper(theSession);
//remove from store cache if it exists
if ((this.getStore() != null)
&& (this.getStore() instanceof StoreBase)) {
((StoreBase) this.getStore()).removeFromStoreCache(id);
}
theSession = null;
} else {
return (theSession);
}
}
//now do full findSession
theSession = findSession(id);
return theSession;
|
| public java.lang.String | getInfo()Return descriptive information about this Manager implementation and
the corresponding version number, in the format
<description>/<version>.
return (this.info);
|
| public int | getMaxActiveSessions()Return the maximum number of active Sessions allowed, or -1 for
no limit.
return (this.maxActiveSessions);
|
| public int | getMaxIdleBackup()Indicates how many seconds old a session can get, after its last
use in a request, before it should be backed up to the store. -1
means sessions are not backed up.
return maxIdleBackup;
|
| public int | getMaxIdleSwap()The time in seconds after which a session should be swapped out of
memory to disk.
return maxIdleSwap;
|
| public int | getMinIdleSwap()The minimum time in seconds that a session must be idle before
it can be swapped out of memory, or -1 if it can be swapped out
at any time.
return minIdleSwap;
|
| public java.lang.String | getMonitorAttributeValues()
//FIXME if desired for monitoring 'file'
return "";
|
| public java.lang.String | getName()Return the descriptive short name of this Manager implementation.
return (name);
|
| public int | getRejectedSessions()Gets the number of sessions that were not created because the maximum
number of active sessions was reached.
return rejectedSessions;
|
| public boolean | getSaveOnRestart()Indicates whether sessions are saved when the Manager is shut down
properly. This requires the unload() method to be called.
return saveOnRestart;
|
| public org.apache.catalina.Store | getStore()Return the Store object which manages persistent Session
storage for this Manager.
return (this.store);
|
| public boolean | isLoaded(java.lang.String id)Return true, if the session id is loaded in memory
otherwise false is returned
try {
if ( super.findSession(id) != null )
return true;
} catch (IOException e) {
log.error("checking isLoaded for id, " + id + ", "+e.getMessage(), e);
}
return false;
|
| public boolean | isSessionIdValid(java.lang.String sessionId)
return (!invalidatedSessions.containsKey(sessionId));
|
| protected boolean | isStarted()Get the started status.
return started;
|
| public void | load()Load all sessions found in the persistence mechanism, assuming
they are marked as valid and have not passed their expiration
limit. If persistence is not supported, this method returns
without doing anything.
Note that by default, this method is not called by the MiddleManager
class. In order to use it, a subclass must specifically call it,
for example in the start() and/or processPersistenceChecks() methods.
// Initialize our internal data structures
sessions.clear();
if (store == null)
return;
String[] ids = null;
try {
if (SecurityUtil.isPackageProtectionEnabled()){
try{
ids = (String[])AccessController.doPrivileged(new PrivilegedStoreKeys());
}catch(PrivilegedActionException ex){
Exception exception = ex.getException();
log.error("Exception in the Store during load: " + exception);
exception.printStackTrace();
}
} else {
ids = store.keys();
}
} catch (IOException e) {
log.error("Can't load sessions from store, " + e.getMessage(), e);
return;
}
int n = ids.length;
if (n == 0)
return;
if (log.isDebugEnabled())
log.debug(sm.getString("persistentManager.loading", String.valueOf(n)));
for (int i = 0; i < n; i++)
try {
swapIn(ids[i]);
} catch (IOException e) {
log.error("Failed load session from store, " + e.getMessage(), e);
}
|
| protected void | processExpires()Invalidate all sessions that have expired.
Hercules: modified method
if (!started)
return;
long timeNow = System.currentTimeMillis();
Session sessions[] = findSessions();
for (int i = 0; i < sessions.length; i++) {
StandardSession session = (StandardSession) sessions[i];
/* START CR 6363689
if (!session.isValid()) {
*/
// START CR 6363689
if(!session.getIsValid() || session.hasExpired()) {
// END CR 6363689
if(session.lockBackground()) {
try {
session.expire();
} finally {
session.unlockBackground();
}
}
}
}
|
| protected void | processInvalidatedSessions()Purges those session ids from the map of invalidated session ids whose
time has come up
if (!started) {
return;
}
long timeNow = System.currentTimeMillis();
Iterator<String> iter = invalidatedSessions.keySet().iterator();
while (iter.hasNext()) {
String id = iter.next();
Long timeAdded = invalidatedSessions.get(id);
if ((timeAdded == null)
|| (timeNow - timeAdded.longValue() >
rememberInvalidatedSessionIdMilliSecs)) {
removeFromInvalidatedSessions(id);
}
}
|
| protected void | processMaxActiveSwaps()Swap idle sessions out to Store if too many are active
Hercules: modified method
if (!isStarted() || getMaxActiveSessions() < 0)
return;
Session sessions[] = findSessions();
// FIXME: Smarter algorithm (LRU)
if (getMaxActiveSessions() >= sessions.length)
return;
if(log.isDebugEnabled())
log.debug(sm.getString
("persistentManager.tooManyActive",
Integer.valueOf(sessions.length)));
int toswap = sessions.length - getMaxActiveSessions();
long timeNow = System.currentTimeMillis();
for (int i = 0; i < sessions.length && toswap > 0; i++) {
int timeIdle = // Truncate, do not round up
(int) ((timeNow - sessions[i].getLastAccessedTime()) / 1000L);
if (timeIdle > minIdleSwap) {
StandardSession session = (StandardSession) sessions[i];
//skip the session if it cannot be locked
if(session.lockBackground()) {
if(log.isDebugEnabled())
log.debug(sm.getString
("persistentManager.swapTooManyActive",
sessions[i].getIdInternal(),
Integer.valueOf(timeIdle)));
try {
swapOut(sessions[i]);
} catch (java.util.ConcurrentModificationException e1) {
; // This is logged in writeSession()
} catch (IOException e) {
; // This is logged in writeSession()
} catch (Exception e) {
; // This is logged in writeSession()
} finally {
session.unlockBackground();
}
toswap--;
}
}
}
|
| protected void | processMaxIdleBackups()Back up idle sessions.
Hercules: modified method
if (!isStarted() || maxIdleBackup < 0)
return;
Session sessions[] = findSessions();
long timeNow = System.currentTimeMillis();
// Back up all sessions idle longer than maxIdleBackup
if (maxIdleBackup >= 0) {
for (int i = 0; i < sessions.length; i++) {
StandardSession session = (StandardSession) sessions[i];
if (!session.isValid())
continue;
int timeIdle = // Truncate, do not round up
(int) ((timeNow - session.getLastAccessedTime()) / 1000L);
if (timeIdle > maxIdleBackup) {
//if session cannot be background locked then skip it
if (session.lockBackground()) {
if (log.isDebugEnabled())
log.debug(sm.getString
("persistentManager.backupMaxIdle",
session.getIdInternal(),
Integer.valueOf(timeIdle)));
try {
writeSession(session);
} catch (java.util.ConcurrentModificationException e1) {
; // This is logged in writeSession()
} catch (IOException e) {
; // This is logged in writeSession()
} catch (Exception e) {
; // This is logged in writeSession()
} finally {
session.unlockBackground();
}
}
}
}
}
|
| protected void | processMaxIdleSwaps()Swap idle sessions out to Store if they are idle too long.
if (!isStarted() || maxIdleSwap < 0)
return;
Session sessions[] = findSessions();
long timeNow = System.currentTimeMillis();
// Swap out all sessions idle longer than maxIdleSwap
// FIXME: What's preventing us from mangling a session during
// a request?
if (maxIdleSwap >= 0) {
for (int i = 0; i < sessions.length; i++) {
StandardSession session = (StandardSession) sessions[i];
if (!session.isValid())
continue;
int timeIdle = // Truncate, do not round up
(int) ((timeNow - session.getLastAccessedTime()) / 1000L);
if (timeIdle > maxIdleSwap && timeIdle > minIdleSwap) {
if (log.isDebugEnabled())
log.debug(sm.getString
("persistentManager.swapMaxIdle",
session.getIdInternal(),
Integer.valueOf(timeIdle)));
try {
swapOut(session);
} catch (IOException e) {
; // This is logged in writeSession()
}
}
}
}
|
| public void | processPersistenceChecks()Called by the background thread after active sessions have
been checked for expiration, to allow sessions to be
swapped out, backed up, etc.
processMaxIdleSwaps();
processMaxActiveSwaps();
processMaxIdleBackups();
|
| public void | propertyChange(java.beans.PropertyChangeEvent event)Process property change events from our associated Context.
// Validate the source of this event
if (!(event.getSource() instanceof Context))
return;
Context context = (Context) event.getSource();
// Process a relevant property change
if (event.getPropertyName().equals("sessionTimeout")) {
try {
setMaxInactiveIntervalSeconds
( ((Integer) event.getNewValue()).intValue()*60 );
} catch (NumberFormatException e) {
log.error(sm.getString("standardManager.sessionTimeout",
event.getNewValue().toString()));
}
}
|
| public void | release()
super.release();
clearStore();
|
| public void | remove(org.apache.catalina.Session session)Remove this Session from the active Sessions for this Manager,
and from the Store.
remove(session, true);
|
| public void | remove(org.apache.catalina.Session session, boolean persistentRemove)Remove this Session from the active Sessions for this Manager,
and from the Store.
super.remove (session);
if (persistentRemove && store != null){
removeSession(session.getIdInternal());
}
|
| public void | removeFromInvalidatedSessions(java.lang.String sessionId)Removes the given session id from the map of invalidated session ids.
invalidatedSessions.remove(sessionId);
|
| public void | removeLifecycleListener(org.apache.catalina.LifecycleListener listener)Remove a lifecycle event listener from this component.
lifecycle.removeLifecycleListener(listener);
|
| private void | removeSession(java.lang.String id)Remove this Session from the active Sessions for this Manager,
and from the Store.
try {
if (SecurityUtil.isPackageProtectionEnabled()){
try{
AccessController.doPrivileged(new PrivilegedStoreRemove(id));
}catch(PrivilegedActionException ex){
Exception exception = ex.getException();
log.error("Exception in the Store during removeSession: " + exception);
exception.printStackTrace();
}
} else {
store.remove(id);
}
} catch (IOException e) {
log.error("Exception removing session " + e.getMessage());
e.printStackTrace();
}
|
| public void | removeSuper(org.apache.catalina.Session session)Remove this Session from the active Sessions for this Manager,
but not from the Store. (Used by the PersistentValve)
super.remove (session);
|
| public void | setContainer(org.apache.catalina.Container container)Set the Container with which this Manager has been associated. If
it is a Context (the usual case), listen for changes to the session
timeout property.
// De-register from the old Container (if any)
if ((this.container != null) && (this.container instanceof Context))
((Context) this.container).removePropertyChangeListener(this);
// Default processing provided by our superclass
super.setContainer(container);
// Register with the new Container (if any)
if ((this.container != null) && (this.container instanceof Context)) {
setMaxInactiveIntervalSeconds
( ((Context) this.container).getSessionTimeout()*60 );
((Context) this.container).addPropertyChangeListener(this);
}
// START SJSAS 6406580
if (container instanceof StandardContext) {
// Determine for how long we're going to remember invalidated
// session ids
StandardContext ctx = (StandardContext) container;
int frequency = ctx.getManagerChecksFrequency();
int reapIntervalSeconds = ctx.getBackgroundProcessorDelay();
rememberInvalidatedSessionIdMilliSecs
= frequency * reapIntervalSeconds * 1000L * 2;
if (rememberInvalidatedSessionIdMilliSecs <= 0) {
rememberInvalidatedSessionIdMilliSecs = 60000L;
}
}
// END SJSAS 6406580
|
| public void | setMaxActiveSessions(int max)Set the maximum number of actives Sessions allowed, or -1 for
no limit.
int oldMaxActiveSessions = this.maxActiveSessions;
this.maxActiveSessions = max;
support.firePropertyChange("maxActiveSessions",
Integer.valueOf(oldMaxActiveSessions),
Integer.valueOf(this.maxActiveSessions));
|
| public void | setMaxIdleBackup(int backup)Sets the option to back sessions up to the Store after they
are used in a request. Sessions remain available in memory
after being backed up, so they are not passivated as they are
when swapped out. The value set indicates how old a session
may get (since its last use) before it must be backed up: -1
means sessions are not backed up.
Note that this is not a hard limit: sessions are checked
against this age limit periodically according to checkInterval.
This value should be considered to indicate when a session is
ripe for backing up.
So it is possible that a session may be idle for maxIdleBackup +
checkInterval seconds, plus the time it takes to handle other
session expiration, swapping, etc. tasks.
if (backup == this.maxIdleBackup)
return;
int oldBackup = this.maxIdleBackup;
this.maxIdleBackup = backup;
support.firePropertyChange("maxIdleBackup",
Integer.valueOf(oldBackup),
Integer.valueOf(this.maxIdleBackup));
|
| public void | setMaxIdleSwap(int max)Sets the time in seconds after which a session should be swapped out of
memory to disk.
if (max == this.maxIdleSwap)
return;
int oldMaxIdleSwap = this.maxIdleSwap;
this.maxIdleSwap = max;
support.firePropertyChange("maxIdleSwap",
Integer.valueOf(oldMaxIdleSwap),
Integer.valueOf(this.maxIdleSwap));
|
| public void | setMinIdleSwap(int min)Sets the minimum time in seconds that a session must be idle before
it can be swapped out of memory due to maxActiveSession. Set it to -1
if it can be swapped out at any time.
if (this.minIdleSwap == min)
return;
int oldMinIdleSwap = this.minIdleSwap;
this.minIdleSwap = min;
support.firePropertyChange("minIdleSwap",
Integer.valueOf(oldMinIdleSwap),
Integer.valueOf(this.minIdleSwap));
|
| public void | setRejectedSessions(int rejectedSessions)Sets the number of sessions that were not created because the maximum
number of active sessions was reached.
this.rejectedSessions = rejectedSessions;
|
| public void | setSaveOnRestart(boolean saveOnRestart)Set the option to save sessions to the Store when the Manager is
shut down, then loaded when the Manager starts again. If set to
false, any sessions found in the Store may still be picked up when
the Manager is started again.
if (saveOnRestart == this.saveOnRestart)
return;
boolean oldSaveOnRestart = this.saveOnRestart;
this.saveOnRestart = saveOnRestart;
support.firePropertyChange("saveOnRestart",
Boolean.valueOf(oldSaveOnRestart),
Boolean.valueOf(this.saveOnRestart));
|
| protected void | setStarted(boolean started)Set the started flag
this.started = started;
|
| public void | setStore(org.apache.catalina.Store store)Set the Store object which will manage persistent Session
storage for this Manager.
this.store = store;
store.setManager(this);
|
| public void | start()Prepare for the beginning of active use of the public methods of this
component. This method should be called after configure(),
and before any of the public methods of the component are utilized.
// Validate and update our current component state
if (started) {
log.info(sm.getString("standardManager.alreadyStarted"));
return;
}
if( ! initialized )
init();
lifecycle.fireLifecycleEvent(START_EVENT, null);
started = true;
// Force initialization of the random number generator
if (log.isTraceEnabled())
log.trace("Force random number initialization starting");
String dummy = generateSessionId();
if (log.isTraceEnabled())
log.trace("Force random number initialization completed");
if (store == null)
log.error("No Store configured, persistence disabled");
else if (store instanceof Lifecycle)
((Lifecycle)store).start();
|
| public void | stop()Gracefully terminate the active use of the public methods of this
component. This method should be the last one called on a given
instance of this component.
if (log.isDebugEnabled())
log.debug("Stopping");
// Validate and update our current component state
if (!isStarted()) {
log.info(sm.getString("standardManager.notStarted"));
return;
}
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
setStarted(false);
if (getStore() != null && saveOnRestart) {
unload();
} else {
// Expire all active sessions
Session sessions[] = findSessions();
for (int i = 0; i < sessions.length; i++) {
StandardSession session = (StandardSession) sessions[i];
if (!session.isValid())
continue;
session.expire();
}
}
if (getStore() != null && getStore() instanceof Lifecycle)
((Lifecycle)getStore()).stop();
// Require a new random number generator if we are restarted
this.random = null;
if( initialized )
destroy();
|
| protected org.apache.catalina.Session | superFindSession(java.lang.String id)used by subclasses of PersistentManagerBase
Hercules: added method
return super.findSession(id);
|
| protected org.apache.catalina.Session | swapIn(java.lang.String id)Look for a session in the Store and, if found, restore
it in the Manager's list of active sessions if appropriate.
The session will be removed from the Store after swapping
in, but will not be added to the active session list if it
is invalid or past its expiration.
return swapIn(id, null);
|
| protected org.apache.catalina.Session | swapIn(java.lang.String id, java.lang.String version)Look for a session in the Store and, if found, restore
it in the Manager's list of active sessions if appropriate.
The session will be removed from the Store after swapping
in, but will not be added to the active session list if it
is invalid or past its expiration.
ClassLoader webappCl = null;
ClassLoader curCl = null;
if (getContainer() != null
&& getContainer().getLoader() != null) {
webappCl = getContainer().getLoader().getClassLoader();
curCl = Thread.currentThread().getContextClassLoader();
}
Session sess = null;
if (webappCl != null && curCl != webappCl) {
try {
Thread.currentThread().setContextClassLoader(webappCl);
sess = doSwapIn(id, version);
} finally {
Thread.currentThread().setContextClassLoader(curCl);
}
} else {
sess = doSwapIn(id, version);
}
return sess;
|
| protected void | swapOut(org.apache.catalina.Session session)Remove the session from the Manager's list of active
sessions and write it out to the Store. If the session
is past its expiration or invalid, this method does
nothing.
if (store == null || !session.isValid()) {
return;
}
((StandardSession)session).passivate();
writeSession(session);
super.remove(session);
session.recycle();
|
| public void | unload()Save all currently active sessions in the appropriate persistence
mechanism, if any. If persistence is not supported, this method
returns without doing anything.
Note that by default, this method is not called by the MiddleManager
class. In order to use it, a subclass must specifically call it,
for example in the stop() and/or processPersistenceChecks() methods.
if (store == null)
return;
Session sessions[] = findSessions();
int n = sessions.length;
if (n == 0)
return;
if (log.isDebugEnabled())
log.debug(sm.getString("persistentManager.unloading",
String.valueOf(n)));
for (int i = 0; i < n; i++)
try {
swapOut(sessions[i]);
} catch (IOException e) {
; // This is logged in writeSession()
}
|
| protected void | writeSession(org.apache.catalina.Session session)Write the provided session to the Store without modifying
the copy in memory or triggering passivation events. Does
nothing if the session is invalid or past its expiration.
if (store == null || !session.isValid()) {
return;
}
try {
if (SecurityUtil.isPackageProtectionEnabled()){
try{
AccessController.doPrivileged(new PrivilegedStoreSave(session));
}catch(PrivilegedActionException ex){
Exception exception = ex.getException();
log.error("Exception in the Store during writeSession: " + exception);
exception.printStackTrace();
}
} else {
store.save(session);
}
} catch (IOException e) {
log.error(sm.getString
("persistentManager.serializeError", session.getIdInternal(), e));
throw e;
}
|
