import okio.Source
import okio.Timeout

/**
 * Replicates a single upstream source into multiple downstream sources. Each downstream source
 * returns the same bytes as the upstream source. Downstream sources may read data either as it
 * is returned by upstream, or after the upstream source has been exhausted.
 *
 * As bytes are returned from upstream they are written to a local file. Downstream sources read
 * from this file as necessary.

mkdocs gh-deploy

# Restore Javadocs from 1.x, 2.x, and 3.x.
git checkout gh-pages
git cherry-pick bb229b9dcc9a21a73edbf8d936bea88f52e0a3ff
git cherry-pick c695732f1d4aea103b826876c077fbfea630e244
git push --set-upstream origin gh-pages

# Delete our temp folder
cd ..

      return socket.isHealthy(source)
    }

    return true
  }

  /** Refuse incoming streams. */
  @Throws(IOException::class)
  override fun onStream(stream: Http2Stream) {
    stream.close(ErrorCode.REFUSED_STREAM, null)
  }

  /** When settings are received, adjust the allocation limit. */
  override fun onSettings(
    connection: Http2Connection,
    settings: Settings,
  ) {

## Version 4.3.0

_2019-12-31_

 *  Fix: Degrade HTTP/2 connections after a timeout. When an HTTP/2 stream times out it may impact
    the stream only or the entire connection. With this fix OkHttp will now send HTTP/2 pings after
    a stream timeout to determine whether the connection should remain eligible for pooling.

      sleepNanos(response.headersDelayNanos)
      stream.writeHeaders(response.toHttp2Headers(), outFinished, flushHeaders)

      if (trailers.size > 0) {
        stream.enqueueTrailers(trailers)
      }
      pushPromises(stream, request, response.pushPromises)
      if (body != null) {
        sleepNanos(bodyDelayNanos)
        val responseBodySink =
          stream.getSink().withThrottlingAndSocketPolicy(

 */
@ExperimentalOkHttpApi
interface Stream {
  val requestBody: BufferedSource
  val responseBody: BufferedSink

  /**
   * Terminate the stream so that no further data is transmitted or received. Note that
   * [requestBody] may return data after this call; that is the buffered data received before this
   * stream was canceled.
   *

      if (file.isDirectory) {
        serveDirectory(stream, file.listFiles()!!)
      } else if (file.exists()) {
        serveFile(stream, file)
      } else {
        send404(stream, path)
      }
    } catch (e: IOException) {
      Platform.get().log("Failure serving Http2Stream: " + e.message, Platform.INFO, null)
    }
  }

  private fun send404(
    stream: Http2Stream,
    path: String,
  ) {

    peer.acceptFrame() // SYN_STREAM on stream 1
    for (i in 0 until framesThatFillWindow) {
      peer.acceptFrame() // DATA on stream 1
    }
    peer.acceptFrame() // SYN_STREAM on stream 2
    peer.acceptFrame() // DATA on stream 2
    peer.play()

    // Play it back.
    val connection = connect(peer)
    val stream1 = connection.newStream(headerEntries("a", "apple"), true)

    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
    stream!!.writeTimeout().timeout(chain.writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
  }

  override fun flushRequest() {
    http2Connection.flush()
  }

  override fun finishRequest() {

    assertThat(formattedFlags).containsExactly(
      "",
      "END_STREAM",
      "00000010",
      "00000011",
      "END_HEADERS",
      "END_STREAM|END_HEADERS",
      "00000110",
      "00000111",
      "PADDED",
      "END_STREAM|PADDED",
      "00001010",
      "00001011",
      "00001100",
      "END_STREAM|END_HEADERS|PADDED",
      "00001110",
      "00001111",
      "00010000",