logger.error("Failed to close httpClient.", e);
            }
            httpClient = null;
            if (clientConnectionManager != null) {
                clientConnectionManager.shutdown();
            }
        }
    }

    public void addHttpClientProperty(final String name, final Object value) {
        if (StringUtil.isNotBlank(name) && value != null) {

    val cached = cacheGet(cache, request)
    if (shouldWriteToCache) {
      assertThat(cached).isNotNull()
      cached!!.body.close()
    } else {
      assertThat(cached).isNull()
    }
    server.shutdown() // tearDown() isn't sufficient; this test starts multiple servers
  }

  private fun assertSubsequentResponseCached(
    initialResponseCode: Int,
    finalResponseCode: Int,
  ) {

    assertFailsWith<IOException> {
      getResponse(request)
    }
  }

  @Test
  fun connectRetriesUntilConnectedOrFailed() {
    val request = newRequest("/foo")
    server.shutdown()
    assertFailsWith<IOException> {
      getResponse(request)
    }
  }

  @Test
  fun requestBodySurvivesRetriesWithFixedLength() {
    testRequestBodySurvivesRetries(TransferKind.FIXED_LENGTH)

                         * server will return "Access denied" even if a logoff is
                         * sent. Unfortunately calling disconnect() doesn't always
                         * actually shutdown the connection before other threads
                         * have committed themselves (e.g. InterruptTest example).
                         */
                        try {

      else break;
    }
  }

  /** Waits out termination of a thread pool or fails doing so. */
  void joinPool(ExecutorService exec) throws InterruptedException {
    try {
      exec.shutdown();
      assertTrue(
          "ExecutorService did not terminate in a timely manner",
          exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS));
    } catch (SecurityException ok) {

It is very simple and intuitive. It's designed to be easily extensible, and have modular components.

It has:

* Seriously impressive performance.
* WebSocket support.
* In-process background tasks.
* Startup and shutdown events.
* Test client built on HTTPX.
* CORS, GZip, Static Files, Streaming responses.
* Session and Cookie support.
* 100% test coverage.
* 100% type annotated codebase.
* Few hard dependencies.

      else break;
    }
  }

  /** Waits out termination of a thread pool or fails doing so. */
  void joinPool(ExecutorService exec) throws InterruptedException {
    try {
      exec.shutdown();
      assertTrue(
          "ExecutorService did not terminate in a timely manner",
          exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS));
    } catch (SecurityException ok) {

```

⛔️ **Shell** form:

```Dockerfile
# ⛔️ Don't do this
CMD fastapi run app/main.py --port 80
```

Make sure to always use the **exec** form to ensure that FastAPI can shutdown gracefully and [lifespan events](../advanced/events.md){.internal-link target=_blank} are triggered.

    listener.forbidLock(get(client.connectionPool))
    listener.forbidLock(client.dispatcher)
  }

  @AfterEach
  fun tearDown() {
    if (socksProxy != null) {
      socksProxy!!.shutdown()
    }
    if (cache != null) {
      cache!!.delete()
    }
  }

  @Test
  fun successfulCallEventSequence() {
    server.enqueue(
      MockResponse.Builder()
        .body("abc")

* The kube-apiserver has improved behavior for both startup and shutdown sequences and also now exposes `/readyz` for readiness checking. Readyz includes all existing healthz checks but also adds a shutdown check. When a cluster admin initiates a shutdown, the kube-apiserver will try to process existing requests (for the duration of request timeout) before killing the apiserver process.   ([#78458](https://...