public  void add(Session session) 
{
        sessions.put(session.getIdInternal(), session);
        int size = sessions.size();
        if( size  > maxActive ) {
            maxActive = size;
        }
}

Add this Session to the set of active Sessions for this Manager.

 public  void addPropertyChangeListener(PropertyChangeListener listener) 
{
        support.addPropertyChangeListener(listener);
}

Add a property change listener to this component.

 public  void backgroundProcess() 
{
        count = (count + 1) % processExpiresFrequency;
        if (count == 0)
            processExpires();
}

Implements the Manager interface, direct call to processExpires

 public Session createEmptySession() 
{
        return (getNewSession());
}

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.

 public Session createSession() 
{
        return createSession(null);
}

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.

 public Session createSession(String sessionId) 
{
        
        // 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);
        if (sessionId == null) {
            sessionId = generateSessionId();
        // FIXME WHy we need no duplication check?
        /*         
             synchronized (sessions) {
                while (sessions.get(sessionId) != null) { // Guarantee
                    // uniqueness
                    duplicates++;
                    sessionId = generateSessionId();
                }
            }
        */
            // FIXME: Code to be used in case route replacement is needed
            /*
        } else {
            String jvmRoute = getJvmRoute();
            if (getJvmRoute() != null) {
                String requestJvmRoute = null;
                int index = sessionId.indexOf(".");
                if (index  > 0) {
                    requestJvmRoute = sessionId
                            .substring(index + 1, sessionId.length());
                }
                if (requestJvmRoute != null && !requestJvmRoute.equals(jvmRoute)) {
                    sessionId = sessionId.substring(0, index) + "." + jvmRoute;
                }
            }
            */
        }
        session.setId(sessionId);
        sessionCounter++;
        return (session);
}

Construct and return a new session object, based on the default settings specified by this Manager's properties. The session id specified will be used as the session id. If a new session cannot be created for any reason, return null.

 public  void destroy() 
{
        if( oname != null )
            Registry.getRegistry(null, null).unregisterComponent(oname);
        initialized=false;
        oname = null;
}

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

 public Session findSession(String id) throws IOException 
{
        if (id == null)
            return (null);
        return (Session) sessions.get(id);
}

Return the active Session, associated with this Manager, with the specified session id (if any); otherwise return null.

 public Session[] findSessions() 
{
        return sessions.values().toArray(new Session[0]);
}

