コード例 #1
0
 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);
   }
 }
コード例 #2
0
    @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;
    }
コード例 #3
0
  /**
   * 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());
    }
  }
コード例 #4
0
 public void saveValidityBackup() {
   final String backupValidityKey = _sessionIdFormat.createBackupKey(_validityKey);
   final int maxInactiveInterval = _session.getMaxInactiveInterval();
   // fix for #88, along with the change in session.getMemcachedExpirationTimeToSet
   final int expiration = maxInactiveInterval <= 0 ? 0 : maxInactiveInterval;
   _memcached.set(backupValidityKey, toMemcachedExpiration(expiration), _validityData);
 }
コード例 #5
0
 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.");
   }
 }
コード例 #6
0
 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);
   }
 }
コード例 #7
0
 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);
   }
 }
コード例 #8
0
 /**
  * Deserialize session data that was serialized using {@link #serialize(MemcachedBackupSession)}
  * (or a combination of {@link #serializeAttributes(MemcachedBackupSession, Map)} and {@link
  * #serialize(MemcachedBackupSession, byte[])}).
  *
  * <p>Note: the returned session already has the manager set and {@link
  * MemcachedBackupSession#doAfterDeserialization()} is invoked. Additionally the attributes hash
  * is set (via {@link MemcachedBackupSession#setDataHashCode(int)}).
  *
  * @param data the byte array of the serialized session and its session attributes. Can be <code>
  *     null</code>.
  * @param realm the realm that is used to reconstruct the principal if there was any stored in the
  *     session.
  * @param manager the manager to set on the deserialized session.
  * @return the deserialized {@link MemcachedBackupSession} or <code>null</code> if the provided
  *     <code>byte[] data</code> was <code>null</code>.
  */
 public MemcachedBackupSession deserialize(final byte[] data, final SessionManager manager) {
   if (data == null) {
     return null;
   }
   try {
     final DeserializationResult deserializationResult = deserializeSessionFields(data, manager);
     final byte[] attributesData = deserializationResult.getAttributesData();
     final Map<String, Object> attributes = deserializeAttributes(attributesData);
     final MemcachedBackupSession session = deserializationResult.getSession();
     session.setAttributesInternal(attributes);
     session.setDataHashCode(Arrays.hashCode(attributesData));
     session.setManager(manager);
     session.doAfterDeserialization();
     return session;
   } catch (final InvalidVersionException e) {
     LOG.info("Got session data from memcached with an unsupported version: " + e.getVersion());
     // for versioning probably there will be changes in the design,
     // with the first change and version 2 we'll see what we need
     return null;
   }
 }
コード例 #9
0
 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);
   }
 }
コード例 #10
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);
    }
  }
コード例 #11
0
 /**
  * Serialize the given session to a byte array. This is a shortcut for <code><pre>
  * final byte[] attributesData = serializeAttributes( session, session.getAttributes() );
  * serialize( session, attributesData );
  * </pre></code> The returned byte array can be deserialized using {@link #deserialize(byte[],
  * Realm, Manager)}.
  *
  * @see #serializeAttributes(MemcachedBackupSession, Map)
  * @see #serialize(MemcachedBackupSession, byte[])
  * @see #deserialize(byte[], Realm, Manager)
  * @param session the session to serialize.
  * @return the serialized session data.
  */
 public byte[] serialize(final MemcachedBackupSession session) {
   final byte[] attributesData = serializeAttributes(session, session.getAttributesInternal());
   return serialize(session, attributesData);
 }
コード例 #12
0
  static DeserializationResult deserializeSessionFields(
      final byte[] data, final SessionManager manager) throws InvalidVersionException {
    final MemcachedBackupSession result = manager.newMemcachedBackupSession();

    final short version = (short) decodeNum(data, 0, 2);

    if (version != CURRENT_VERSION) {
      throw new InvalidVersionException(
          "The version " + version + " does not match the current version " + CURRENT_VERSION,
          version);
    }

    final short sessionFieldsDataLength = (short) decodeNum(data, 2, 2);

    result.setCreationTimeInternal(decodeNum(data, 4, 8));
    result.setLastAccessedTimeInternal(decodeNum(data, 12, 8));
    result.setMaxInactiveInterval((int) decodeNum(data, 20, 4));
    result.setIsNewInternal(decodeBoolean(data, 24));
    result.setIsValidInternal(decodeBoolean(data, 25));
    result.setThisAccessedTimeInternal(decodeNum(data, 26, 8));
    result.setLastBackupTime(decodeNum(data, 34, 8));

    final short idLength = (short) decodeNum(data, 42, 2);
    result.setIdInternal(decodeString(data, 44, idLength));

    final short authTypeId = (short) decodeNum(data, 44 + idLength, 2);
    result.setAuthTypeInternal(AuthType.valueOfId(authTypeId).getValue());

    final int currentIdx = 44 + idLength + 2;
    final short principalDataLength = (short) decodeNum(data, currentIdx, 2);
    if (principalDataLength > 0) {
      final byte[] principalData = new byte[principalDataLength];
      System.arraycopy(data, currentIdx + 2, principalData, 0, principalDataLength);
      result.setPrincipalInternal(deserializePrincipal(principalData, manager));
    }

    final byte[] attributesData = new byte[data.length - sessionFieldsDataLength];
    System.arraycopy(
        data, sessionFieldsDataLength, attributesData, 0, data.length - sessionFieldsDataLength);

    return new DeserializationResult(result, attributesData);
  }
コード例 #13
0
  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;
  }