FileDocCategorySizeDatePackage
ManagerBase.javaAPI DocGlassfish v2 API42856Wed Jul 18 08:31:58 BST 2007org.apache.catalina.session

ManagerBase

public abstract class ManagerBase extends Object implements org.apache.catalina.Manager, MBeanRegistration
Minimal implementation of the Manager interface that supports no session persistence or distributable capabilities. This class may be subclassed to create more sophisticated Manager implementations.
author
Craig R. McClanahan
version
$Revision: 1.23 $ $Date: 2007/07/18 15:31:57 $

Fields Summary
protected com.sun.org.apache.commons.logging.Log
log
protected DataInputStream
randomIS
protected String
devRandomSource
protected static final String
DEFAULT_ALGORITHM
The default message digest algorithm to use if we cannot use the requested one.
protected String
algorithm
The message digest algorithm to be used when generating session identifiers. This must be an algorithm supported by the java.security.MessageDigest class on your platform.
protected org.apache.catalina.Container
container
The Container with which this Manager is associated.
protected int
debug
The debugging detail level for this component.
protected org.apache.catalina.DefaultContext
defaultContext
The DefaultContext with which this Manager is associated.
protected MessageDigest
digest
Return the MessageDigest implementation to be used when creating session identifiers.
protected boolean
distributable
The distributable flag for Sessions created by this Manager. If this flag is set to true, any user attributes added to a session controlled by this Manager must be Serializable.
protected String
entropy
A String initialization parameter used to increase the entropy of the initialization of our random number generator.
protected org.apache.catalina.SessionLocker
sessionLocker
A SessionLocker used to lock sessions (curently only in the request dispatcher forward/include use case)
private static final String
info
The descriptive information string for this implementation.
protected int
maxInactiveInterval
The default maximum inactive interval for Sessions created by this Manager.
protected int
sessionIdLength
The session id length of Sessions created by this Manager.
protected static final String
name
The descriptive name of this Manager implementation (for logging).
protected Random
random
A random number generator to use when generating session identifiers.
protected com.sun.enterprise.util.uuid.UuidGenerator
uuidGenerator
The Uuid Generator to be used when generating universally unique session identifiers. HERCULES: add
protected String
randomClass
The Java class name of the random number generator class to be used when generating session identifiers.
protected int
sessionMaxAliveTime
The longest time (in seconds) that an expired session had been alive.
protected int
sessionAverageAliveTime
Average time (in seconds) that expired sessions had been alive.
protected int
expiredSessions
Number of sessions that have expired.
protected HashMap
sessions
The set of currently active Sessions for this Manager, keyed by session identifier.
protected int
sessionCounter
protected int
maxActive
protected int
duplicates
protected boolean
initialized
protected static final org.apache.catalina.util.StringManager
sm
The string manager for this package.
protected PropertyChangeSupport
support
The property change support for this component.
private boolean
prefixSessionID_
private String
prefix_
private static final IOUtilsCaller
webUtilsCaller
Utility class used to call into services from com.sun.ejb.base.io.IOUtils, which provides object input and output streams for the serialization and deserialization of EJB references stored in HTTP sessions
protected String
domain
protected ObjectName
oname
protected MBeanServer
mserver
Constructors Summary
Methods Summary
public voidadd(org.apache.catalina.Session session)
Add this Session to the set of active Sessions for this Manager.

param
session Session to be added


        synchronized (sessions) {
            sessions.put(session.getIdInternal(), session);
            if( sessions.size() > maxActive ) {
                maxActive=sessions.size();
            }
        }
public voidaddPropertyChangeListener(java.beans.PropertyChangeListener listener)
Add a property change listener to this component.

param
listener The listener to add


        support.addPropertyChangeListener(listener);
public voidclearSessions()
clear out the sessions cache HERCULES:added

        sessions.clear();