Return the set of active Sessions associated with this Manager. If this Manager has no active Sessions, a zero-length array is returned.

 protected synchronized String generateSessionId() 
{
        byte random[] = new byte[16];
        String jvmRoute = getJvmRoute();
        String result = null;
        // Render the result as a String of hexadecimal digits
        StringBuffer buffer = new StringBuffer();
        do {
            int resultLenBytes = 0;
            if (result != null) {
                buffer = new StringBuffer();
                duplicates++;
            }
            while (resultLenBytes <  this.sessionIdLength) {
                getRandomBytes(random);
                random = getDigest().digest(random);
                for (int j = 0;
                j <  random.length && resultLenBytes <  this.sessionIdLength;
                j++) {
                    byte b1 = (byte) ((random[j] & 0xf0)  > > 4);
                    byte b2 = (byte) (random[j] & 0x0f);
                    if (b1 <  10)
                        buffer.append((char) ('0" + b1));
                    else
                        buffer.append((char) ('A" + (b1 - 10)));
                    if (b2 <  10)
                        buffer.append((char) ('0" + b2));
                    else
                        buffer.append((char) ('A" + (b2 - 10)));
                    resultLenBytes++;
                }
            }
            if (jvmRoute != null) {
                buffer.append('.").append(jvmRoute);
            }
            result = buffer.toString();
        } while (sessions.containsKey(result));
        return (result);
}

Generate and return a new session identifier.

 public int getActiveSessions() 
{
        return sessions.size();
}

Returns the number of active sessions

 public String getAlgorithm() 
{
        return (this.algorithm);
}

Return the message digest algorithm for this Manager.

 public String getClassName() 
{
        return this.getClass().getName();
}

Returns the name of the implementation class.

 public Container getContainer() 
{
        return (this.container);
}

Return the Container with which this Manager is associated.

 public String getCreationTime(String sessionId) 
{
        Session s=(Session)sessions.get(sessionId);
        if( s==null ) {
            if(log.isInfoEnabled())
                log.info("Session not found " + sessionId);
            return "";
        }
        return new Date(s.getCreationTime()).toString();
}

 public synchronized MessageDigest getDigest() 
{
        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);
}

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.

 public boolean getDistributable() 
{
        return (this.distributable);
}

Return the distributable flag for the sessions supported by this Manager.

 public String getDomain() 
{
        return domain;
}

 public int getDuplicates() 
{
        return duplicates;
}

Number of duplicated session IDs generated by the random source. Anything bigger than 0 means problems.

 public Engine getEngine() 
{
        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;
}

Retrieve the enclosing Engine for this Manager.

 public String getEntropy() 
{
        // Calculate a semi-useful value if this has not been set
        if (this.entropy == null) {
            // Use APR to get a crypto secure entropy value
            byte[] result = new byte[32];
            boolean apr = false;
            try {
                String methodName = "random";
                Class paramTypes[] = new Class[2];
                paramTypes[0] = result.getClass();
                paramTypes[1] = int.class;
                Object paramValues[] = new Object[2];
                paramValues[0] = result;
                paramValues[1] = new Integer(32);
                Method method = Class.forName("org.apache.tomcat.jni.OS")
                    .getMethod(methodName, paramTypes);
                method.invoke(null, paramValues);
                apr = true;
            } catch (Throwable t) {
                // Ignore
            }
            if (apr) {
                setEntropy(new String(result));
            } else {
                setEntropy(this.toString());
            }
        }
        return (this.entropy);
}

Return the entropy increaser value, or compute a semi-useful value if this String has not yet been set.

 public int getExpiredSessions() 
{
        return expiredSessions;
}

Gets the number of sessions that have expired.

 public String getInfo() 
{
        return (info);
}

Return descriptive information about this Manager implementation and the corresponding version number, in the format <description>/<version>.

 public String getJvmRoute() 
{
        Engine e = getEngine();
        return e == null ? null : e.getJvmRoute();
}

Retrieve the JvmRoute for the enclosing Engine.

 public String getLastAccessedTime(String sessionId) 
{
        Session s=(Session)sessions.get(sessionId);
        if( s==null ) {
            if(log.isInfoEnabled())
                log.info("Session not found " + sessionId);
            return "";
        }
        return new Date(s.getLastAccessedTime()).toString();
}

 public int getMaxActive() 
{
        return maxActive;
}

Max number of concurrent active sessions

 public int getMaxInactiveInterval() 
{
        return (this.maxInactiveInterval);
}

Return the default maximum inactive interval (in seconds) for Sessions created by this Manager.

 public String getName() 
{
        return (name);
}

Return the descriptive short name of this Manager implementation.

 protected StandardSession getNewSession() 
{
        return new StandardSession(this);
}

Get new session class to be used in the doLoad() method.

 public ObjectName getObjectName() 
{
        return oname;
}

 public int getProcessExpiresFrequency() 
{
        return (this.processExpiresFrequency);
}

Return the frequency of manager checks.

 public long getProcessingTime() 
{
        return processingTime;
}

 public Random getRandom() 
{
        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);
            }
            if(log.isDebugEnabled()) {
                long t2=System.currentTimeMillis();
                if( (t2-t1)  > 100 )
                    log.debug(sm.getString("managerBase.seeding", randomClass) + " " + (t2-t1));
            }
        }
        return (this.random);
}

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.

 protected  void getRandomBytes(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;
                }
                if(log.isDebugEnabled())
                    log.debug("Got " + len + " " + bytes.length );
            } catch (Exception ex) {
                // Ignore
            }
            devRandomSource = null;
            try {
                randomIS.close();
            } catch (Exception e) {
                log.warn("Failed to close randomIS.");
            }
            randomIS = null;
        }
        getRandom().nextBytes(bytes);
}

 public String getRandomClass() 
{
        return (this.randomClass);
}

Return the random number generator class name.

 public String getRandomFile() 
{
        return devRandomSource;
}

 public HashMap getSession(String sessionId) 
{
        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;
}

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.

 public String getSessionAttribute(String sessionId,
    String key) 
{
        Session s = (Session) sessions.get(sessionId);
        if( s==null ) {
            if(log.isInfoEnabled())
                log.info("Session not found " + sessionId);
            return null;
        }
        Object o=s.getSession().getAttribute(key);
        if( o==null ) return null;
        return o.toString();
}

For debugging: get a session attribute

 public int getSessionAverageAliveTime() 
{
        return sessionAverageAliveTime;
}

Gets the average time (in seconds) that expired sessions had been alive.

 public int getSessionCounter() 
{
        return sessionCounter;
}

Total sessions created by this manager.

 public int getSessionIdLength() 
{
        return (this.sessionIdLength);
}

Gets the session id length (in bytes) of Sessions created by this Manager.

 public int getSessionMaxAliveTime() 
{
        return sessionMaxAliveTime;
}

Gets the longest time (in seconds) that an expired session had been alive.

 public  void init() 
{
        if( initialized ) return;
        initialized=true;        
        log = LogFactory.getLog(ManagerBase.class);
        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.getPath();
                if (path.equals("")) {
                    path = "/";
                }   
                oname=new ObjectName(domain + ":type=Manager,path="
                + path + ",host=" + hst.getName());
                Registry.getRegistry(null, null).registerComponent(this, oname, null );
            } catch (Exception e) {
                log.error("Error registering ",e);
            }
        }
        // Initialize random number generation
        getRandomBytes(new byte[16]);
        if(log.isDebugEnabled())
            log.debug("Registering " + oname );
}

 public String listSessionIds() 
{
        StringBuffer sb=new StringBuffer();
        Iterator keys = sessions.keySet().iterator();
        while (keys.hasNext()) {
            sb.append(keys.next()).append(" ");
        }
        return sb.toString();
}

