1060 lines
33 KiB
Java
1060 lines
33 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.apache.catalina.session;
|
|
|
|
import java.io.IOException;
|
|
import java.security.AccessController;
|
|
import java.security.PrivilegedActionException;
|
|
import java.security.PrivilegedExceptionAction;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import org.apache.catalina.Lifecycle;
|
|
import org.apache.catalina.LifecycleException;
|
|
import org.apache.catalina.LifecycleState;
|
|
import org.apache.catalina.Session;
|
|
import org.apache.catalina.Store;
|
|
import org.apache.catalina.StoreManager;
|
|
import org.apache.catalina.security.SecurityUtil;
|
|
import org.apache.juli.logging.Log;
|
|
import org.apache.juli.logging.LogFactory;
|
|
/**
|
|
* Extends the {@link ManagerBase} class to implement most of the
|
|
* functionality required by a Manager which supports any kind of
|
|
* persistence, even if only for restarts.
|
|
* <p>
|
|
* <b>IMPLEMENTATION NOTE</b>: Correct behavior of session storing and
|
|
* reloading depends upon external calls to the {@link Lifecycle#start()}
|
|
* and {@link Lifecycle#stop()} methods of this class
|
|
* at the correct times.
|
|
*
|
|
* @author Craig R. McClanahan
|
|
*/
|
|
public abstract class PersistentManagerBase extends ManagerBase
|
|
implements StoreManager {
|
|
|
|
private final Log log = LogFactory.getLog(PersistentManagerBase.class); // must not be static
|
|
|
|
// ---------------------------------------------------- Security Classes
|
|
|
|
private class PrivilegedStoreClear
|
|
implements PrivilegedExceptionAction<Void> {
|
|
|
|
PrivilegedStoreClear() {
|
|
// NOOP
|
|
}
|
|
|
|
@Override
|
|
public Void run() throws Exception{
|
|
store.clear();
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private class PrivilegedStoreRemove
|
|
implements PrivilegedExceptionAction<Void> {
|
|
|
|
private String id;
|
|
|
|
PrivilegedStoreRemove(String id) {
|
|
this.id = id;
|
|
}
|
|
|
|
@Override
|
|
public Void run() throws Exception{
|
|
store.remove(id);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private class PrivilegedStoreLoad
|
|
implements PrivilegedExceptionAction<Session> {
|
|
|
|
private String id;
|
|
|
|
PrivilegedStoreLoad(String id) {
|
|
this.id = id;
|
|
}
|
|
|
|
@Override
|
|
public Session run() throws Exception{
|
|
return store.load(id);
|
|
}
|
|
}
|
|
|
|
private class PrivilegedStoreSave
|
|
implements PrivilegedExceptionAction<Void> {
|
|
|
|
private Session session;
|
|
|
|
PrivilegedStoreSave(Session session) {
|
|
this.session = session;
|
|
}
|
|
|
|
@Override
|
|
public Void run() throws Exception{
|
|
store.save(session);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private class PrivilegedStoreKeys
|
|
implements PrivilegedExceptionAction<String[]> {
|
|
|
|
PrivilegedStoreKeys() {
|
|
// NOOP
|
|
}
|
|
|
|
@Override
|
|
public String[] run() throws Exception{
|
|
return store.keys();
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------- Instance Variables
|
|
|
|
/**
|
|
* The descriptive name of this Manager implementation (for logging).
|
|
*/
|
|
private static final String name = "PersistentManagerBase";
|
|
|
|
/**
|
|
* Key of the note of a session in which the timestamp of last backup is stored.
|
|
*/
|
|
private static final String PERSISTED_LAST_ACCESSED_TIME =
|
|
"org.apache.catalina.session.PersistentManagerBase.persistedLastAccessedTime";
|
|
|
|
|
|
/**
|
|
* Store object which will manage the Session store.
|
|
*/
|
|
protected Store store = null;
|
|
|
|
|
|
/**
|
|
* Whether to save and reload sessions when the Manager <code>unload</code>
|
|
* and <code>load</code> methods are called.
|
|
*/
|
|
protected boolean saveOnRestart = true;
|
|
|
|
|
|
/**
|
|
* How long a session must be idle before it should be backed up.
|
|
* {@code -1} means sessions won't be backed up.
|
|
*/
|
|
protected int maxIdleBackup = -1;
|
|
|
|
|
|
/**
|
|
* The minimum time in seconds a session must be idle before it is eligible
|
|
* to be swapped to disk to keep the active session count below
|
|
* maxActiveSessions. Setting to {@code -1} means sessions will not be
|
|
* swapped out to keep the active session count down.
|
|
*/
|
|
protected int minIdleSwap = -1;
|
|
|
|
|
|
/**
|
|
* The maximum time in seconds a session may be idle before it is eligible
|
|
* to be swapped to disk due to inactivity. Setting this to {@code -1} means
|
|
* sessions should not be swapped out just because of inactivity.
|
|
*/
|
|
protected int maxIdleSwap = -1;
|
|
|
|
|
|
/**
|
|
* Sessions currently being swapped in and the associated locks
|
|
*/
|
|
private final Map<String,Object> sessionSwapInLocks = new HashMap<>();
|
|
|
|
/*
|
|
* Session that is currently getting swapped in to prevent loading it more
|
|
* than once concurrently
|
|
*/
|
|
private final ThreadLocal<Session> sessionToSwapIn = new ThreadLocal<>();
|
|
|
|
|
|
// ------------------------------------------------------------- Properties
|
|
|
|
|
|
/**
|
|
* 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. {@code -1} means sessions
|
|
* are not backed up.
|
|
*
|
|
* @return the timeout after which sessions are ripe for back up
|
|
*/
|
|
public int getMaxIdleBackup() {
|
|
|
|
return maxIdleBackup;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* 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: {@code -1}
|
|
* means sessions are not backed up.
|
|
* <p>
|
|
* Note that this is not a hard limit: sessions are checked
|
|
* against this age limit periodically according to {@code processExpiresFrequency}.
|
|
* This value should be considered to indicate when a session is
|
|
* ripe for backing up.
|
|
* <p>
|
|
* So it is possible that a session may be idle for {@code maxIdleBackup +
|
|
* processExpiresFrequency * engine.backgroundProcessorDelay} seconds, plus the time it takes to handle other
|
|
* session expiration, swapping, etc. tasks.
|
|
*
|
|
* @param backup The number of seconds after their last accessed
|
|
* time when they should be written to the Store.
|
|
*/
|
|
public void setMaxIdleBackup (int backup) {
|
|
|
|
if (backup == this.maxIdleBackup)
|
|
return;
|
|
int oldBackup = this.maxIdleBackup;
|
|
this.maxIdleBackup = backup;
|
|
support.firePropertyChange("maxIdleBackup",
|
|
Integer.valueOf(oldBackup),
|
|
Integer.valueOf(this.maxIdleBackup));
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* @return The maximum time in seconds a session may be idle before it is
|
|
* eligible to be swapped to disk due to inactivity. A value of {@code -1}
|
|
* means sessions should not be swapped out just because of inactivity.
|
|
*/
|
|
public int getMaxIdleSwap() {
|
|
return maxIdleSwap;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the maximum time in seconds a session may be idle before it is
|
|
* eligible to be swapped to disk due to inactivity. Setting this to
|
|
* {@code -1} means sessions should not be swapped out just because of
|
|
* inactivity.
|
|
*
|
|
* @param max time in seconds to wait for possible swap out
|
|
*/
|
|
public void setMaxIdleSwap(int max) {
|
|
|
|
if (max == this.maxIdleSwap)
|
|
return;
|
|
int oldMaxIdleSwap = this.maxIdleSwap;
|
|
this.maxIdleSwap = max;
|
|
support.firePropertyChange("maxIdleSwap",
|
|
Integer.valueOf(oldMaxIdleSwap),
|
|
Integer.valueOf(this.maxIdleSwap));
|
|
}
|
|
|
|
|
|
/**
|
|
* @return The minimum time in seconds a session must be idle before it is
|
|
* eligible to be swapped to disk to keep the active session count below
|
|
* maxActiveSessions. A value of {@code -1} means sessions will not be
|
|
* swapped out to keep the active session count down.
|
|
*/
|
|
public int getMinIdleSwap() {
|
|
return minIdleSwap;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the minimum time in seconds a session must be idle before it is
|
|
* eligible to be swapped to disk to keep the active session count below
|
|
* maxActiveSessions. Setting to {@code -1} means sessions will not be
|
|
* swapped out to keep the active session count down.
|
|
*
|
|
* @param min time in seconds before a possible swap out
|
|
*/
|
|
public void setMinIdleSwap(int min) {
|
|
|
|
if (this.minIdleSwap == min)
|
|
return;
|
|
int oldMinIdleSwap = this.minIdleSwap;
|
|
this.minIdleSwap = min;
|
|
support.firePropertyChange("minIdleSwap",
|
|
Integer.valueOf(oldMinIdleSwap),
|
|
Integer.valueOf(this.minIdleSwap));
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Check, whether a session is loaded in memory
|
|
*
|
|
* @param id The session id for the session to be searched for
|
|
* @return {@code true}, if the session id is loaded in memory
|
|
* otherwise {@code false} is returned
|
|
*/
|
|
public boolean isLoaded( String id ){
|
|
try {
|
|
if ( super.findSession(id) != null )
|
|
return true;
|
|
} catch (IOException e) {
|
|
log.error("checking isLoaded for id, " + id + ", "+e.getMessage(), e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
@Override
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the Store object which will manage persistent Session
|
|
* storage for this Manager.
|
|
*
|
|
* @param store the associated Store
|
|
*/
|
|
public void setStore(Store store) {
|
|
this.store = store;
|
|
store.setManager(this);
|
|
}
|
|
|
|
|
|
/**
|
|
* @return the Store object which manages persistent Session
|
|
* storage for this Manager.
|
|
*/
|
|
@Override
|
|
public Store getStore() {
|
|
return this.store;
|
|
}
|
|
|
|
|
|
/**
|
|
* Indicates whether sessions are saved when the Manager is shut down
|
|
* properly. This requires the {@link #unload()} method to be called.
|
|
*
|
|
* @return {@code true}, when sessions should be saved on restart,
|
|
* {code false} otherwise
|
|
*/
|
|
public boolean getSaveOnRestart() {
|
|
|
|
return 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.
|
|
*
|
|
* @param saveOnRestart {@code true} if sessions should be saved on restart, {@code false} if
|
|
* they should be ignored.
|
|
*/
|
|
public void setSaveOnRestart(boolean saveOnRestart) {
|
|
|
|
if (saveOnRestart == this.saveOnRestart)
|
|
return;
|
|
|
|
boolean oldSaveOnRestart = this.saveOnRestart;
|
|
this.saveOnRestart = saveOnRestart;
|
|
support.firePropertyChange("saveOnRestart",
|
|
Boolean.valueOf(oldSaveOnRestart),
|
|
Boolean.valueOf(this.saveOnRestart));
|
|
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------- Public Methods
|
|
|
|
|
|
/**
|
|
* Clear all sessions from the Store.
|
|
*/
|
|
public void clearStore() {
|
|
|
|
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);
|
|
}
|
|
} else {
|
|
store.clear();
|
|
}
|
|
} catch (IOException e) {
|
|
log.error("Exception clearing the Store: " + e, e);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* <p>
|
|
* Direct call to processExpires and processPersistenceChecks
|
|
*/
|
|
@Override
|
|
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()) {
|
|
expiredSessions.incrementAndGet();
|
|
expireHere++;
|
|
}
|
|
}
|
|
processPersistenceChecks();
|
|
if (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);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* 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 processPersistenceChecks() {
|
|
|
|
processMaxIdleSwaps();
|
|
processMaxActiveSwaps();
|
|
processMaxIdleBackups();
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* <p>
|
|
* This method checks the persistence store if persistence is enabled,
|
|
* otherwise just uses the functionality from ManagerBase.
|
|
*/
|
|
@Override
|
|
public Session findSession(String id) throws IOException {
|
|
|
|
Session session = super.findSession(id);
|
|
// OK, at this point, we're not sure if another thread is trying to
|
|
// remove the session or not so the only way around this is to lock it
|
|
// (or attempt to) and then try to get it by this session id again. If
|
|
// the other code ran swapOut, then we should get a null back during
|
|
// this run, and if not, we lock it out so we can access the session
|
|
// safely.
|
|
if(session != null) {
|
|
synchronized(session){
|
|
session = super.findSession(session.getIdInternal());
|
|
if(session != null){
|
|
// To keep any external calling code from messing up the
|
|
// concurrency.
|
|
session.access();
|
|
session.endAccess();
|
|
}
|
|
}
|
|
}
|
|
if (session != null)
|
|
return session;
|
|
|
|
// See if the Session is in the Store
|
|
session = swapIn(id);
|
|
return session;
|
|
}
|
|
|
|
/**
|
|
* Remove this Session from the active Sessions for this Manager,
|
|
* but not from the Store. (Used by the PersistentValve)
|
|
*
|
|
* @param session Session to be removed
|
|
*/
|
|
@Override
|
|
public void removeSuper(Session session) {
|
|
super.remove(session, false);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
* <p>
|
|
* 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.
|
|
*/
|
|
@Override
|
|
public void load() {
|
|
|
|
// Initialize our internal data structures
|
|
sessions.clear();
|
|
|
|
if (store == null)
|
|
return;
|
|
|
|
String[] ids = null;
|
|
try {
|
|
if (SecurityUtil.isPackageProtectionEnabled()){
|
|
try{
|
|
ids = AccessController.doPrivileged(
|
|
new PrivilegedStoreKeys());
|
|
}catch(PrivilegedActionException ex){
|
|
Exception exception = ex.getException();
|
|
log.error("Exception in the Store during load: "
|
|
+ exception, exception);
|
|
return;
|
|
}
|
|
} 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);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* {@inheritDoc}
|
|
* <p>
|
|
* Remove this Session from the Store.
|
|
*/
|
|
@Override
|
|
public void remove(Session session, boolean update) {
|
|
|
|
super.remove (session, update);
|
|
|
|
if (store != null){
|
|
removeSession(session.getIdInternal());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Remove this Session from the active Sessions for this Manager,
|
|
* and from the Store.
|
|
*
|
|
* @param id Session's id to be removed
|
|
*/
|
|
protected void removeSession(String id){
|
|
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);
|
|
}
|
|
} else {
|
|
store.remove(id);
|
|
}
|
|
} catch (IOException e) {
|
|
log.error("Exception removing session " + e.getMessage(), e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Save all currently active sessions in the appropriate persistence
|
|
* mechanism, if any. If persistence is not supported, this method
|
|
* returns without doing anything.
|
|
* <p>
|
|
* 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.
|
|
*/
|
|
@Override
|
|
public void unload() {
|
|
|
|
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()
|
|
}
|
|
|
|
}
|
|
|
|
|
|
@Override
|
|
public int getActiveSessionsFull() {
|
|
// In memory session count
|
|
int result = getActiveSessions();
|
|
try {
|
|
// Store session count
|
|
result += getStore().getSize();
|
|
} catch (IOException ioe) {
|
|
log.warn(sm.getString("persistentManager.storeSizeException"));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
@Override
|
|
public Set<String> getSessionIdsFull() {
|
|
Set<String> sessionIds = new HashSet<>();
|
|
// In memory session ID list
|
|
sessionIds.addAll(sessions.keySet());
|
|
// Store session ID list
|
|
String[] storeKeys;
|
|
try {
|
|
storeKeys = getStore().keys();
|
|
for (String storeKey : storeKeys) {
|
|
sessionIds.add(storeKey);
|
|
}
|
|
} catch (IOException e) {
|
|
log.warn(sm.getString("persistentManager.storeKeysException"));
|
|
}
|
|
return sessionIds;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------ Protected Methods
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param id The id of the session that should be swapped in
|
|
* @return restored session, or {@code null}, if none is found
|
|
* @throws IOException an IO error occurred
|
|
*/
|
|
protected Session swapIn(String id) throws IOException {
|
|
|
|
if (store == null)
|
|
return null;
|
|
|
|
Object swapInLock = null;
|
|
|
|
/*
|
|
* The purpose of this sync and these locks is to make sure that a
|
|
* session is only loaded once. It doesn't matter if the lock is removed
|
|
* and then another thread enters this method and tries to load the same
|
|
* session. That thread will re-create a swapIn lock for that session,
|
|
* quickly find that the session is already in sessions, use it and
|
|
* carry on.
|
|
*/
|
|
synchronized (this) {
|
|
swapInLock = sessionSwapInLocks.get(id);
|
|
if (swapInLock == null) {
|
|
swapInLock = new Object();
|
|
sessionSwapInLocks.put(id, swapInLock);
|
|
}
|
|
}
|
|
|
|
Session session = null;
|
|
|
|
synchronized (swapInLock) {
|
|
// First check to see if another thread has loaded the session into
|
|
// the manager
|
|
session = sessions.get(id);
|
|
|
|
if (session == null) {
|
|
Session currentSwapInSession = sessionToSwapIn.get();
|
|
try {
|
|
if (currentSwapInSession == null || !id.equals(currentSwapInSession.getId())) {
|
|
session = loadSessionFromStore(id);
|
|
sessionToSwapIn.set(session);
|
|
|
|
if (session != null && !session.isValid()) {
|
|
log.error(sm.getString("persistentManager.swapInInvalid", id));
|
|
session.expire();
|
|
removeSession(id);
|
|
session = null;
|
|
}
|
|
|
|
if (session != null) {
|
|
reactivateLoadedSession(id, session);
|
|
}
|
|
}
|
|
} finally {
|
|
sessionToSwapIn.remove();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure the lock is removed
|
|
synchronized (this) {
|
|
sessionSwapInLocks.remove(id);
|
|
}
|
|
|
|
return session;
|
|
|
|
}
|
|
|
|
private void reactivateLoadedSession(String id, Session session) {
|
|
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();
|
|
// endAccess() to ensure timeouts happen correctly.
|
|
// access() to keep access count correct or it will end up
|
|
// negative
|
|
session.access();
|
|
session.endAccess();
|
|
}
|
|
|
|
private Session loadSessionFromStore(String id) throws IOException {
|
|
try {
|
|
if (SecurityUtil.isPackageProtectionEnabled()){
|
|
return securedStoreLoad(id);
|
|
} else {
|
|
return store.load(id);
|
|
}
|
|
} catch (ClassNotFoundException e) {
|
|
String msg = sm.getString(
|
|
"persistentManager.deserializeError", id);
|
|
log.error(msg, e);
|
|
throw new IllegalStateException(msg, e);
|
|
}
|
|
}
|
|
|
|
|
|
private Session securedStoreLoad(String id) throws IOException, ClassNotFoundException {
|
|
try {
|
|
return AccessController.doPrivileged(
|
|
new PrivilegedStoreLoad(id));
|
|
} catch (PrivilegedActionException ex) {
|
|
Exception e = ex.getException();
|
|
log.error(sm.getString(
|
|
"persistentManager.swapInException", id),
|
|
e);
|
|
if (e instanceof IOException){
|
|
throw (IOException)e;
|
|
} else if (e instanceof ClassNotFoundException) {
|
|
throw (ClassNotFoundException)e;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* @param session The Session to write out
|
|
* @throws IOException an IO error occurred
|
|
*/
|
|
protected void swapOut(Session session) throws IOException {
|
|
|
|
if (store == null || !session.isValid()) {
|
|
return;
|
|
}
|
|
|
|
((StandardSession)session).passivate();
|
|
writeSession(session);
|
|
super.remove(session, true);
|
|
session.recycle();
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* 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.
|
|
* @param session The session that should be written
|
|
* @throws IOException an IO error occurred
|
|
*/
|
|
protected void writeSession(Session session) throws IOException {
|
|
|
|
if (store == null || !session.isValid()) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
if (SecurityUtil.isPackageProtectionEnabled()){
|
|
try{
|
|
AccessController.doPrivileged(new PrivilegedStoreSave(session));
|
|
}catch(PrivilegedActionException ex){
|
|
Exception exception = ex.getException();
|
|
if (exception instanceof IOException) {
|
|
throw (IOException) exception;
|
|
}
|
|
log.error("Exception in the Store during writeSession: "
|
|
+ exception, exception);
|
|
}
|
|
} else {
|
|
store.save(session);
|
|
}
|
|
} catch (IOException e) {
|
|
log.error(sm.getString
|
|
("persistentManager.serializeError", session.getIdInternal(), e));
|
|
throw e;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Start this component and implement the requirements
|
|
* of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
|
|
*
|
|
* @exception LifecycleException if this component detects a fatal error
|
|
* that prevents this component from being used
|
|
*/
|
|
@Override
|
|
protected synchronized void startInternal() throws LifecycleException {
|
|
|
|
super.startInternal();
|
|
|
|
if (store == null)
|
|
log.error("No Store configured, persistence disabled");
|
|
else if (store instanceof Lifecycle)
|
|
((Lifecycle)store).start();
|
|
|
|
setState(LifecycleState.STARTING);
|
|
}
|
|
|
|
|
|
/**
|
|
* Stop this component and implement the requirements
|
|
* of {@link org.apache.catalina.util.LifecycleBase#stopInternal()}.
|
|
*
|
|
* @exception LifecycleException if this component detects a fatal error
|
|
* that prevents this component from being used
|
|
*/
|
|
@Override
|
|
protected synchronized void stopInternal() throws LifecycleException {
|
|
|
|
if (log.isDebugEnabled())
|
|
log.debug("Stopping");
|
|
|
|
setState(LifecycleState.STOPPING);
|
|
|
|
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() instanceof Lifecycle) {
|
|
((Lifecycle)getStore()).stop();
|
|
}
|
|
|
|
// Require a new random number generator if we are restarted
|
|
super.stopInternal();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------ Protected Methods
|
|
|
|
|
|
/**
|
|
* Swap idle sessions out to Store if they are idle too long.
|
|
*/
|
|
protected void processMaxIdleSwaps() {
|
|
|
|
if (!getState().isAvailable() || maxIdleSwap < 0)
|
|
return;
|
|
|
|
Session sessions[] = findSessions();
|
|
|
|
// Swap out all sessions idle longer than maxIdleSwap
|
|
if (maxIdleSwap >= 0) {
|
|
for (int i = 0; i < sessions.length; i++) {
|
|
StandardSession session = (StandardSession) sessions[i];
|
|
synchronized (session) {
|
|
if (!session.isValid())
|
|
continue;
|
|
int timeIdle = (int) (session.getIdleTimeInternal() / 1000L);
|
|
if (timeIdle >= maxIdleSwap && timeIdle >= minIdleSwap) {
|
|
if (session.accessCount != null &&
|
|
session.accessCount.get() > 0) {
|
|
// Session is currently being accessed - skip it
|
|
continue;
|
|
}
|
|
if (log.isDebugEnabled())
|
|
log.debug(sm.getString
|
|
("persistentManager.swapMaxIdle",
|
|
session.getIdInternal(),
|
|
Integer.valueOf(timeIdle)));
|
|
try {
|
|
swapOut(session);
|
|
} catch (IOException e) {
|
|
// This is logged in writeSession()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Swap idle sessions out to Store if too many are active
|
|
*/
|
|
protected void processMaxActiveSwaps() {
|
|
|
|
if (!getState().isAvailable() || minIdleSwap < 0 || getMaxActiveSessions() < 0) {
|
|
return;
|
|
}
|
|
|
|
Session sessions[] = findSessions();
|
|
|
|
// FIXME: Smarter algorithm (LRU)
|
|
int limit = (int) (getMaxActiveSessions() * 0.9);
|
|
|
|
if (limit >= sessions.length)
|
|
return;
|
|
|
|
if(log.isDebugEnabled())
|
|
log.debug(sm.getString
|
|
("persistentManager.tooManyActive",
|
|
Integer.valueOf(sessions.length)));
|
|
|
|
int toswap = sessions.length - limit;
|
|
|
|
for (int i = 0; i < sessions.length && toswap > 0; i++) {
|
|
StandardSession session = (StandardSession) sessions[i];
|
|
synchronized (session) {
|
|
int timeIdle = (int) (session.getIdleTimeInternal() / 1000L);
|
|
if (timeIdle >= minIdleSwap) {
|
|
if (session.accessCount != null &&
|
|
session.accessCount.get() > 0) {
|
|
// Session is currently being accessed - skip it
|
|
continue;
|
|
}
|
|
if(log.isDebugEnabled())
|
|
log.debug(sm.getString
|
|
("persistentManager.swapTooManyActive",
|
|
session.getIdInternal(),
|
|
Integer.valueOf(timeIdle)));
|
|
try {
|
|
swapOut(session);
|
|
} catch (IOException e) {
|
|
// This is logged in writeSession()
|
|
}
|
|
toswap--;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Back up idle sessions.
|
|
*/
|
|
protected void processMaxIdleBackups() {
|
|
|
|
if (!getState().isAvailable() || maxIdleBackup < 0)
|
|
return;
|
|
|
|
Session sessions[] = findSessions();
|
|
|
|
// Back up all sessions idle longer than maxIdleBackup
|
|
if (maxIdleBackup >= 0) {
|
|
for (int i = 0; i < sessions.length; i++) {
|
|
StandardSession session = (StandardSession) sessions[i];
|
|
synchronized (session) {
|
|
if (!session.isValid())
|
|
continue;
|
|
long lastAccessedTime = session.getLastAccessedTimeInternal();
|
|
Long persistedLastAccessedTime =
|
|
(Long) session.getNote(PERSISTED_LAST_ACCESSED_TIME);
|
|
if (persistedLastAccessedTime != null &&
|
|
lastAccessedTime == persistedLastAccessedTime.longValue())
|
|
continue;
|
|
int timeIdle = (int) (session.getIdleTimeInternal() / 1000L);
|
|
if (timeIdle >= maxIdleBackup) {
|
|
if (log.isDebugEnabled())
|
|
log.debug(sm.getString
|
|
("persistentManager.backupMaxIdle",
|
|
session.getIdInternal(),
|
|
Integer.valueOf(timeIdle)));
|
|
|
|
try {
|
|
writeSession(session);
|
|
} catch (IOException e) {
|
|
// This is logged in writeSession()
|
|
}
|
|
session.setNote(PERSISTED_LAST_ACCESSED_TIME,
|
|
Long.valueOf(lastAccessedTime));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|