| Methods Summary |
|---|
| public void | addLifecycleListener(org.apache.catalina.LifecycleListener listener)Add a lifecycle event listener to this component.
lifecycle.addLifecycleListener(listener);
|
| public void | clearStore()
File file = file();
if (file != null && file.exists()) {
file.delete();
}
|
| public org.apache.catalina.Session | createSession()Construct and return a new session object, based on the default
settings specified by this Manager's properties. The session
id will be assigned by this method, and available via the getId()
method of the returned session. If a new session cannot be created
for any reason, return null.
if ((maxActiveSessions >= 0) &&
(sessions.size() >= maxActiveSessions)) {
rejectedSessions++;
throw new IllegalStateException
(sm.getString("standardManager.createSession.ise"));
}
return (super.createSession());
|
| private void | doLoad()Load any currently active sessions that were previously unloaded
to the appropriate persistence mechanism, if any. If persistence is not
supported, this method returns without doing anything.
if (log.isDebugEnabled())
log.debug("Start: Loading persisted sessions");
// Initialize our internal data structures
sessions.clear();
// Open an input stream to the specified pathname, if any
File file = file();
if (file == null)
return;
if (log.isDebugEnabled())
log.debug(sm.getString("standardManager.loading", pathname));
FileInputStream fis = null;
ObjectInputStream ois = null;
Loader loader = null;
ClassLoader classLoader = null;
try {
fis = new FileInputStream(file.getAbsolutePath());
BufferedInputStream bis = new BufferedInputStream(fis);
if (container != null)
loader = container.getLoader();
if (loader != null)
classLoader = loader.getClassLoader();
if (classLoader != null) {
IOUtilsCaller caller = getWebUtilsCaller();
if (caller != null) {
try {
ois = caller.createObjectInputStream(
bis, true, classLoader);
} catch (Exception ex) {}
} else {
if (log.isDebugEnabled()) {
log.debug("Creating custom object input stream for class loader ");
}
ois = new CustomObjectInputStream(bis, classLoader);
}
}
if (ois == null) {
if (log.isDebugEnabled()) {
log.debug("Creating standard object input stream");
}
ois = new ObjectInputStream(bis);
}
} catch (FileNotFoundException e) {
if (log.isDebugEnabled())
log.debug("No persisted data file found");
return;
} catch (IOException e) {
log.error(sm.getString("standardManager.loading.ioe", e), e);
if (ois != null) {
try {
ois.close();
} catch (IOException f) {
;
}
ois = null;
}
throw e;
}
// Load the previously unloaded active sessions
synchronized (sessions) {
try {
Integer count = (Integer) ois.readObject();
int n = count.intValue();
if (log.isDebugEnabled())
log.debug("Loading " + n + " persisted sessions");
for (int i = 0; i < n; i++) {
StandardSession session =
StandardSession.deserialize(ois, this);
session.setManager(this);
sessions.put(session.getIdInternal(), session);
session.activate();
}
} catch (ClassNotFoundException e) {
log.error(sm.getString("standardManager.loading.cnfe", e), e);
if (ois != null) {
try {
ois.close();
} catch (IOException f) {
;
}
ois = null;
}
throw e;
} catch (IOException e) {
log.error(sm.getString("standardManager.loading.ioe", e), e);
if (ois != null) {
try {
ois.close();
} catch (IOException f) {
;
}
ois = null;
}
throw e;
} finally {
// Close the input stream
try {
if (ois != null)
ois.close();
} catch (IOException f) {
// ignored
}
// Delete the persistent storage file
if (file != null && file.exists() )
file.delete();
}
}
if (log.isDebugEnabled())
log.debug("Finish: Loading persisted sessions");
|
| private void | doUnload(boolean doExpire)Save any currently active sessions in the appropriate persistence
mechanism, if any. If persistence is not supported, this method
returns without doing anything.
if (log.isDebugEnabled())
log.debug("Unloading persisted sessions");
// Open an output stream to the specified pathname, if any
File file = file();
if (file == null)
return;
//HERCULES: add
boolean haveValidDirectory = isDirectoryValidFor(file.getAbsolutePath());
if(!haveValidDirectory)
return;
//end HERCULES: add
if (log.isDebugEnabled())
log.debug(sm.getString("standardManager.unloading", pathname));
FileOutputStream fos = null;
ObjectOutputStream oos = null;
try {
fos = new FileOutputStream(file.getAbsolutePath());
IOUtilsCaller caller = getWebUtilsCaller();
if (caller != null) {
try {
oos = caller.createObjectOutputStream(
new BufferedOutputStream(fos), true);
} catch (Exception ex) {}
}
// Use normal ObjectOutputStream if there is a failure during
// stream creation
if (oos == null) {
oos = new ObjectOutputStream(new BufferedOutputStream(fos));
}
} catch (IOException e) {
log.error(sm.getString("standardManager.unloading.ioe", e), e);
if (oos != null) {
try {
oos.close();
} catch (IOException f) {
;
}
oos = null;
}
throw e;
}
// Write the number of active sessions, followed by the details
ArrayList list = new ArrayList();
synchronized (sessions) {
if (log.isDebugEnabled())
log.debug("Unloading " + sessions.size() + " sessions");
try {
// START SJSAS 6375689
Session actSessions[] = findSessions();
if (actSessions != null) {
for (int i = 0; i < actSessions.length; i++) {
StandardSession session = (StandardSession)
actSessions[i];
((StandardSession) session).passivate();
}
}
// END SJSAS 6375689
oos.writeObject(Integer.valueOf(sessions.size()));
Iterator elements = sessions.values().iterator();
while (elements.hasNext()) {
StandardSession session =
(StandardSession) elements.next();
list.add(session);
/* SJSAS 6375689
((StandardSession) session).passivate();
*/
oos.writeObject(session);
}
} catch (IOException e) {
log.error(sm.getString("standardManager.unloading.ioe", e), e);
if (oos != null) {
try {
oos.close();
} catch (IOException f) {
;
}
oos = null;
}
throw e;
}
}
// Flush and close the output stream
try {
oos.flush();
oos.close();
oos = null;
} catch (IOException e) {
if (oos != null) {
try {
oos.close();
} catch (IOException f) {
;
}
oos = null;
}
throw e;
}
if (doExpire) {
// Expire all the sessions we just wrote
if (log.isDebugEnabled())
log.debug("Expiring " + list.size() + " persisted sessions");
Iterator expires = list.iterator();
while (expires.hasNext()) {
StandardSession session = (StandardSession) expires.next();
try {
session.expire(false);
} catch (Throwable t) {
;
}
}
}
if (log.isDebugEnabled())
log.debug("Unloading complete");
|
| private java.io.File | file()Return a File object representing the pathname to our
persistence file, if any.
// START SJSAS 6359401
if (absPathName != null) {
return new File(absPathName);
}
// END SJSAS 6359401
if ((pathname == null) || (pathname.length() == 0))
return (null);
File file = new File(pathname);
if (!file.isAbsolute()) {
if (container instanceof Context) {
ServletContext servletContext =
((Context) container).getServletContext();
File tempdir = (File)
servletContext.getAttribute(Globals.WORK_DIR_ATTR);
if (tempdir != null)
file = new File(tempdir, pathname);
}
}
// START SJSAS 6359401
if (file != null) {
absPathName = file.getAbsolutePath();
}
// END SJSAS 6359401
return (file);
|
| 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 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 java.lang.String | getName()Return the descriptive short name of this Manager implementation.
return (name);
|
| public java.lang.String | getPathname()Return the session persistence pathname, if any.
return (this.pathname);
|
| public long | getProcessingTime()
return processingTime;
|
| public int | getRejectedSessions()Number of session creations that failed due to maxActiveSessions
return rejectedSessions;
|
| private boolean | isDirectoryValidFor(java.lang.String fullPathFileName)Check if the directory for this full qualified file
exists and is valid
Hercules: added method
int lastSlashIdx = fullPathFileName.lastIndexOf(File.separator);
if(lastSlashIdx == -1) {
return false;
}
String result = fullPathFileName.substring(0, lastSlashIdx);
//System.out.println("PATH name = " + result);
File file = new File(result);
boolean isDirValid = file.isDirectory();
//System.out.println("IS DIR VALID: " + result);
return isDirValid;
|
| public void | load()Load any currently active sessions that were previously unloaded
to the appropriate persistence mechanism, if any. If persistence is not
supported, this method returns without doing anything.
if (SecurityUtil.isPackageProtectionEnabled()){
try{
AccessController.doPrivileged( new PrivilegedDoLoad() );
} catch (PrivilegedActionException ex){
Exception exception = ex.getException();
if (exception instanceof ClassNotFoundException){
throw (ClassNotFoundException)exception;
} else if (exception instanceof IOException){
throw (IOException)exception;
}
if (log.isDebugEnabled())
log.debug("Unreported exception in load() "
+ exception);
}
} else {
doLoad();
}
|
| public void | processExpires()Invalidate all sessions that have expired.
long timeNow = System.currentTimeMillis();
Session sessions[] = findSessions();
for (int i = 0; i < sessions.length; i++) {
sessions[i].isValid();
}
long timeEnd = System.currentTimeMillis();
processingTime += ( timeEnd - timeNow );
|
| 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 | removeLifecycleListener(org.apache.catalina.LifecycleListener listener)Remove a lifecycle event listener from this component.
lifecycle.removeLifecycleListener(listener);
|
| 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.
// ------------------------------------------------------------- Properties
// 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);
}
|
| 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 | setPathname(java.lang.String pathname)Set the session persistence pathname to the specified value. If no
persistence support is desired, set the pathname to null.
String oldPathname = this.pathname;
this.pathname = pathname;
support.firePropertyChange("pathname", oldPathname, this.pathname);
|
| public void | setProcessingTime(long processingTime)
this.processingTime = processingTime;
|
| public void | setRejectedSessions(int rejectedSessions)
this.rejectedSessions = rejectedSessions;
|
| 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.
if( ! initialized )
init();
// Validate and update our current component state
if (started) {
log.info(sm.getString("standardManager.alreadyStarted"));
return;
}
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");
// Load unloaded sessions, if any
try {
load();
} catch (Throwable t) {
log.error(sm.getString("standardManager.managerLoad"), t);
}
|
| 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 (!started)
throw new LifecycleException
(sm.getString("standardManager.notStarted"));
lifecycle.fireLifecycleEvent(STOP_EVENT, null);
started = false;
// Write out sessions
try {
unload(false);
} catch (IOException e) {
log.error(sm.getString("standardManager.managerUnload"), e);
}
// Expire all active sessions and notify their listeners
Session sessions[] = findSessions();
for (int i = 0; i < sessions.length; i++) {
StandardSession session = (StandardSession) sessions[i];
if (!session.isValid())
continue;
try {
session.expire();
} catch (Throwable t) {
;
}
}
// Require a new random number generator if we are restarted
this.random = null;
if( initialized ) {
destroy();
}
|
| public void | unload()Save any currently active sessions in the appropriate persistence
mechanism, if any. If persistence is not supported, this method
returns without doing anything.
unload(true);
|
| protected void | unload(boolean doExpire)Save any currently active sessions in the appropriate persistence
mechanism, if any. If persistence is not supported, this method
returns without doing anything.
if (SecurityUtil.isPackageProtectionEnabled()){
try{
AccessController.doPrivileged( new PrivilegedDoUnload(doExpire) );
} catch (PrivilegedActionException ex){
Exception exception = ex.getException();
if (exception instanceof IOException){
throw (IOException)exception;
}
if (log.isDebugEnabled())
log.debug("Unreported exception in unLoad() "
+ exception);
}
} else {
doUnload(doExpire);
}
|
