docs: public Future<BackupResult> backupSession( final MemcachedBackupSession session, final boolean force ) {
          if ( _log.isDebugEnabled() ) {
              _log.debug( "Starting for session id " + session.getId() );
          }
  
          final long start = System.currentTimeMillis();
          try {
  
              if ( !_memcachedNodesManager.getSessionIdFormat().isValid( session.getId() ) ) {
                  if ( _log.isDebugEnabled() ) {
                      _log.debug( "Skipping backup for session id " + session.getId() + " as the session id is not usable for memcached." );
                  }
                  _statistics.requestWithBackupFailure();
                  return new SimpleFuture<BackupResult>( BackupResult.FAILURE );
              }
  
              /* Check if the session was accessed at all since the last backup/check.
               * If this is not the case, we even don't have to check if attributes
               * have changed (and can skip serialization and hash calucation)
               */
              if ( !session.wasAccessedSinceLastBackupCheck()
                      && !force ) {
                  _log.debug( "Session was not accessed since last backup/check, therefore we can skip this" );
                  _statistics.requestWithoutSessionAccess();
                  releaseLock( session );
                  return new SimpleFuture<BackupResult>( BackupResult.SKIPPED );
              }
  
              if ( !session.attributesAccessedSinceLastBackup()
                      && !force
                      && !session.authenticationChanged()
                      && !session.isNewInternal() ) {
                  _log.debug( "Session attributes were not accessed since last backup/check, therefore we can skip this" );
                  _statistics.requestWithoutAttributesAccess();
                  releaseLock( session );
                  return new SimpleFuture<BackupResult>( BackupResult.SKIPPED );
              }
  
              final BackupSessionTask task = createBackupSessionTask( session, force );
              final Future<BackupResult> result = _executorService.submit( task );
  
              if ( !_sessionBackupAsync ) {
                  try {
                      result.get( _sessionBackupTimeout, TimeUnit.MILLISECONDS );
                  } catch ( final Exception e ) {
                      if ( _log.isInfoEnabled() ) {
                          _log.info( "Could not store session " + session.getId() + " in memcached.", e );
                      }
                  }
              }
  
              return result;
  
          } finally {
              _statistics.registerSince( EFFECTIVE_BACKUP, start );
          }
  
      }