protected LockStatus lock(final String sessionId, final long timeout, final TimeUnit timeUnit) {
if (_log.isDebugEnabled()) {
_log.debug("Locking session " + sessionId);
}
final long start = System.currentTimeMillis();
try {
acquireLock(
sessionId,
LOCK_RETRY_INTERVAL,
LOCK_MAX_RETRY_INTERVAL,
timeUnit.toMillis(timeout),
System.currentTimeMillis());
_stats.registerSince(ACQUIRE_LOCK, start);
if (_log.isDebugEnabled()) {
_log.debug("Locked session " + sessionId);
}
return LockStatus.LOCKED;
} catch (final TimeoutException e) {
_log.warn(
"Reached timeout when trying to aquire lock for session "
+ sessionId
+ ". Will use this session without this lock.");
_stats.registerSince(ACQUIRE_LOCK_FAILURE, start);
return LockStatus.COULD_NOT_AQUIRE_LOCK;
} catch (final InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException("Got interrupted while trying to lock session.", e);
} catch (final ExecutionException e) {
_log.warn("An exception occurred when trying to aquire lock for session " + sessionId);
_stats.registerSince(ACQUIRE_LOCK_FAILURE, start);
return LockStatus.COULD_NOT_AQUIRE_LOCK;
}
}
/**
* Is invoked for the backup of a non-sticky session that was not accessed for the current
* request.
*/
protected void onBackupWithoutLoadedSession(
@Nonnull final String sessionId,
@Nonnull final String requestId,
@Nonnull final BackupSessionService backupSessionService) {
if (!_sessionIdFormat.isValid(sessionId)) {
return;
}
try {
final long start = System.currentTimeMillis();
final String validityKey = _sessionIdFormat.createValidityInfoKeyName(sessionId);
final SessionValidityInfo validityInfo = loadSessionValidityInfoForValidityKey(validityKey);
if (validityInfo == null) {
_log.warn("Found no validity info for session id " + sessionId);
return;
}
final int maxInactiveInterval = validityInfo.getMaxInactiveInterval();
final byte[] validityData =
encode(maxInactiveInterval, System.currentTimeMillis(), System.currentTimeMillis());
// fix for #88, along with the change in session.getMemcachedExpirationTimeToSet
final int expiration = maxInactiveInterval <= 0 ? 0 : maxInactiveInterval;
final Future<Boolean> validityResult =
_memcached.set(validityKey, toMemcachedExpiration(expiration), validityData);
if (!_manager.isSessionBackupAsync()) {
validityResult.get(_manager.getSessionBackupTimeout(), TimeUnit.MILLISECONDS);
}
/*
* - ping session
* - ping session backup
* - save validity backup
*/
final Callable<?> backupSessionTask =
new OnBackupWithoutLoadedSessionTask(
sessionId, _storeSecondaryBackup, validityKey, validityData, maxInactiveInterval);
_executor.submit(backupSessionTask);
if (_log.isDebugEnabled()) {
_log.debug("Stored session validity info for session " + sessionId);
}
_stats.registerSince(NON_STICKY_ON_BACKUP_WITHOUT_LOADED_SESSION, start);
} catch (final Throwable e) {
_log.warn("An error when trying to load/update validity info.", e);
}
}
protected void releaseLock(@Nonnull final String sessionId) {
try {
if (_log.isDebugEnabled()) {
_log.debug("Releasing lock for session " + sessionId);
}
final long start = System.currentTimeMillis();
_memcached.delete(_sessionIdFormat.createLockName(sessionId)).get();
_stats.registerSince(RELEASE_LOCK, start);
} catch (final Exception e) {
_log.warn("Caught exception when trying to release lock for session " + sessionId, e);
}
}
/** Invoked after a non-sticky session is removed from memcached. */
protected void onAfterDeleteFromMemcached(@Nonnull final String sessionId) {
final long start = System.currentTimeMillis();
final String validityInfoKey = _sessionIdFormat.createValidityInfoKeyName(sessionId);
_memcached.delete(validityInfoKey);
if (_storeSecondaryBackup) {
_memcached.delete(_sessionIdFormat.createBackupKey(sessionId));
_memcached.delete(_sessionIdFormat.createBackupKey(validityInfoKey));
}
_stats.registerSince(NON_STICKY_AFTER_DELETE_FROM_MEMCACHED, start);
}
/**
* Invoked after a non-sticky session is loaded from memcached, can be used to update some session
* fields based on separately stored information (e.g. session validity info).
*
* @param lockStatus the {@link LockStatus} that was returned from {@link
* #onBeforeLoadFromMemcached(String)}.
*/
protected void onAfterLoadFromMemcached(
@Nonnull final MemcachedBackupSession session, @Nullable final LockStatus lockStatus) {
session.setLockStatus(lockStatus);
final long start = System.currentTimeMillis();
final SessionValidityInfo info = loadSessionValidityInfo(session.getIdInternal());
if (info != null) {
_stats.registerSince(NON_STICKY_AFTER_LOAD_FROM_MEMCACHED, start);
session.setLastAccessedTimeInternal(info.getLastAccessedTime());
session.setThisAccessedTimeInternal(info.getThisAccessedTime());
} else {
_log.warn("No validity info available for session " + session.getIdInternal());
}
}
protected void checkTimeoutAndWait(
@Nonnull final String sessionId, final long timeToWait, final long timeout, final long start)
throws TimeoutException, InterruptedException {
if (System.currentTimeMillis() >= start + timeout) {
throw new TimeoutException(
"Reached timeout when trying to aquire lock for session " + sessionId);
}
if (_log.isDebugEnabled()) {
_log.debug(
"Could not aquire lock for session "
+ sessionId
+ ", waiting "
+ timeToWait
+ " millis now...");
}
sleep(timeToWait);
}
/**
* Is invoked after the backup of the session is initiated, it's represented by the provided
* backupResult. The requestId is identifying the request.
*/
protected void onAfterBackupSession(
@Nonnull final MemcachedBackupSession session,
final boolean backupWasForced,
@Nonnull final Future<BackupResult> result,
@Nonnull final String requestId,
@Nonnull final BackupSessionService backupSessionService) {
if (!_sessionIdFormat.isValid(session.getIdInternal())) {
return;
}
try {
final long start = System.currentTimeMillis();
final int maxInactiveInterval = session.getMaxInactiveInterval();
final byte[] validityData =
encode(
maxInactiveInterval,
session.getLastAccessedTimeInternal(),
session.getThisAccessedTimeInternal());
final String validityKey =
_sessionIdFormat.createValidityInfoKeyName(session.getIdInternal());
// fix for #88, along with the change in session.getMemcachedExpirationTimeToSet
final int expiration = maxInactiveInterval <= 0 ? 0 : maxInactiveInterval;
final Future<Boolean> validityResult =
_memcached.set(validityKey, toMemcachedExpiration(expiration), validityData);
if (!_manager.isSessionBackupAsync()) {
// TODO: together with session backup wait not longer than sessionBackupTimeout.
// Details: Now/here we're waiting the whole session backup timeout, even if (perhaps) some
// time
// was spent before when waiting for session backup result.
// For sync session backup it would be better to set both the session data and
// validity info and afterwards wait for both results (but in sum no longer than
// sessionBackupTimeout)
validityResult.get(_manager.getSessionBackupTimeout(), TimeUnit.MILLISECONDS);
}
if (_log.isDebugEnabled()) {
_log.debug("Stored session validity info for session " + session.getIdInternal());
}
/* The following task are performed outside of the request thread (includes waiting for the backup result):
* - ping session if the backup was skipped (depends on the backup result)
* - save secondary session backup if session was modified (backup not skipped)
* - ping secondary session backup if the backup was skipped
* - save secondary validity backup
*/
final boolean pingSessionIfBackupWasSkipped = !backupWasForced;
final boolean performAsyncTasks = pingSessionIfBackupWasSkipped || _storeSecondaryBackup;
if (performAsyncTasks) {
final Callable<?> backupSessionTask =
new OnAfterBackupSessionTask(
session,
result,
pingSessionIfBackupWasSkipped,
backupSessionService,
_storeSecondaryBackup,
validityKey,
validityData);
_executor.submit(backupSessionTask);
}
_stats.registerSince(NON_STICKY_AFTER_BACKUP, start);
} catch (final Throwable e) {
_log.warn("An error occurred during onAfterBackupSession.", e);
}
}