| Methods Summary |
|---|
| public void | addLifecycleListener(org.apache.catalina.LifecycleListener listener)Add a lifecycle event listener to this component.
lifecycle.addLifecycleListener(listener);
|
| 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.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.
Session session = super.findSession(id);
if (session != null)
return (session);
// See if the Session is in the Store
session = swapIn(id);
return (session);
|
| public java.lang.String | getInfo()Return descriptive information about this Manager implementation and
the corresponding version number, in the format
<description>/<version>.
return (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.
// ------------------------------------------------------------- Properties
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 | getName()Return the descriptive short name of this Manager implementation.
return (name);
|
| public int | getRejectedSessions()Number of session creations that failed due to maxActiveSessions.
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;
|
| 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);
}
|
| public void | processExpires()Implements the Manager interface, direct call to processExpires and processPersistenceChecks
long timeNow = System.currentTimeMillis();
Session sessions[] = findSessions();
int expireHere = 0 ;
if(log.isDebugEnabled())
log.debug("Start expire sessions " + getName() + " at " + timeNow + " sessioncount " + sessions.length);
for (int i = 0; i < sessions.length; i++) {
if (!sessions[i].isValid()) {
expiredSessions++;
expireHere++;
}
}
processPersistenceChecks();
if ((getStore() != null) && (getStore() instanceof StoreBase)) {
((StoreBase) getStore()).processExpires();
}
long timeEnd = System.currentTimeMillis();
if(log.isDebugEnabled())
log.debug("End expire sessions " + getName() + " processingTime " + (timeEnd - timeNow) + " expired sessions: " + expireHere);
processingTime += (timeEnd - timeNow);
|
| protected void | processMaxActiveSwaps()Swap idle sessions out to Store if too many are active
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",
new Integer(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) {
if(log.isDebugEnabled())
log.debug(sm.getString
("persistentManager.swapTooManyActive",
sessions[i].getIdInternal(), new Integer(timeIdle)));
try {
swapOut(sessions[i]);
} catch (IOException e) {
; // This is logged in writeSession()
}
toswap--;
}
}
|
| protected void | processMaxIdleBackups()Back up idle sessions.
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 (log.isDebugEnabled())
log.debug(sm.getString
("persistentManager.backupMaxIdle",
session.getIdInternal(), new Integer(timeIdle)));
try {
writeSession(session);
} catch (IOException e) {
; // This is logged in writeSession()
}
}
}
}
|
| 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(), new Integer(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 {
setMaxInactiveInterval
( ((Integer) event.getNewValue()).intValue()*60 );
} catch (NumberFormatException e) {
log.error(sm.getString("standardManager.sessionTimeout",
event.getNewValue().toString()));
}
}
|
| public void | remove(org.apache.catalina.Session session)Remove this Session from the active Sessions for this Manager,
and from the Store.
super.remove (session);
if (store != null){
removeSession(session.getIdInternal());
}
|
| public void | removeLifecycleListener(org.apache.catalina.LifecycleListener listener)Remove a lifecycle event listener from this component.
lifecycle.removeLifecycleListener(listener);
|
| protected 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)) {
setMaxInactiveInterval
( ((Context) this.container).getSessionTimeout()*60 );
((Context) this.container).addPropertyChangeListener(this);
}
|
| 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",
new Integer(oldMaxActiveSessions),
new Integer(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 processExpiresFrequency.
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 +
processExpiresFrequency * engine.backgroundProcessorDelay 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",
new Integer(oldBackup),
new Integer(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",
new Integer(oldMaxIdleSwap),
new Integer(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",
new Integer(oldMinIdleSwap),
new Integer(this.minIdleSwap));
|
| public void | setRejectedSessions(int rejectedSessions)
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",
new Boolean(oldSaveOnRestart),
new Boolean(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.isDebugEnabled())
log.debug("Force random number initialization starting");
String dummy = generateSessionId();
if (log.isDebugEnabled())
log.debug("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 | 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.
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 {
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");
session.expire();
removeSession(id);
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();
session.endAccess();
return (session);
|
| 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;
}
|