public org.apache.catalina.SessioncreateEmptySession()
Get a session from the recycled ones or create a new empty one. The PersistentManager manager does not need to create session data because it reads it from the Store.

        return (getNewSession());
public org.apache.catalina.SessioncreateSession()
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. Hercules: modified

exception
IllegalStateException if a new session cannot be instantiated for any reason

        
        // Recycle or create a Session instance
        Session session = null;
        session = createEmptySession();
        StandardSession sess = (StandardSession) session;
        //always lock
        sess.lockForeground(); 

        // Initialize the properties of the new session and return it
        session.setNew(true);
        session.setValid(true);
        session.setCreationTime(System.currentTimeMillis());
        session.setMaxInactiveInterval(this.maxInactiveInterval);
        //HERCULES:mod
        String sessionId = generateSessionId(session);

        /*
        String jvmRoute = getJvmRoute();
        // @todo Move appending of jvmRoute generateSessionId()???
        if (jvmRoute != null) {
            sessionId += '.' + jvmRoute;
        }
         */
        /*
        synchronized (sessions) {
            while (sessions.get(sessionId) != null){ // Guarantee uniqueness
                duplicates++;
                sessionId = generateSessionId();
                // @todo Move appending of jvmRoute generateSessionId()???
                if (jvmRoute != null) {
                    sessionId += '.' + jvmRoute;
                }
            }
        }
         */
        //end HERCULES:mod

        session.setId(sessionId);
        sessionCounter++;

        return (session);
public org.apache.catalina.SessioncreateSession(java.lang.String sessionId)
Construct and return a new session object, based on the default settings specified by this Manager's properties, using the specified session id. IMPLEMENTATION NOTE: This method must be kept in sync with the createSession method that takes no arguments.

param
sessionId the session id to assign to the new session
exception
IllegalStateException if a new session cannot be instantiated for any reason
return
the new session, or null if a session with the requested id already exists


        // Recycle or create a Session instance
        Session session = createEmptySession();

        // Initialize the properties of the new session and return it
        session.setNew(true);
        session.setValid(true);
        session.setCreationTime(System.currentTimeMillis());
        session.setMaxInactiveInterval(this.maxInactiveInterval);

        synchronized (sessions) {
            if (sessions.get(sessionId) != null) {
                // Session with requested id already exists
                return null;
            }
        }
        
        //START OF 6364900
        StandardSession sess = (StandardSession) session;
        //always lock
        sess.lockForeground();        
        //END OF 6364900        

        session.setId(sessionId);
        sessionCounter++;

        return (session);
public voiddestroy()

        if( oname != null )
            Registry.getRegistry().unregisterComponent(oname);
        initialized=false;
        oname = null;
public voidexpireSession(java.lang.String sessionId)

        Session s=(Session)sessions.get(sessionId);
        if( s==null ) {
            log.info("Session not found " + sessionId);
            return;
        }
        s.expire();
public org.apache.catalina.SessionfindSession(java.lang.String id)
Return the active Session, associated with this Manager, with the specified session id (if any); otherwise return null.

param
id The session id for the session to be returned
exception
IllegalStateException if a new session cannot be instantiated for any reason
exception
IOException if an input/output error occurs while processing this request


        if (id == null)
            return (null);
        synchronized (sessions) {
            Session session = (Session) sessions.get(id);
            return (session);
        }
public org.apache.catalina.SessionfindSession(java.lang.String id, java.lang.String version)
Finds and returns the session with the given id that also satisfies the given version requirement. This overloaded version of findSession() will be invoked only if isSessionVersioningSupported() returns true. By default, this method delegates to the version of findSession() that does not take any session version number.

param
id The session id to match
param
version The session version requirement to satisfy
return
The session that matches the given id and also satisfies the given version requirement, or null if no such session could be found by this session manager
exception
IOException if an IO error occurred


        return findSession(id);
