while (true) {
          val socket = serverSocket!!.accept()
          connectionCount.incrementAndGet()
          service(socket)
        }
      } catch (e: SocketException) {
        logger.info("$threadName done accepting connections: ${e.message}")
      } catch (e: IOException) {
        logger.log(Level.WARNING, "$threadName failed unexpectedly", e)
      } finally {
        for (socket in openSockets) {

      receivedCloseCode == -1
    } catch (e: Exception) {
      failWebSocket(e = e)
      false
    }
  }

  /**
   * Clean up and publish necessary close events when the reader is done. Invoked only by the reader
   * thread.
   */
  fun finishReader() {
    val failed: Boolean
    val code: Int
    val reason: String?
    var streamsToClose: Streams?

Change Log
==========

## Version 4.x

See [4.x Change log](https://square.github.io/okhttp/changelogs/changelog_4x/) for the stable version changelogs.

## Version 5.0.0-alpha.14

_2024-04-17_

 *  Breaking: Move coroutines extensions to okhttp3.coroutines. Previously this artifact shared the
    `okhttp3` package name with our core module, which is incompatible with the Java Platform Module
    System.

    `NullPointerException`.
 *  Fix: Better handling of uncaught exceptions in MockWebServer with HTTP/2.

## Version 2.3.0

_2015-03-16_

 *  **HTTP/2 support.** We've done interop testing and haven't seen any
    problems. HTTP/2 support has been a big effort and we're particularly
    thankful to Adrian Cole who has helped us to reach this milestone.

        .build();

    final ProgressListener progressListener = new ProgressListener() {
      boolean firstUpdate = true;

      @Override public void update(long bytesRead, long contentLength, boolean done) {
        if (done) {
          System.out.println("completed");
        } else {
          if (firstUpdate) {
            firstUpdate = false;
            if (contentLength == -1) {

    // First response is still waiting.
    assertThat(firstResponseCode.get()).isEqualTo(0)
    // Second response is done.
    assertThat(secondResponseCode.get()).isEqualTo(200)
    latch.countDown()
    startsFirst.join()
    // And now it's done!
    assertThat(firstResponseCode.get()).isEqualTo(200)
    // (Still done).
    assertThat(secondResponseCode.get()).isEqualTo(200)
  }

  private fun buildRequestThread(

        if (read == -1L) throw EOFException()
        remainingByteCount -= read

        // Move the received data to the read buffer to the reader can read it. If this source has
        // been closed since this read began we must discard the incoming data and tell the
        // connection we've done so.
        ******@****.***ck {
          if (closed) {
            receiveBuffer.clear()
          } else {

     * may be started on the same key.
     */
    @Throws(IOException::class)
    fun commit() {
      synchronized(this@DiskLruCache) {
        check(!done)
        if (entry.currentEditor == this) {
          completeEdit(this, true)
        }
        done = true
      }
    }

    /**
     * Aborts this edit. This releases the edit lock so another edit may be started on the same
     * key.
     */

logFile = File("/tmp/key.log"), tlsVersions = tlsVersions, launch = launch)`
 * 3. Register with `client.eventListenerFactory(eventListenerFactory)`
 * 4. Launch wireshark if not done externally `val process = eventListenerFactory.launchWireShark()`
 */
@SuppressSignatureCheck
class WireSharkListenerFactory(
  private val logFile: File,
  private val tlsVersions: List<TlsVersion>,

    cleanupQueue.schedule(cleanupTask)
  }

  /**
   * Ensure enough connections open to [address] to satisfy its [ConnectionPool.AddressPolicy].
   * If there are already enough connections, we're done.
   * If not, we create one and then schedule the task to run again immediately.
   */
  private fun openConnections(state: AddressState): Long {
    // This policy does not require minimum connections, don't run again