private void pingSessionBackup(@Nonnull final MemcachedBackupSession session)
     throws InterruptedException {
   final String key = _sessionIdFormat.createBackupKey(session.getId());
   final Future<Boolean> touchResultFuture = _memcached.add(key, 5, 1);
   try {
     final boolean touchResult =
         touchResultFuture.get(_manager.getOperationTimeout(), TimeUnit.MILLISECONDS);
     if (touchResult) {
       _log.warn(
           "The secondary backup for session "
               + session.getIdInternal()
               + " should be touched in memcached, but it seemed to be"
               + " not existing. Will store in memcached again.");
       saveSessionBackup(session, key);
     } else _log.debug("The secondary session backup was ping'ed successfully.");
   } catch (final TimeoutException e) {
     _log.warn(
         "The secondary backup for session "
             + session.getIdInternal()
             + " could not be completed within "
             + _manager.getOperationTimeout()
             + " millis, was cancelled now.");
   } catch (final ExecutionException e) {
     _log.warn(
         "An exception occurred when trying to ping session " + session.getIdInternal(), e);
   }
 }
  /**
   * 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());
    }
  }
    @Override
    public Void call() throws Exception {

      final BackupResult backupResult = _result.get();

      if (_pingSessionIfBackupWasSkipped) {
        if (backupResult.getStatus() == BackupResultStatus.SKIPPED) {
          pingSession(_session, _backupSessionService);
        }
      }

      /*
       * For non-sticky sessions we store a backup of the session in a secondary memcached node (under a special key
       * that's resolved by the SuffixBasedNodeLocator), but only when we have more than 1 memcached node configured...
       */
      if (_storeSecondaryBackup) {
        try {
          if (_log.isDebugEnabled()) {
            _log.debug(
                "Storing backup in secondary memcached for non-sticky session " + _session.getId());
          }
          if (backupResult.getStatus() == BackupResultStatus.SKIPPED) {
            pingSessionBackup(_session);
          } else {
            saveSessionBackupFromResult(backupResult);
          }

          saveValidityBackup();
        } catch (final RuntimeException e) {
          _log.info("Could not store secondary backup of session " + _session.getIdInternal(), e);
        }
      }

      return null;
    }
 private void pingSession(
     @Nonnull final MemcachedBackupSession session,
     @Nonnull final BackupSessionService backupSessionService)
     throws InterruptedException {
   final Future<Boolean> touchResult =
       _memcached.add(_storageKeyFormat.format(session.getIdInternal()), 5, 1);
   try {
     if (touchResult.get()) {
       _stats.nonStickySessionsPingFailed();
       _log.warn(
           "The session "
               + session.getIdInternal()
               + " should be touched in memcached, but it does not exist"
               + " therein. Will store in memcached again.");
       updateSession(session, backupSessionService);
     } else _log.debug("The session was ping'ed successfully.");
   } catch (final ExecutionException e) {
     _log.warn("An exception occurred when trying to ping session " + session.getIdInternal(), e);
   }
 }
 public void saveSessionBackup(
     @Nonnull final MemcachedBackupSession session, @Nonnull final String key)
     throws InterruptedException {
   try {
     final byte[] data = _manager.serialize(session);
     final Future<Boolean> backupResult =
         _memcached.set(
             key, toMemcachedExpiration(session.getMemcachedExpirationTimeToSet()), data);
     if (!backupResult.get().booleanValue()) {
       _log.warn(
           "Update for secondary backup of session "
               + session.getIdInternal()
               + " (after unsuccessful ping) did not return sucess.");
     }
   } catch (final ExecutionException e) {
     _log.warn(
         "An exception occurred when trying to update secondary session backup for "
             + session.getIdInternal(),
         e);
   }
 }
 public void saveSessionBackupFromResult(final BackupResult backupResult) {
   final byte[] data = backupResult.getData();
   if (data != null) {
     final String key = _sessionIdFormat.createBackupKey(_session.getId());
     _memcached.set(
         key, toMemcachedExpiration(_session.getMemcachedExpirationTimeToSet()), data);
   } else {
     _log.warn(
         "No data set for backupResultStatus "
             + backupResult.getStatus()
             + " for sessionId "
             + _session.getIdInternal()
             + ", skipping backup"
             + " of non-sticky session in secondary memcached.");
   }
 }
 private void updateSession(
     @Nonnull final MemcachedBackupSession session,
     @Nonnull final BackupSessionService backupSessionService)
     throws InterruptedException {
   final Future<BackupResult> result = backupSessionService.backupSession(session, true);
   try {
     if (result.get().getStatus() != BackupResultStatus.SUCCESS) {
       _log.warn(
           "Update for session (after unsuccessful ping) did not return SUCCESS, but "
               + result.get());
     }
   } catch (final ExecutionException e) {
     _log.warn(
         "An exception occurred when trying to update session " + session.getIdInternal(), e);
   }
 }
  static byte[] serializeSessionFields(final MemcachedBackupSession session) {

    final byte[] idData = serializeId(session.getIdInternal());

    final byte[] principalData =
        session.getPrincipal() != null ? serializePrincipal(session.getPrincipal()) : null;
    final int principalDataLength = principalData != null ? principalData.length : 0;

    final int sessionFieldsDataLength =
        2 // short value for the version
            // the following might change with other versions, refactoring needed then
            + 2 // short value that stores the dataLength
            + NUM_BYTES // bytes that store all session attributes but the id
            + 2 // short value that stores the idData length
            + idData.length // the number of bytes for the id
            + 2 // short value for the authType
            + 2 // short value that stores the principalData length
            + principalDataLength; // the number of bytes for the principal
    final byte[] data = new byte[sessionFieldsDataLength];

    int idx = 0;
    idx = encodeNum(CURRENT_VERSION, data, idx, 2);
    idx = encodeNum(sessionFieldsDataLength, data, idx, 2);
    idx = encodeNum(session.getCreationTimeInternal(), data, idx, 8);
    idx = encodeNum(session.getLastAccessedTimeInternal(), data, idx, 8);
    idx = encodeNum(session.getMaxInactiveInterval(), data, idx, 4);
    idx = encodeBoolean(session.isNewInternal(), data, idx);
    idx = encodeBoolean(session.isValidInternal(), data, idx);
    idx = encodeNum(session.getThisAccessedTimeInternal(), data, idx, 8);
    idx = encodeNum(session.getLastBackupTime(), data, idx, 8);
    idx = encodeNum(idData.length, data, idx, 2);
    idx = copy(idData, data, idx);
    idx = encodeNum(AuthType.valueOfValue(session.getAuthType()).getId(), data, idx, 2);
    idx = encodeNum(principalDataLength, data, idx, 2);
    copy(principalData, data, idx);

    return data;
  }
  /**
   * 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);
    }
  }