public org.apache.catalina.Session[]findSessions()
Return the set of active Sessions associated with this Manager. If this Manager has no active Sessions, a zero-length array is returned.


        Session results[] = null;
        synchronized (sessions) {
            results = new Session[sessions.size()];
            results = (Session[]) sessions.values().toArray(results);
        }
        return (results);
protected synchronized java.lang.StringgenerateSessionId(java.lang.Object obj)
Generate and return a new session identifier. Hercules:added

        String result = uuidGenerator.generateUuid(obj);
        //START OF RIMOD# 5056989 -- Support for iWS6.0 style session ids
        if (prefixSessionID_) {
            result = prefix_ + result;
        }
        //END OF RIMOD# 5056989
        return result;
protected synchronized java.lang.StringgenerateSessionId()
Generate and return a new session identifier. Hercules:modified

        return generateSessionId(new Object());
public intgetActiveSessions()
Returns the number of active sessions

return
number of sessions active

        return sessions.size();
public java.lang.StringgetAlgorithm()
Return the message digest algorithm for this Manager.


        return (this.algorithm);
public java.lang.StringgetClassName()
Returns the name of the implementation class.

        return this.getClass().getName();
public org.apache.catalina.ContainergetContainer()
Return the Container with which this Manager is associated.


        return (this.container);
public intgetDebug()
Return the debugging detail level for this component.


        return (this.debug);
public org.apache.catalina.DefaultContextgetDefaultContext()
Return the DefaultContext with which this Manager is associated.


        return (this.defaultContext);
public synchronized java.security.MessageDigestgetDigest()
Return the MessageDigest object to be used for calculating session identifiers. If none has been created yet, initialize one the first time this method is called.


        if (this.digest == null) {
            long t1=System.currentTimeMillis();
            if (log.isDebugEnabled())
                log.debug(sm.getString("managerBase.getting", algorithm));
            try {
                this.digest = MessageDigest.getInstance(algorithm);
            } catch (NoSuchAlgorithmException e) {
                log.error(sm.getString("managerBase.digest", algorithm), e);
                try {
                    this.digest = MessageDigest.getInstance(DEFAULT_ALGORITHM);
                } catch (NoSuchAlgorithmException f) {
                    log.error(sm.getString("managerBase.digest",
                                     DEFAULT_ALGORITHM), e);
                    this.digest = null;
                }
            }
            if (log.isDebugEnabled())
                log.debug(sm.getString("managerBase.gotten"));
            long t2=System.currentTimeMillis();
            if( log.isDebugEnabled() )
                log.debug("getDigest() " + (t2-t1));
        }

        return (this.digest);
public booleangetDistributable()
Return the distributable flag for the sessions supported by this Manager.


        return (this.distributable);
public java.lang.StringgetDomain()

        return domain;
public intgetDuplicates()
Number of duplicated session IDs generated by the random source. Anything bigger than 0 means problems.

return

        return duplicates;
public org.apache.catalina.EnginegetEngine()
Retrieve the enclosing Engine for this Manager.

return
an Engine object (or null).

        Engine e = null;
        for (Container c = getContainer(); e == null && c != null ; c = c.getParent()) {
            if (c != null && c instanceof Engine) {
                e = (Engine)c;
            }
        }
        return e;
public java.lang.StringgetEntropy()
Return the entropy increaser value, or compute a semi-useful value if this String has not yet been set.


        // Calculate a semi-useful value if this has not been set
        if (this.entropy == null)
            setEntropy(this.toString());

        return (this.entropy);
public intgetExpiredSessions()
Gets the number of sessions that have expired.

return
Number of sessions that have expired

        return expiredSessions;
public java.lang.StringgetInfo()
Return descriptive information about this Manager implementation and the corresponding version number, in the format <description>/<version>.


        return (this.info);
public java.lang.StringgetJvmRoute()
Retrieve the JvmRoute for the enclosing Engine.

return
the JvmRoute or null.

        Engine e = getEngine();
        return e == null ? null : e.getJvmRoute();
