// for the local lock mutex.
// We do not block unlocking or maintenance, but they add to the count.
// The limit is set to allow for bursty behavior,
// but prevent requests to overload the server completely.
// Rejected clients are expected to retry.
const lockMutexWaitLimit = 1000

// lockRequesterInfo stores various info from the client for each lock that is requested.
type lockRequesterInfo struct {

            logger.info("[RAG:EVAL] Evaluation completed. hasRelevant={}, relevantCount={}, totalResults={}, elapsedTime={}ms",
                    result.isHasRelevantResults(), result.getRelevantDocIds().size(), searchResults.size(),
                    System.currentTimeMillis() - startTime);
            if (logger.isDebugEnabled()) {
                logger.debug("[RAG:EVAL] Result evaluation completed. hasRelevant={}, relevantDocIds={}, elapsedTime={}ms",

        ) {
          result.flush()
          handleSocketEffect(socketEffect, socket, stream)
        }
    }

    return result
  }

  /** Returns true if processing this exchange is complete. */
  private fun handleSocketEffect(
    effect: SocketEffect?,
    socket: MockWebServerSocket,
    stream: Http2Stream? = null,
  ): Boolean {
    if (effect == null) return false

    when (effect) {

                return true;
            });
            resultBuf.append("Exported ").append(count).append(" documents.");
            if (logger.isInfoEnabled()) {
                logger.info("[EXPORT] Completed: exportedCount={}, elapsedTime={}ms", count, System.currentTimeMillis() - startTime);
            }
        } catch (final Exception e) {
            logger.warn("Failed to export documents.", e);

Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de message, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans différents process, et surtout, sur plusieurs serveurs.

        assertEquals(newState, entry.getLeaseState());
        assertEquals(initialEpoch + 1, entry.getEpoch());
        assertFalse(entry.isBreaking()); // Should be false after break handling completes
    }

    @Test
    @DisplayName("Should release lease")
    void testReleaseLease() {
        String path = "/share/file.txt";
        int requestedState = Smb2LeaseState.SMB2_LEASE_READ_HANDLE;

You can add more than one event handler function.

And your application won't start receiving requests until all the `startup` event handlers have completed.

### `shutdown` event { #shutdown-event }

To add a function that should be run when the application is shutting down, declare it with the event `"shutdown"`:

You can define background tasks to be run *after* returning a response.

This is useful for operations that need to happen after a request, but that the client doesn't really have to be waiting for the operation to complete before receiving the response.

This includes, for example:

* Email notifications sent after performing an action:

            Thread.sleep(100);
        } catch (Exception e) {
            // May throw due to null user when task executes, which is expected
        }

        assertTrue("scheduleParentGroupLookup should complete without immediate error", true);
    }

    /**
     * Test that empty groupIds list does not schedule any task.
     */
    @Test

        }
    }

    @Nested
    @DisplayName("Integration Scenarios")
    class IntegrationTests {

        @Test
        @DisplayName("Should complete full connection lifecycle")
        void testFullConnectionLifecycle() throws Exception {
            // Given
            when(transportPool.getSmbTransport(context, TEST_HOST, DEFAULT_PORT, false, false)).thenReturn(transport);