* Add retryDecision event to track retry logic in EventListener
Introduced a new `retryDecision` event to improve observability of retry logic. This includes detailed reasons for retry decisions, enhancing debugging. Updated relevant tests, interceptors, and event handling to accommodate the new event.
It also cleanly signals the boundary before a prior request and the follow up.
Refactor: Centralize lock management
This change centralizes the management of locks and conditions by introducing a centralised Locks registry. This allows for easier debugging and potential future improvements to lock usage.
The `withLock` and `newLockCondition` functions are now invoked through the `Locks` object, providing a central point of access.
We've got a race where we'll start a thread when we need
one, even if we've already started a thread. This changes
TaskRunner's behavior to never add a thread if we're
still waiting for a recently-added one to start running.
This is intended to reduce the number of threads contenting
for the TaskRunner lock as reported in this issue:
https://github.com/square/okhttp/issues/8388
This is different from the production thread factory:
- No daemon threads in tests. We don't need 'em.
- Threads are numbered in tests. We do need that.
* Redo TaskFaker's internal queue
Previously this used locks to stop threads from executing. Now
it uses a custom 'yield' function to accomplish a similar purpose.
The main benefit of the new approach is we're no longer subject
to unspecified lock release order - we maintain our own queue
and get true deterministic order of execution.
* Fix interruption
* Fixup tests
* Spotless
* Use an enum rather than two booleans
This PR adds support for configuring the connection pool to proactively create connections to specified hosts. This is useful for "prewarming" the connection pool before it starts being used.
The main public API change is adding `ConnectionPool.setPolicy(Address, AddressPolicy)`. A policy specifies how many _concurrent streams_ should be supported by the pool (which might be satisfied by a single http/2 connection or by N http/1.1 connections).
The main internal change is adding a new task queue to `RealConnectionPool` which checks to see if it needs to create new connections to satisfy existing policies. This task is enqueued any time a policy changes, a connection is closed, or an http/2 connection's settings decrease the number of concurrent streams supported.
This is working towards supporting pre-warmed connections
in ConnectionPool. We want to create connections without a
Call object.
Co-authored-by: Evan Nelson <enelson@squareup.com>
* Prepare to enable Spotless
I'm not super keen on any of these changes, but I am very
keen on having automatic formatting.
* Don't actually enable Spotless yet
* Switch to assertk.fail
* Use assertFailsWith
* More assertFailsWith
* Use more assertFailsWith
* More assertFailsWith
* More assertFailsWith
* Native image dependencies
* Move JUnit dependency
* Don't lock in a specific implementation class
* Missing finally
* Even more assertk
When we split tests into multiplatform we switched them
from AssertJ to assertk. I'm migrating everything over to
assertk so that I can merge tests back together without
changing assertion APIs.
* Fixup some type conversion problems
* Switch back to the kotlin JVM plugin
This does a ton of file moves from jvmMain to main, and jvmTest to test.
* Don't use AnimalSniffer on okcurl
* Use assertk more (#8150)
Just hard-coding 'localhost' is simpler and avoids problems where
the host machine's IP address has additional DNS registrations.
Closes: https://github.com/square/okhttp/issues/7603
* Attempt at a ConnectionListener
* Fixes
* Test for locks
* Fix for locking
* Add events in RouteFailureTest
* Fixes
* Fixes
* Fixes
* Fast path when None
* Don't defer connectionClosed events
* Don't enqueue connection events
Co-authored-by: Jesse Wilson <jwilson@squareup.com>
* Add a proper Kotlin constructor for Request
This turns out to be very useful throughout our test suite.
* Dump updated API
* Fix multipleTags Kotlin conversion
In a race this could cause us to prefer a new connection over
a pooled connection, which violates our invariant that pooled
connections are always used if they're found.
Closes: https://github.com/square/okhttp/issues/7152