public java.lang.StringgetLastAccessedTimeMillis(java.lang.String sessionId)

        Session s=(Session)sessions.get(sessionId);
        if( s==null ) {
            log.info("Session not found " + sessionId);
            return "";
        }
        return new Date(s.getLastAccessedTime()).toString();
public intgetMaxActive()
Max number of concurent active sessions

return

        return maxActive;
public intgetMaxInactiveInterval()
Same as getMaxInactiveIntervalSeconds

        return getMaxInactiveIntervalSeconds();
public intgetMaxInactiveIntervalSeconds()
Return the default maximum inactive interval (in seconds) for Sessions created by this Manager.


        return (this.maxInactiveInterval);
public java.lang.StringgetName()
Return the descriptive short name of this Manager implementation.


        return (name);
protected StandardSessiongetNewSession()
Get new session class to be used in the doLoad() method.

        return new StandardSession(this);
public javax.management.ObjectNamegetObjectName()

        return oname;
public synchronized java.util.RandomgetRandom()
Return the random number generator instance we should use for generating session identifiers. If there is no such generator currently defined, construct and seed a new one.

        if (this.random == null) {
            synchronized (this) {
                if (this.random == null) {
                    // Calculate the new random number generator seed
                    long seed = System.currentTimeMillis();
                    long t1 = seed;
                    char entropy[] = getEntropy().toCharArray();
                    for (int i = 0; i < entropy.length; i++) {
                        long update = ((byte) entropy[i]) << ((i % 8) * 8);
                        seed ^= update;
                    }
                    try {
                        // Construct and seed a new random number generator
                        Class clazz = Class.forName(randomClass);
                        this.random = (Random) clazz.newInstance();
                        this.random.setSeed(seed);
                    } catch (Exception e) {
                        // Fall back to the simple case
                        log.error(sm.getString("managerBase.random", randomClass),
                            e);
                        this.random = new java.util.Random();
                        this.random.setSeed(seed);
                    }
                    long t2=System.currentTimeMillis();
                    if( (t2-t1) > 100 )
                        log.debug(sm.getString("managerBase.seeding", randomClass) + " " + (t2-t1));
                }
            }
        }

        return (this.random);
protected voidgetRandomBytes(byte[] bytes)

        // Generate a byte array containing a session identifier
        if( devRandomSource!=null && randomIS==null ) {
            setRandomFile( devRandomSource );
        }
        if(randomIS!=null ) {
            try {
                int len=randomIS.read( bytes );
                if( len==bytes.length ) {
                    return;
                }
                log.debug("Got " + len + " " + bytes.length );
            } catch( Exception ex ) {
            }
            devRandomSource=null;
            randomIS=null;
        }
        Random random = getRandom();
        getRandom().nextBytes(bytes);
public java.lang.StringgetRandomClass()
Return the random number generator class name.


        return (this.randomClass);
public java.lang.StringgetRandomFile()

        return devRandomSource;
public java.util.HashMapgetSession(java.lang.String sessionId)
Returns information about the session with the given session id.

The session information is organized as a HashMap, mapping session attribute names to the String representation of their values.

param
sessionId Session id
return
HashMap mapping session attribute names to the String representation of their values, or null if no session with the specified id exists, or if the session does not have any attributes

        Session s = (Session) sessions.get(sessionId);
        if (s == null) {
            if (log.isInfoEnabled()) {
                log.info("Session not found " + sessionId);
            }
            return null;
        }

        Enumeration ee = s.getSession().getAttributeNames();
        if (ee == null || !ee.hasMoreElements()) {
            return null;
        }

        HashMap map = new HashMap();
        while (ee.hasMoreElements()) {
            String attrName = (String) ee.nextElement();
            map.put(attrName, getSessionAttribute(sessionId, attrName));
        }

        return map;
public java.lang.StringgetSessionAttribute(java.lang.String sessionId, java.lang.String key)
For debugging: get a session attribute

