Thread waiter = new Thread(() -> {
                synchronized (response) {
                    try {
                        if (!response.isReceived()) {
                            response.wait(1000);
                        }
                        latch.countDown();
                    } catch (InterruptedException e) {
                        // Ignore
                    }
                }

                if (connectionState == 2 || connectionState == 3) { // connected or disconnecting
                    return;
                }
                try {
                    session.transport.wait();
                } catch (final InterruptedException ie) {
                    throw new SmbException(ie.getMessage(), ie);
                }
            }
            connectionState = 1; // trying ...

    $ mvn antrun:run  # Download OpenSearch plugins (if not done)
    $ mvn package     # Build the package

#### 2. Start Fess Server

    $ unzip target/releases/fess-*.zip
    $ ./fess-*/bin/fess &

Wait for Fess to be ready (this may take up to 60 seconds):

    $ curl -s "http://localhost:8080/api/v1/health"

You should see a JSON response when Fess is ready.

#### 3. Clone Test Data

                                     readRegion.getSize());
            
            // Send request header via RDMA send
            sendWithRdmaSendReceive(request);
            
            // Wait for server to write data directly to our buffer via RDMA
            // No additional receive needed - data written directly to memory
            
            // Create response with data from RDMA buffer

        int requestedState = Smb2LeaseState.SMB2_LEASE_READ_CACHING;

        Smb2LeaseKey key = leaseManager.requestLease(path, requestedState);
        assertNotNull(leaseManager.getLease(key));

        // Wait a bit and then cleanup with a very short expiration time
        Thread.sleep(10);
        int cleaned = leaseManager.cleanupExpiredLeases(1); // 1ms expiration

        assertEquals(1, cleaned);

                new IOException("Failed to reconnect after " + maxRetries + " attempts"));
        }
        
        return CompletableFuture.supplyAsync(() -> {
            try {
                // Wait before retry (except first attempt)
                if (attempt > 0) {
                    Thread.sleep(retryDelay * attempt);
                }
                
                // Create reconnect context

        TestResource resource = new TestResource("old");
        resourceManager.registerResource(resource);

        assertFalse(resource.isClosed());

        // Wait for automatic cleanup to kick in
        Thread.sleep(300);

        // Perform cleanup
        resourceManager.performCleanup();

        // Old resource should be auto-closed

        directoryLeaseManager.updateDirectoryCache(directoryPath, files);

        assertTrue(entry.isComplete());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        Thread.sleep(100);

        assertTrue(entry.isExpired());
        assertTrue(entry.needsRefresh());

        // After expiration, cache should be treated as invalid by manager

        // Create an expired handle
        HandleInfo expiredHandle = new HandleInfo("/test/file.txt", new HandleGuid(), new byte[16], HandleType.DURABLE_V2, 100, // 100ms timeout
                null);

        // Wait for expiration
        Thread.sleep(150);

        CompletableFuture<HandleInfo> future = reconnector.reconnectHandle(expiredHandle, new IOException("Network error"));

        // Create multiple threads that all try to connect simultaneously
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                try {
                    startLatch.await(); // Wait for signal to start
                    conn.connect();
                    successCount.incrementAndGet();
                } catch (Exception e) {
                    synchronized (exceptions) {