| java.lang.Object
 org.apache.catalina.session.ManagerBase
org.apache.catalina.session.PersistentManagerBase
All known Subclasses: org.apache.catalina.session.PersistentManager,
| PersistentManagerBase | | abstract public class PersistentManagerBase extends ManagerBase implements Lifecycle,PropertyChangeListener(Code) | | Extends the ManagerBase class to implement most of the
functionality required by a Manager which supports any kind of
persistence, even if onlyfor restarts.
IMPLEMENTATION NOTE: Correct behavior of session storing and
reloading depends upon external calls to the start() and
stop() methods of this class at the correct times.
author:
Craig R. McClanahan
author:
Jean-Francois Arcand
version:
$Revision: 1.19 $ $Date: 2004/05/26 16:14:04 $ |
| Field Summary | |
| protected int | expiredSessions
Number of sessions that expired. | | protected LifecycleSupport | lifecycle
The lifecycle event support for this component. | | protected int | maxActiveSessions
The maximum number of active Sessions allowed, or -1 for no limit. | | protected int | maxIdleBackup
How long a session must be idle before it should be backed up. | | protected int | maxIdleSwap
The maximum time a session may be idle before it should be swapped
to file just on general principle. | | protected int | minIdleSwap
Minimum time a session must be idle before it is swapped to disk.
This overrides maxActiveSessions, to prevent thrashing if there are lots
of active sessions. | | protected long | processingTime
Processing time during session expiration and passivation. | | protected int | rejectedSessions
Number of session creations that failed due to maxActiveSessions. | | protected boolean | saveOnRestart
Whether to save and reload sessions when the Manager unload
and load methods are called. | | protected boolean | started
| | protected Store | store
Store object which will manage the Session store. |
| Method Summary | |
| public void | addLifecycleListener(LifecycleListener listener)
Add a lifecycle event listener to this component. | | public void | backgroundProcess()
| | public void | clearStore()
Clear all sessions from the Store. | | public LifecycleListener[] | findLifecycleListeners()
Get the lifecycle listeners associated with this lifecycle. | | public Session | findSession(String id)
Return the active Session, associated with this Manager, with the
specified session id (if any); otherwise return null. | | public int | getExpiredSessions()
Number of sessions that expired. | | public String | getInfo()
Return descriptive information about this Manager implementation and
the corresponding version number, in the format
<description>/<version>. | | public int | getMaxActiveSessions()
Return the maximum number of active Sessions allowed, or -1 for
no limit. | | 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. | | public int | getMaxIdleSwap()
The time in seconds after which a session should be swapped out of
memory to disk. | | 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. | | public String | getName()
Return the descriptive short name of this Manager implementation. | | public long | getProcessingTime()
| | public int | getRejectedSessions()
Number of session creations that failed due to maxActiveSessions. | | public boolean | getSaveOnRestart()
Indicates whether sessions are saved when the Manager is shut down
properly. | | public Store | getStore()
Return the Store object which manages persistent Session
storage for this Manager. | | public boolean | isLoaded(String id)
| | protected boolean | isStarted()
Get the started status. | | public void | load()
Load all sessions found in the persistence mechanism, assuming
they are marked as valid and have not passed their expiration
limit. | | public void | processExpires()
Invalidate all sessions that have expired. | | protected void | processMaxActiveSwaps()
| | protected void | processMaxIdleBackups()
Back up idle sessions. | | protected void | processMaxIdleSwaps()
Swap idle sessions out to Store if they are idle too long. | | 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. | | public void | propertyChange(PropertyChangeEvent event)
Process property change events from our associated Context. | | public void | remove(Session session)
Remove this Session from the active Sessions for this Manager,
and from the Store. | | public void | removeLifecycleListener(LifecycleListener listener)
Remove a lifecycle event listener from this component. | | protected void | removeSession(String id)
Remove this Session from the active Sessions for this Manager,
and from the Store. | | public void | removeSuper(Session session)
Remove this Session from the active Sessions for this Manager,
but not from the Store. | | public void | setContainer(Container container)
Set the Container with which this Manager has been associated. | | public void | setExpiredSessions(int expiredSessions)
| | public void | setMaxActiveSessions(int max)
Set the maximum number of actives Sessions allowed, or -1 for
no limit. | | public void | setMaxIdleBackup(int backup)
Sets the option to back sessions up to the Store after they
are used in a request. | | public void | setMaxIdleSwap(int max)
Sets the time in seconds after which a session should be swapped out of
memory to disk. | | 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. | | public void | setProcessingTime(long processingTime)
| | public void | setRejectedSessions(int 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. | | protected void | setStarted(boolean started)
| | public void | setStore(Store store)
Set the Store object which will manage persistent Session
storage for this Manager. | | public void | start()
Prepare for the beginning of active use of the public methods of this
component. | | public void | stop()
Gracefully terminate the active use of the public methods of this
component. | | protected Session | swapIn(String id)
Look for a session in the Store and, if found, restore
it in the Manager's list of active sessions if appropriate. | | protected void | swapOut(Session session)
Remove the session from the Manager's list of active
sessions and write it out to the Store. | | public void | unload()
Save all currently active sessions in the appropriate persistence
mechanism, if any. | | protected void | writeSession(Session session)
Write the provided session to the Store without modifying
the copy in memory or triggering passivation events. |
| expiredSessions | | protected int expiredSessions(Code) | | Number of sessions that expired.
|
| maxActiveSessions | | protected int maxActiveSessions(Code) | | The maximum number of active Sessions allowed, or -1 for no limit.
|
| maxIdleBackup | | protected int maxIdleBackup(Code) | | How long a session must be idle before it should be backed up.
-1 means sessions won't be backed up.
|
| maxIdleSwap | | protected int maxIdleSwap(Code) | | The maximum time a session may be idle before it should be swapped
to file just on general principle. Setting this to -1 means sessions
should not be forced out.
|
| minIdleSwap | | protected int minIdleSwap(Code) | | Minimum time a session must be idle before it is swapped to disk.
This overrides maxActiveSessions, to prevent thrashing if there are lots
of active sessions. Setting to -1 means it's ignored.
|
| processingTime | | protected long processingTime(Code) | | Processing time during session expiration and passivation.
|
| rejectedSessions | | protected int rejectedSessions(Code) | | Number of session creations that failed due to maxActiveSessions.
|
| saveOnRestart | | protected boolean saveOnRestart(Code) | | Whether to save and reload sessions when the Manager unload
and load methods are called.
|
| started | | protected boolean started(Code) | | Has this component been started yet?
|
| store | | protected Store store(Code) | | Store object which will manage the Session store.
|
| addLifecycleListener | | public void addLifecycleListener(LifecycleListener listener)(Code) | | Add a lifecycle event listener to this component.
Parameters:
listener - The listener to add |
| backgroundProcess | | public void backgroundProcess()(Code) | | Perform the background processes for this Manager
|
| clearStore | | public void clearStore()(Code) | | Clear all sessions from the Store.
|
| findLifecycleListeners | | public LifecycleListener[] findLifecycleListeners()(Code) | | Get the lifecycle listeners associated with this lifecycle. If this
Lifecycle has no listeners registered, a zero-length array is returned.
|
| findSession | | public Session findSession(String id) throws IOException(Code) | | 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.
Parameters:
id - The session id for the session to be returned
exception:
IllegalStateException - if a new session cannot beinstantiated for any reason
exception:
IOException - if an input/output error occurs whileprocessing this request |
| getExpiredSessions | | public int getExpiredSessions()(Code) | | Number of sessions that expired.
The count |
| getInfo | | public String getInfo()(Code) | | Return descriptive information about this Manager implementation and
the corresponding version number, in the format
<description>/<version>.
|
| getMaxActiveSessions | | public int getMaxActiveSessions()(Code) | | Return the maximum number of active Sessions allowed, or -1 for
no limit.
|
| getMaxIdleBackup | | public int getMaxIdleBackup()(Code) | | 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.
|
| getMaxIdleSwap | | public int getMaxIdleSwap()(Code) | | The time in seconds after which a session should be swapped out of
memory to disk.
|
| getMinIdleSwap | | public int getMinIdleSwap()(Code) | | 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.
|
| getName | | public String getName()(Code) | | Return the descriptive short name of this Manager implementation.
|
| getProcessingTime | | public long getProcessingTime()(Code) | | |
| getRejectedSessions | | public int getRejectedSessions()(Code) | | Number of session creations that failed due to maxActiveSessions.
The count |
| getSaveOnRestart | | public boolean getSaveOnRestart()(Code) | | Indicates whether sessions are saved when the Manager is shut down
properly. This requires the unload() method to be called.
|
| getStore | | public Store getStore()(Code) | | Return the Store object which manages persistent Session
storage for this Manager.
|
| isLoaded | | public boolean isLoaded(String id)(Code) | | Return true, if the session id is loaded in memory
otherwise false is returned
Parameters:
id - The session id for the session to be searched for |
| isStarted | | protected boolean isStarted()(Code) | | Get the started status.
|
| load | | public void load()(Code) | | 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.
|
| processExpires | | public void processExpires()(Code) | | Invalidate all sessions that have expired.
|
| processMaxActiveSwaps | | protected void processMaxActiveSwaps()(Code) | | Swap idle sessions out to Store if too many are active
|
| processMaxIdleBackups | | protected void processMaxIdleBackups()(Code) | | Back up idle sessions.
|
| processMaxIdleSwaps | | protected void processMaxIdleSwaps()(Code) | | Swap idle sessions out to Store if they are idle too long.
|
| processPersistenceChecks | | public void processPersistenceChecks()(Code) | | Called by the background thread after active sessions have
been checked for expiration, to allow sessions to be
swapped out, backed up, etc.
|
| propertyChange | | public void propertyChange(PropertyChangeEvent event)(Code) | | Process property change events from our associated Context.
Parameters:
event - The property change event that has occurred |
| remove | | public void remove(Session session)(Code) | | Remove this Session from the active Sessions for this Manager,
and from the Store.
Parameters:
session - Session to be removed |
| removeLifecycleListener | | public void removeLifecycleListener(LifecycleListener listener)(Code) | | Remove a lifecycle event listener from this component.
Parameters:
listener - The listener to remove |
| removeSession | | protected void removeSession(String id)(Code) | | Remove this Session from the active Sessions for this Manager,
and from the Store.
Parameters:
id - Session's id to be removed |
| removeSuper | | public void removeSuper(Session session)(Code) | | Remove this Session from the active Sessions for this Manager,
but not from the Store. (Used by the PersistentValve)
Parameters:
session - Session to be removed |
| setContainer | | public void setContainer(Container container)(Code) | | 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.
Parameters:
container - The associated Container |
| setExpiredSessions | | public void setExpiredSessions(int expiredSessions)(Code) | | |
| setMaxActiveSessions | | public void setMaxActiveSessions(int max)(Code) | | Set the maximum number of actives Sessions allowed, or -1 for
no limit.
Parameters:
max - The new maximum number of sessions |
| setMaxIdleBackup | | public void setMaxIdleBackup(int backup)(Code) | | 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.
Parameters:
backup - The number of seconds after their last accessedtime when they should be written to the Store. |
| setMaxIdleSwap | | public void setMaxIdleSwap(int max)(Code) | | Sets the time in seconds after which a session should be swapped out of
memory to disk.
|
| setMinIdleSwap | | public void setMinIdleSwap(int min)(Code) | | 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.
|
| setProcessingTime | | public void setProcessingTime(long processingTime)(Code) | | |
| setRejectedSessions | | public void setRejectedSessions(int rejectedSessions)(Code) | | |
| setSaveOnRestart | | public void setSaveOnRestart(boolean saveOnRestart)(Code) | | 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.
Parameters:
saveOnRestart - true if sessions should be saved on restart, false ifthey should be ignored. |
| setStarted | | protected void setStarted(boolean started)(Code) | | Set the started flag
|
| setStore | | public void setStore(Store store)(Code) | | Set the Store object which will manage persistent Session
storage for this Manager.
Parameters:
store - the associated Store |
| start | | public void start() throws LifecycleException(Code) | | 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.
exception:
LifecycleException - if this component detects a fatal errorthat prevents this component from being used |
| stop | | public void stop() throws LifecycleException(Code) | | 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.
exception:
LifecycleException - if this component detects a fatal errorthat needs to be reported |
| swapIn | | protected Session swapIn(String id) throws IOException(Code) | | 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.
|
| swapOut | | protected void swapOut(Session session) throws IOException(Code) | | 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.
Parameters:
session - The Session to write out. |
| unload | | public void unload()(Code) | | 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.
|
| writeSession | | protected void writeSession(Session session) throws IOException(Code) | | 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.
|
|
|