param
sessionId
param
key
return

        Session s=(Session)sessions.get(sessionId);
        if( s==null ) {
            log.info("Session not found " + sessionId);
            return null;
        }
        Object o=s.getSession().getAttribute(key);
        if( o==null ) return null;
        return o.toString();
public intgetSessionAverageAliveTime()
Same as getSessionAverageAliveTimeSeconds

        return getSessionAverageAliveTimeSeconds();
public intgetSessionAverageAliveTimeSeconds()
Gets the average time (in seconds) that expired sessions had been alive.

return
Average time (in seconds) that expired sessions had been alive.

        return sessionAverageAliveTime;
public intgetSessionCount()
Total sessions created by this manager.

return
sessions created

        return sessionCounter;
public intgetSessionCounter()
Same as getSessionCount

        return getSessionCount();
public intgetSessionIdLength()
Gets the session id length (in bytes) of Sessions created by this Manager.

return
The session id length


        return (this.sessionIdLength);
public intgetSessionMaxAliveTime()
Same as getSessionMaxAliveTimeSeconds

        return getSessionMaxAliveTimeSeconds();
public intgetSessionMaxAliveTimeSeconds()
Gets the longest time (in seconds) that an expired session had been alive.

return
Longest time (in seconds) that an expired session had been alive.

        return sessionMaxAliveTime;
public com.sun.enterprise.util.uuid.UuidGeneratorgetUuidGenerator()
Return the UuidGenerator for this Manager. HERCULES:added


        return (this.uuidGenerator);
protected static IOUtilsCallergetWebUtilsCaller()
Gets the utility class used to call into services from com.sun.ejb.base.io.IOUtils.

        return webUtilsCaller;
public voidinit()

        if( initialized ) return;
        initialized=true;        
        
        if( oname==null ) {
            try {
                StandardContext ctx=(StandardContext)this.getContainer();
                Engine eng=(Engine)ctx.getParent().getParent();
                domain=ctx.getEngineName();
                distributable = ctx.getDistributable();
                StandardHost hst=(StandardHost)ctx.getParent();
                String path = ctx.getEncodedPath();
                if (path.equals("")) {
                    path = "/";
                }   
                oname=new ObjectName(domain + ":type=Manager,path="
                + path + ",host=" + hst.getName());
                Registry.getRegistry().registerComponent(this, oname, null );
            } catch (Exception e) {
                log.error("Error registering ",e);
            }
        }
        log.debug("Registering " + oname );
public booleanisSessionVersioningSupported()
Returns true if this session manager supports session versioning, false otherwise.

return
true if this session manager supports session versioning, false otherwise.

        return false;
public java.lang.StringlistSessionIds()
For debugging: return a list of all session ids currently active

        StringBuffer sb=new StringBuffer();
        Iterator keys=sessions.keySet().iterator();
        while( keys.hasNext() ) {
            sb.append(keys.next()).append(" ");
        }
        return sb.toString();
public booleanlockSession(javax.servlet.ServletRequest request)

        boolean result = false;
        if(sessionLocker != null) {
            result = sessionLocker.lockSession(request);
        }        
        return result;
protected voidlog(java.lang.String message)
Log a message on the Logger associated with our Container (if any).

param
message Message to be logged
deprecated

        log.info( message );
protected voidlog(java.lang.String message, java.lang.Throwable throwable)
Log a message on the Logger associated with our Container (if any).

param
message Message to be logged
param
throwable Associated exception
deprecated

        log.info(message,throwable);
public voidpostDeregister()
public voidpostRegister(java.lang.Boolean registrationDone)
public voidpostRequestDispatcherProcess(javax.servlet.ServletRequest request, javax.servlet.ServletResponse response)

        //deliberate no-op
        return;
public voidpreDeregister()
public javax.management.ObjectNamepreRegister(javax.management.MBeanServer server, javax.management.ObjectName name)

        oname=name;
        mserver=server;
        domain=name.getDomain();
        return name;
