コード例 #1
0
  /** 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);
  }
コード例 #2
0
  /**
   * 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);
    }
  }
コード例 #3
0
 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);
   }
 }
コード例 #4
0
 protected void acquireLock(
     @Nonnull final String sessionId,
     final long retryInterval,
     final long maxRetryInterval,
     final long timeout,
     final long start)
     throws InterruptedException, ExecutionException, TimeoutException {
   final Future<Boolean> result =
       _memcached.add(_sessionIdFormat.createLockName(sessionId), 5, LOCK_VALUE);
   if (result.get().booleanValue()) {
     if (_log.isDebugEnabled()) {
       _log.debug("Locked session " + sessionId);
     }
     return;
   } else {
     checkTimeoutAndWait(sessionId, retryInterval, timeout, start);
     acquireLock(
         sessionId, min(retryInterval * 2, maxRetryInterval), maxRetryInterval, timeout, start);
   }
 }
コード例 #5
0
 @CheckForNull
 protected SessionValidityInfo loadBackupSessionValidityInfo(@Nonnull final String sessionId) {
   final String key = _sessionIdFormat.createValidityInfoKeyName(sessionId);
   final String backupKey = _sessionIdFormat.createBackupKey(key);
   return loadSessionValidityInfoForValidityKey(backupKey);
 }
コード例 #6
0
 @CheckForNull
 protected SessionValidityInfo loadSessionValidityInfo(@Nonnull final String sessionId) {
   return loadSessionValidityInfoForValidityKey(
       _sessionIdFormat.createValidityInfoKeyName(sessionId));
 }
コード例 #7
0
  /**
   * 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);
    }
  }