bitreq: Fix connection persistence, pool refresh

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.

[tnull]

Based on #660.
Closes#659.

Honor HTTP persistence rules
Reuse HTTP/1.1 connections unless either endpoint requests
closure, and require explicit keep-alive only for HTTP/1.0. This
allows compliant servers to omit redundant keep-alive headers while
still preventing reuse after a close option.

Refresh async pool entries on reuse A cache hit must make its connection the most recently used entry.
Without that refresh, inserting another origin can evict an actively
reused connection and retain an older idle one.

[TheBlueMatt]

Thanks, changes in this PR LGTM, had one question in the dep PR though.

[tnull]

Force-pushed with the following changes:

diff --git a/bitreq/src/client.rs b/bitreq/src/client.rs
index f2a9bb25..d71c349c 100644
--- a/bitreq/src/client.rs+++ b/bitreq/src/client.rs@@ -69,5 +69,6 @@ impl Client {
let mut state = self.r#async.lock().unwrap();
- if let Some(conn) = state.connections.get(&owned_key).cloned() {+ if let Some(conn) = state.connections.get(&owned_key) {+ let conn = Arc::clone(conn);
state.lru_order.retain(|key| key != &owned_key);
state.lru_order.push_back(owned_key.clone());
diff --git a/bitreq/src/connection.rs b/bitreq/src/connection.rs
index 1fe7b92c..3b28bad4 100644
--- a/bitreq/src/connection.rs+++ b/bitreq/src/connection.rs@@ -587,5 +587,5 @@ impl AsyncConnection {
.await?;
- let connection = response.headers.get("connection").map(String::as_str);+ let connection = response.headers.get("connection");
let received_close =
connection.is_some_and(|value| has_connection_option(value, "close"));

[tcharding]

Please note development has migrated to https://git.rust-bitcoin.org/rust-bitcoin/corepc. Any further comments or pushes here on github may be ignored or lost. Closing since I know @tnull is ok with the migration.