public voidpreRequestDispatcherProcess(javax.servlet.ServletRequest request, javax.servlet.ServletResponse response)

        //deliberate no-op
        return;
public voidrelease()

        clearSessions();
public voidremove(org.apache.catalina.Session session)
Remove this Session from the active Sessions for this Manager.

param
session Session to be removed


        synchronized (sessions) {
            sessions.remove(session.getIdInternal());
        }
public voidremovePropertyChangeListener(java.beans.PropertyChangeListener listener)
Remove a property change listener from this component.

param
listener The listener to remove


        support.removePropertyChangeListener(listener);
public voidsetAlgorithm(java.lang.String algorithm)
Set the message digest algorithm for this Manager.

param
algorithm The new message digest algorithm


        String oldAlgorithm = this.algorithm;
        this.algorithm = algorithm;
        support.firePropertyChange("algorithm", oldAlgorithm, this.algorithm);
public voidsetContainer(org.apache.catalina.Container container)
Set the Container with which this Manager is associated.

param
container The newly associated Container


        Container oldContainer = this.container;
        this.container = container;
        support.firePropertyChange("container", oldContainer, this.container);
        // TODO: find a good scheme for the log names
        //log=LogFactory.getLog("tomcat.manager." + container.getName());
public voidsetDebug(int debug)
Set the debugging detail level for this component.

param
debug The new debugging detail level


        this.debug = debug;
public voidsetDefaultContext(org.apache.catalina.DefaultContext defaultContext)
Set the DefaultContext with which this Manager is associated.

param
defaultContext The newly associated DefaultContext


        DefaultContext oldDefaultContext = this.defaultContext;
        this.defaultContext = defaultContext;
        support.firePropertyChange("defaultContext", oldDefaultContext, this.defaultContext);
public voidsetDistributable(boolean distributable)
Set the distributable flag for the sessions supported by this Manager. If this flag is set, all user data objects added to sessions associated with this manager must implement Serializable.

param
distributable The new distributable flag


        boolean oldDistributable = this.distributable;
        this.distributable = distributable;
        support.firePropertyChange("distributable",
                                   Boolean.valueOf(oldDistributable),
                                   Boolean.valueOf(this.distributable));
public voidsetDuplicates(int duplicates)

        this.duplicates = duplicates;
public voidsetEntropy(java.lang.String entropy)
Set the entropy increaser value.

param
entropy The new entropy increaser value


        String oldEntropy = entropy;
        this.entropy = entropy;
        support.firePropertyChange("entropy", oldEntropy, this.entropy);
public voidsetExpiredSessions(int expiredSessions)
Sets the number of sessions that have expired.

param
expiredSessions Number of sessions that have expired

        this.expiredSessions = expiredSessions;
public voidsetMaxActive(int maxActive)

        this.maxActive = maxActive;
public voidsetMaxInactiveInterval(int interval)
Same as setMaxInactiveIntervalSeconds

        setMaxInactiveIntervalSeconds(interval);
public voidsetMaxInactiveIntervalSeconds(int interval)
Set the default maximum inactive interval (in seconds) for Sessions created by this Manager.

param
interval The new default value


        int oldMaxInactiveInterval = this.maxInactiveInterval;
        this.maxInactiveInterval = interval;
        support.firePropertyChange("maxInactiveInterval",
                                   Integer.valueOf(oldMaxInactiveInterval),
                                   Integer.valueOf(this.maxInactiveInterval));
public voidsetRandomClass(java.lang.String randomClass)
Set the random number generator class name.

param
randomClass The new random number generator class name


        String oldRandomClass = this.randomClass;
        this.randomClass = randomClass;
        support.firePropertyChange("randomClass", oldRandomClass,
                                   this.randomClass);
