) {
    if (length < 8) throw IOException("TYPE_GOAWAY length < 8: $length")
    if (streamId != 0) throw IOException("TYPE_GOAWAY streamId != 0")
    val lastStreamId = source.readInt()
    val errorCodeInt = source.readInt()
    val opaqueDataLength = length - 8
    val errorCode =
      ErrorCode.fromHttp2(errorCodeInt) ?: throw IOException(
        "TYPE_GOAWAY unexpected error code: $errorCodeInt",
      )

Cache Events are exposed via the EventListener API.  Typical scenarios are below.

### Cache Hit

In the ideal scenario the cache can fulfill the request without any conditional call to the network.
This will skip the normal events such as DNS, connecting to the network, and downloading the response body.

As recommended by the HTTP RFC the max age of a document is defaulted to 10% of the 

# Extending OpenAPI

There are some cases where you might need to modify the generated OpenAPI schema.

In this section you will see how.

## The normal process

The normal (default) process, is as follows.

A `FastAPI` application (instance) has an `.openapi()` method that is expected to return the OpenAPI schema.

      log.put("normal task running")
      return@schedule -1L
    }

    queue.idleLatch().await(500, TimeUnit.MILLISECONDS)

    assertThat(log.take()).isEqualTo("failing task running")
    assertThat(log.take()).isEqualTo("uncaught exception: java.lang.RuntimeException: boom!")
    assertThat(log.take()).isEqualTo("normal task running")
    assertThat(log).isEmpty()
  }

[2020-01-01 00:00:00] << 0x00000003   288 DATA
[2020-01-01 00:00:00] << 0x00000003     0 DATA          END_STREAM
[2020-01-01 00:00:00] << 0x00000000     8 GOAWAY
[2020-01-01 00:00:05] << 0x00000000     8 GOAWAY
```

### Task Runner Logging 

This logs task enqueues, starts, and finishes.

```
[2020-01-01 00:00:00] Q10000 scheduled after   0 µs: OkHttp ConnectionPool

As `get_db()` is a normal `def` function, **FastAPI** will make it run in a threadpool, with a *copy* of the "context", holding the same value for the context variable (the `dict` with the reset database state). Then it can add database state to that `dict`, like the connection, etc.

### Other utility functions

Any other utility function that you call directly can be created with normal `def` or `async def` and FastAPI won't affect the way you call it.

   */
  @Throws(IOException::class)
  fun goAway(
    lastGoodStreamId: Int,
    errorCode: ErrorCode,
    debugData: ByteArray,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1) { "errorCode.httpCode == -1" }
      frameHeader(
        streamId = 0,
        length = 8 + debugData.size,
        type = TYPE_GOAWAY,
        flags = FLAG_NONE,
      )

## HTTPX

Even if your **FastAPI** application uses normal `def` functions instead of `async def`, it is still an `async` application underneath.

Wybierz opcję "Tylko wydania".

Dzięki temu będziesz otrzymywać powiadomienia (na swój adres e-mail) za każdym razem, gdy pojawi się nowe wydanie (nowa wersja) **FastAPI** z poprawkami błędów i nowymi funkcjami.

## Skontaktuj się z autorem