For debugging: return a list of all session ids currently active

 public  void postDeregister() 
{

}

 public  void postRegister(Boolean registrationDone) 
{

}

 public  void preDeregister() throws Exception 
{

}

 public ObjectName preRegister(MBeanServer server,
    ObjectName name) throws Exception 
{
        oname=name;
        mserver=server;
        domain=name.getDomain();
        return name;
}

 public  void processExpires() 
{
        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()) {
                expireHere++;
            }
        }
        long timeEnd = System.currentTimeMillis();
        if(log.isDebugEnabled())
             log.debug("End expire sessions " + getName() + " processingTime " + (timeEnd - timeNow) + " expired sessions: " + expireHere);
        processingTime += ( timeEnd - timeNow );
}

Invalidate all sessions that have expired.

 public  void remove(Session session) 
{
        sessions.remove(session.getIdInternal());
}

Remove this Session from the active Sessions for this Manager.

 public  void removePropertyChangeListener(PropertyChangeListener listener) 
{
        support.removePropertyChangeListener(listener);
}

Remove a property change listener from this component.

 public  void setAlgorithm(String algorithm) 
{
        String oldAlgorithm = this.algorithm;
        this.algorithm = algorithm;
        support.firePropertyChange("algorithm", oldAlgorithm, this.algorithm);
}

Set the message digest algorithm for this Manager.

 public  void setContainer(Container container) 
{
        Container oldContainer = this.container;
        this.container = container;
        support.firePropertyChange("container", oldContainer, this.container);
}

Set the Container with which this Manager is associated.

 public  void setDistributable(boolean distributable) 
{
        boolean oldDistributable = this.distributable;
        this.distributable = distributable;
        support.firePropertyChange("distributable",
                                   new Boolean(oldDistributable),
                                   new Boolean(this.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.

 public  void setDuplicates(int duplicates) 
{
        this.duplicates = duplicates;
}

 public  void setEntropy(String entropy) 
{
        String oldEntropy = entropy;
        this.entropy = entropy;
        support.firePropertyChange("entropy", oldEntropy, this.entropy);
}

Set the entropy increaser value.

 public  void setExpiredSessions(int expiredSessions) 
{
        this.expiredSessions = expiredSessions;
}

Sets the number of sessions that have expired.

 public  void setMaxActive(int maxActive) 
{
        this.maxActive = maxActive;
}

 public  void setMaxInactiveInterval(int interval) 
{
        int oldMaxInactiveInterval = this.maxInactiveInterval;
        this.maxInactiveInterval = interval;
        support.firePropertyChange("maxInactiveInterval",
                                   new Integer(oldMaxInactiveInterval),
                                   new Integer(this.maxInactiveInterval));
}

Set the default maximum inactive interval (in seconds) for Sessions created by this Manager.

 public  void setProcessExpiresFrequency(int processExpiresFrequency) 
{
        if (processExpiresFrequency < = 0) {
            return;
        }
        int oldProcessExpiresFrequency = this.processExpiresFrequency;
        this.processExpiresFrequency = processExpiresFrequency;
        support.firePropertyChange("processExpiresFrequency",
                                   new Integer(oldProcessExpiresFrequency),
                                   new Integer(this.processExpiresFrequency));
}

Set the manager checks frequency.

 public  void setProcessingTime(long processingTime) 
{
        this.processingTime = processingTime;
}

 public  void setRandomClass(String randomClass) 
{
        String oldRandomClass = this.randomClass;
        this.randomClass = randomClass;
        support.firePropertyChange("randomClass", oldRandomClass,
                                   this.randomClass);
}

Set the random number generator class name.

 public  void setRandomFile(String s) 
{
        // 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 {
            try{
                devRandomSource=s;
                File f=new File( devRandomSource );
                if( ! f.exists() ) return;
                randomIS= new DataInputStream( new FileInputStream(f));
                randomIS.readLong();
                if( log.isDebugEnabled() )
                    log.debug( "Opening " + devRandomSource );
            } catch( IOException ex ) {
                try {
                    randomIS.close();
                } catch (Exception e) {
                    log.warn("Failed to close randomIS.");
                }
                randomIS=null;
            }
        }
}

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.

 public  void setSessionAverageAliveTime(int sessionAverageAliveTime) 
{
        this.sessionAverageAliveTime = sessionAverageAliveTime;
}

Sets the average time (in seconds) that expired sessions had been alive.

 public  void setSessionCounter(int sessionCounter) 
{
        this.sessionCounter = sessionCounter;
}

 public  void setSessionIdLength(int idLength) 
{
        int oldSessionIdLength = this.sessionIdLength;
        this.sessionIdLength = idLength;
        support.firePropertyChange("sessionIdLength",
                                   new Integer(oldSessionIdLength),
                                   new Integer(this.sessionIdLength));
}

Sets the session id length (in bytes) for Sessions created by this Manager.

 public  void setSessionMaxAliveTime(int sessionMaxAliveTime) 
{
        this.sessionMaxAliveTime = sessionMaxAliveTime;
}

Sets the longest time (in seconds) that an expired session had been alive.