public voidsetRandomFile(java.lang.String s)
Use /dev/random-type special device. This is new code, but may reduce the big delay in generating the random. You must specify a path to a random generator file. Use /dev/urandom for linux ( or similar ) systems. Use /dev/random for maximum security ( it may block if not enough "random" exist ). You can also use a pipe that generates random. The code will check if the file exists, and default to java Random if not found. There is a significant performance difference, very visible on the first call to getSession ( like in the first JSP ) - so use it if available.

    // as a hack, you can use a static file - and genarate the same
    // session ids ( good for strange debugging )
        if (Globals.IS_SECURITY_ENABLED){
                randomIS = (DataInputStream)AccessController.doPrivileged(new PrivilegedSetRandomFile());          
            } else {
                FileInputStream fileInputStream = null;
                try{
                    devRandomSource=s;
                    File f=new File( devRandomSource );
                    if( ! f.exists() ) return;
                    fileInputStream = new FileInputStream(f);
                    randomIS= new DataInputStream( fileInputStream);
                    randomIS.readLong();
                    if( log.isDebugEnabled() )
                        log.debug( "Opening " + devRandomSource );
                } catch( IOException ex ) {
                    randomIS=null;
                } finally {
                    try{
                        if ( fileInputStream != null )
                            fileInputStream.close();
                    } catch (IOException ex){
                        ;
                    }
                }
            }
public voidsetSessionAverageAliveTime(int sessionAverageAliveTime)
Same as setSessionAverageAliveTimeSeconds

        setSessionAverageAliveTimeSeconds(sessionAverageAliveTime);
public voidsetSessionAverageAliveTimeSeconds(int sessionAverageAliveTime)
Sets the average time (in seconds) that expired sessions had been alive.

param
sessionAverageAliveTime Average time (in seconds) that expired sessions had been alive.

        this.sessionAverageAliveTime = sessionAverageAliveTime;
public voidsetSessionCount(int sessionCounter)

        this.sessionCounter = sessionCounter;
public voidsetSessionCounter(int sessionCounter)
Same as setSessionCount

        setSessionCount(sessionCounter);
public voidsetSessionIDPrefix(java.lang.String prefix)
Enable/Disable prefixing the MD5 session id with a user specified string

        prefixSessionID_ = (prefix != null);
        if (prefixSessionID_)
            prefix_ = prefix;
public voidsetSessionIdLength(int idLength)
Sets the session id length (in bytes) for Sessions created by this Manager.

param
sessionIdLength The session id length


        int oldSessionIdLength = this.sessionIdLength;
        this.sessionIdLength = idLength;
        support.firePropertyChange("sessionIdLength",
                                   Integer.valueOf(oldSessionIdLength),
                                   Integer.valueOf(this.sessionIdLength));
public voidsetSessionLocker(org.apache.catalina.SessionLocker sessLocker)
set the pluggable sessionLocker for this manager by default it is pre-set to no-op BaseSessionLocker

        sessionLocker = sessLocker;
public voidsetSessionMaxAliveTime(int sessionMaxAliveTime)
Same as setSessionMaxAliveTimeSeconds

        setSessionMaxAliveTimeSeconds(sessionMaxAliveTime);
public voidsetSessionMaxAliveTimeSeconds(int sessionMaxAliveTime)
Sets the longest time (in seconds) that an expired session had been alive.

param
sessionMaxAliveTime Longest time (in seconds) that an expired session had been alive.

        this.sessionMaxAliveTime = sessionMaxAliveTime;
public voidsetUuidGenerator(com.sun.enterprise.util.uuid.UuidGenerator aUuidGenerator)
Set the UuidGenerator for this Manager. HERCULES:added


        uuidGenerator = aUuidGenerator;
public voidunlockSession(javax.servlet.ServletRequest request)

        if(sessionLocker != null) {
            sessionLocker.unlockSession(request);
        }
public voidupdate(javax.servlet.http.HttpSession session)
Perform any operations when the request is finished.

        return;