paramMap.put(entry.getKey(), list.toArray(new String[list.size()]));
        }
        return paramMap;
    }

    /**
     * Cleans up resources when the filter is destroyed.
     * Currently performs no cleanup operations.
     */
    @Override
    public void destroy() {
        // nothing
    }

                DirectoryCacheScope.IMMEDIATE_CHILDREN);

        // Shutdown
        directoryLeaseManager.shutdown();

        // Verify cleanup
        assertNull(directoryLeaseManager.getCacheEntry(directoryPath));
    }

    @Test
    public void testMultipleDirectories() {
        String dir1 = "/test/dir1";
        String dir2 = "/test/dir2";

            cipher.init(encrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, keySpec, gcmSpec);
            return cipher;
        } finally {
            // Guaranteed cleanup of all key material
            if (key != null) {
                SecureKeyManager.secureWipe(key);
            }
            if (keyCopy != null) {
                SecureKeyManager.secureWipe(keyCopy);

  - [Changes by Kind](#changes-by-kind-1)
    - [Bug or Regression](#bug-or-regression-1)
    - [Other (Cleanup or Flake)](#other-cleanup-or-flake)
  - [Dependencies](#dependencies-1)
    - [Added](#added-1)
    - [Changed](#changed-1)
    - [Removed](#removed-1)
- [v1.19.14](#v11914)
  - [Downloads for v1.19.14](#downloads-for-v11914)

import jakarta.annotation.Resource;

/**
 * Service class for managing job logs in the Fess application.
 * Provides functionality to create, read, update, and delete job log entries,
 * as well as manage job status and perform cleanup operations.
 */
public class JobLogService {

    /**
     * Behavior class for job log database operations.
     */
    @Resource
    protected JobLogBhv jobLogBhv;

    /**

   * simultaneously adopted and removed.
   */
  private val connections = ConcurrentLinkedQueue<RealConnection>()

  init {
    // Put a floor on the keep alive duration, otherwise cleanup will spin loop.
    require(keepAliveDuration > 0L) { "keepAliveDuration <= 0: $keepAliveDuration" }
  }

  fun idleConnectionCount(): Int =
    connections.count {
      it.withLock { it.calls.isEmpty() }
    }

    }

    override fun secureConnectEnd(
      call: Call,
      handshake: Handshake?,
    ) {
      logger.removeHandler(loggerHandler)
    }

    override fun callEnd(call: Call) {
      // Cleanup log handler if failed.
      logger.removeHandler(loggerHandler)
    }

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {
      if (random != null) {

import org.slf4j.LoggerFactory;

/**
 * Secure key management for SMB encryption.
 * Provides centralized management of encryption keys with secure storage and cleanup.
 *
 * Features:
 * - Secure key storage with optional KeyStore integration
 * - Automatic key cleanup on close
 * - Thread-safe key management
 * - Key derivation utilities
 * - Memory wiping capabilities
 */
public class SecureKeyManager implements AutoCloseable {

     *
     * @param sessionId the session ID to update
     * @param name the name to set for the crawling session (uses system name if blank)
     * @param dayForCleanup number of days until cleanup (sets expiration if >= 0)
     * @throws FessSystemException if unable to store the updated crawling session
     */
    public void updateParams(final String sessionId, final String name, final int dayForCleanup) {

    public void tearDown() throws Exception {
        if (storage != null && !storage.isDestroyed()) {
            try {
                storage.close();
            } catch (Exception e) {
                // Ignore cleanup exceptions
            }
        }
        if (masterPassword != null) {
            Arrays.fill(masterPassword, '\0');
        }
    }

    @Test
    public void testEncryptDecrypt() throws Exception {