repo stringclasses 1
value | pull_number int64 20 3.81k | instance_id stringlengths 18 20 | issue_numbers listlengths 1 2 | base_commit stringlengths 40 40 | patch stringlengths 214 153k | test_patch stringlengths 288 262k | problem_statement stringlengths 22 7.42k | hints_text stringlengths 0 66.9k | created_at stringlengths 20 20 | version stringclasses 21
values | environment_setup_commit stringclasses 21
values |
|---|---|---|---|---|---|---|---|---|---|---|---|
hyperium/hyper | 3,813 | hyperium__hyper-3813 | [
"3811"
] | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
--- a/src/proto/h1/io.rs
+++ b/src/proto/h1/io.rs
@@ -248,7 +248,11 @@ where
}
}
if curr_len > 0 {
+ trace!("partial headers; {} bytes so far", curr_len);
... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -2908,6 +2908,63 @@ mod conn {
assert_eq!(vec, b"bar=foo");
}
+ #[tokio::test]
+ async fn client_100_then_http09() {
+ let _ = ::pretty_env_logger::try_init();
+
+ let server = TcpListener::... | Intermittent panic in is_complete_fast
**Version**
1.5.1
**Platform**
`Darwin ghost.local 23.5.0 Darwin Kernel Version 23.5.0: Wed May 1 20:19:05 PDT 2024; root:xnu-10063.121.3~5/RELEASE_ARM64_T8112 arm64`
**Description**
Hyper client can panic when processing broken up 1xx HTTP1 responses.
When a server r... | Thanks for the sample code, I'll get this fixed today 🫡 | 2024-12-16T15:39:30Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 3,812 | hyperium__hyper-3812 | [
"3811"
] | a3bda62da36060a38638fba983a0c07c0ab6259d | diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
--- a/src/proto/h1/io.rs
+++ b/src/proto/h1/io.rs
@@ -205,7 +205,11 @@ where
return Poll::Ready(Err(crate::Error::new_too_large()));
}
if curr_len > 0 {
+ trace!("partial header... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -2041,6 +2041,63 @@ mod conn {
assert_eq!(vec, b"bar=foo");
}
+ #[tokio::test]
+ async fn client_100_then_http09() {
+ let (server, addr) = setup_std_test_server();
+
+ thread::spawn(move ||... | Intermittent panic in is_complete_fast
**Version**
1.5.1
**Platform**
`Darwin ghost.local 23.5.0 Darwin Kernel Version 23.5.0: Wed May 1 20:19:05 PDT 2024; root:xnu-10063.121.3~5/RELEASE_ARM64_T8112 arm64`
**Description**
Hyper client can panic when processing broken up 1xx HTTP1 responses.
When a server r... | Thanks for the sample code, I'll get this fixed today 🫡 | 2024-12-16T14:50:50Z | 1.5 | a3bda62da36060a38638fba983a0c07c0ab6259d |
hyperium/hyper | 3,799 | hyperium__hyper-3799 | [
"3790"
] | eaf2267cdc148604469fb09da22646f31710107a | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -279,7 +279,7 @@ jobs:
- name: Install Rust
uses: dtolnay/rust-toolchain@master
with:
- toolchain: nightly-2024-05-01 # Compatible version for cargo-check-... | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -195,7 +195,7 @@ jobs:
- name: Run FFI unit tests
env:
RUSTFLAGS: --cfg hyper_unstable_ffi
- run: cargo test --features server,client,http1,http2,ffi --lib
... | Make client tests work without server feature
Running `cargo test --features http1,http2,client` fails to compile because it uses some types only available when the `server` feature is also enabled. Fixing this would just require adding or adjusting `#[cfg(feature = ...)]` attributes, paying attention to the compiler e... | 2024-11-28T16:18:04Z | 1.5 | a3bda62da36060a38638fba983a0c07c0ab6259d | |
hyperium/hyper | 3,787 | hyperium__hyper-3787 | [
"3786"
] | 3b7375a16f23fb9a0975304ba6616af9323f3f13 | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -23,6 +23,7 @@ jobs:
- features
- ffi
- ffi-header
+ - ffi-cargo-c
- doc
- check-external-types
- udeps
diff --git a/Cargo.toml b/Cargo.toml
--... | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -226,6 +227,31 @@ jobs:
- name: Ensure that hyper.h is up to date
run: ./capi/gen_header.sh --verify
+ ffi-cargo-c:
+ name: Test cargo-c support (FFI)
+ needs: [styl... | cargo-c integration and dynamic linking
**Is your feature request related to a problem? Please describe.**
I'm trying to get the FFI interface of hyper up to speed with rustls-ffi, for integration in an operating system.
Compare the current [curl hyper documentation](https://github.com/curl/curl/blob/cb2ae6e8a8614a... | For what it's worth I've been happy with cargo-c and the upstream maintainers have been very helpful. In rustls-ffi I'm moving towards replacing the old `Makefile` approach (as linked to from the current curl docs) and instead recommending cargo-c as the blessed path for building the library (static or dynamic).
I've i... | 2024-11-19T21:40:38Z | 1.5 | a3bda62da36060a38638fba983a0c07c0ab6259d |
hyperium/hyper | 3,725 | hyperium__hyper-3725 | [
"3720"
] | 4c4de90a7e2aa0629b9c167a482399e28ccb0975 | diff --git a/benches/server.rs b/benches/server.rs
--- a/benches/server.rs
+++ b/benches/server.rs
@@ -72,7 +72,7 @@ macro_rules! bench_server {
tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
.unwrap();
let mut buf = Vec::new();
- t... | diff --git a/benches/pipeline.rs b/benches/pipeline.rs
--- a/benches/pipeline.rs
+++ b/benches/pipeline.rs
@@ -76,7 +76,7 @@ fn hello_world_16(b: &mut test::Bencher) {
tcp.write_all(b"GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n")
.unwrap();
let mut buf = Vec::new();
- ... | No `Connection: close` on HTTP1 Connection Drain
When HTTP1 connection draining is activated, the Connection: close header is not attached to responses sent to active connections. This prevents active clients from realizing that the server is requesting that the connection be closed and prevents graceful draining of HT... | Thanks for the report! I could have sworn we did this, but then tweaked the test and you're right, not done. PR is up at #3725.
Thank you @seanmonstar!
Reopened this until the PR #3725 gets merged. | 2024-08-02T20:50:20Z | 1.4 | 4c4de90a7e2aa0629b9c167a482399e28ccb0975 |
hyperium/hyper | 3,691 | hyperium__hyper-3691 | [
"3673"
] | aa7ff605da3b706e855f9633b8dddeb9463217d4 | diff --git a/src/client/conn/http1.rs b/src/client/conn/http1.rs
--- a/src/client/conn/http1.rs
+++ b/src/client/conn/http1.rs
@@ -12,7 +12,7 @@ use futures_util::ready;
use http::{Request, Response};
use httparse::ParserConfig;
-use super::super::dispatch;
+use super::super::dispatch::{self, TrySendError};
use cr... | diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -13,10 +13,21 @@ use tokio::sync::{mpsc, oneshot};
#[cfg(feature = "http2")]
use crate::{body::Incoming, proto::h2::client::ResponseFutMap};
-#[cfg(test)]
-pub(crate) type RetryPromise<T, U> = o... | hyper client happens cacel error which should retry
**Version**
List the version(s) of `hyper`, and any relevant hyper dependency (such as `h2` if this is related to HTTP/2).
hyper = { version = "1.1.0", features = ["full"] }
hyper-util = { version = "0.1.3", features = ["full"] }
**Platform**
The output of `una... | i found the error msg from the drop func,just as follow
if Envelope still has req, it means req never send ,should it has the chance to retry?
struct Envelope<T, U>(Option<(T, Callback<T, U>)>);
impl<T, U> Drop for Envelope<T, U> {
fn drop(&mut self) {
if let Some((val, cb)) = self.0.take() {
... | 2024-06-21T20:09:56Z | 1.3 | aa7ff605da3b706e855f9633b8dddeb9463217d4 |
hyperium/hyper | 3,637 | hyperium__hyper-3637 | [
"2703"
] | 721785efad8537513e48d900a85c05ce79483018 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -11,6 +11,7 @@ use bytes::{Buf, Bytes};
use futures_util::ready;
use http::header::{HeaderValue, CONNECTION, TE};
use http::{HeaderMap, Method, Version};
+use http_body::Frame;
use httparse::ParserConfi... | diff --git a/src/body/incoming.rs b/src/body/incoming.rs
--- a/src/body/incoming.rs
+++ b/src/body/incoming.rs
@@ -403,6 +403,19 @@ impl Sender {
.map_err(|err| err.into_inner().expect("just sent Ok"))
}
+ #[cfg(feature = "http1")]
+ pub(crate) fn try_send_trailers(
+ &mut self,
+ ... | Receiving HTTP/1.1 trailers
| 2024-04-17T00:18:10Z | 1.3 | aa7ff605da3b706e855f9633b8dddeb9463217d4 | |
hyperium/hyper | 3,616 | hyperium__hyper-3616 | [
"3615",
"3615"
] | bc9a86f58f8bd5c35b2bfd7e632ec132280d79ba | diff --git a/src/server/conn/http1.rs b/src/server/conn/http1.rs
--- a/src/server/conn/http1.rs
+++ b/src/server/conn/http1.rs
@@ -482,7 +482,11 @@ where
/// This `Connection` should continue to be polled until shutdown
/// can finish.
pub fn graceful_shutdown(mut self: Pin<&mut Self>) {
- Pin::ne... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1256,6 +1256,67 @@ async fn disable_keep_alive_post_request() {
child.join().unwrap();
}
+#[tokio::test]
+async fn http1_graceful_shutdown_after_upgrade() {
+ let (listener, addr) = setup_tcp_listener();
+ let (... | Panic on graceful shutdown for http/1
**Version**
Encountered with `1.x`
**Platform**
Doesn't matter
**Description**
Attempt to call `graceful_shutdown` for H1 connection which is upgraded (=> `Poll::Ready`) leads to panic:
```
panic was raised: panicked at /usr/local/cargo/registry/src/index.crates.io-6f1... | 2024-03-30T11:42:44Z | 1.2 | bc9a86f58f8bd5c35b2bfd7e632ec132280d79ba | |
hyperium/hyper | 3,517 | hyperium__hyper-3517 | [
"3477"
] | a9fa893f18c6409abae2e1dcbba0f4487df54d4f | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,6 +41,8 @@ want = { version = "0.3", optional = true }
[dev-dependencies]
form_urlencoded = "1"
+futures-channel = { version = "0.3", features = ["sink"] }
+futures-util = { version = "0.3", default-features = false, features = ["sink"] }... | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -140,7 +140,6 @@ fn http2_parallel_x10_req_10mb(b: &mut test::Bencher) {
}
#[bench]
-#[ignore]
fn http2_parallel_x10_req_10kb_100_chunks(b: &mut test::Bencher) {
let body = &[b'x'; 1024 * 10];... | Re-enable end-to-end request chunks benchmarks
The request chunks benchmarks were disabled as part of the upgrade to v1.0. It should now be easier to re-enable them.
- Update the [code](https://github.com/hyperium/hyper/blob/d3cfb9e0b1928701cfdd96c9551c4bd81c24e83a/benches/end_to_end.rs#L347-L358) to use an async `m... | Can I take this one? | 2024-01-08T16:38:08Z | 1.1 | a9fa893f18c6409abae2e1dcbba0f4487df54d4f |
hyperium/hyper | 3,375 | hyperium__hyper-3375 | [
"2719"
] | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -8,7 +8,7 @@ use std::time::Duration;
use crate::rt::{Read, Write};
use bytes::{Buf, Bytes};
-use http::header::{HeaderValue, CONNECTION};
+use http::header::{HeaderValue, CONNECTION, TE};
use http::{H... | diff --git a/src/proto/h1/encode.rs b/src/proto/h1/encode.rs
--- a/src/proto/h1/encode.rs
+++ b/src/proto/h1/encode.rs
@@ -327,7 +439,16 @@ impl std::error::Error for NotEof {}
#[cfg(test)]
mod tests {
+ use std::iter::FromIterator;
+
use bytes::BufMut;
+ use http::{
+ header::{
+ AUTHO... | Sending HTTP/1.1 trailers
Here's a list of pieces needed to make this work:
- Update [`proto::h1::Dispatcher::poll_write()`](https://github.com/hyperium/hyper/blob/f1b89c117cffebed4b2b8eb2d221fd9b25c1d3d1/src/proto/h1/dispatch.rs#L365) so that when all data items are done (is `None`), check the body for trails `poll... | @Xuanwo I've updated the issue above to include a list of things I think that needs to be done. If anything is missing, we can add more instructions here! | 2023-10-26T10:31:05Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,312 | hyperium__hyper-3312 | [
"2844"
] | 0891c9e3084453f4ff239c5059f3dddcbe25f1fb | diff --git a/src/error.rs b/src/error.rs
--- a/src/error.rs
+++ b/src/error.rs
@@ -8,6 +8,18 @@ pub type Result<T> = std::result::Result<T, Error>;
type Cause = Box<dyn StdError + Send + Sync>;
/// Represents errors that can occur handling HTTP streams.
+///
+/// # Formatting
+///
+/// The `Display` implementation ... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -2318,10 +2318,6 @@ mod conn {
let error = client.send_request(req).await.unwrap_err();
assert!(error.is_user());
- assert_eq!(
- error.to_string(),
- "dispatch task is gone: us... | Figure out hyper::Error Display including source chain
The current `Display` output of `Error` [doesn't match what many people think it should](https://github.com/hyperium/hyper/blob/master/docs/ROADMAP.md#errors), namely that it prints the error chain. We need to either:
- Change `hyper::Error` to not print the sou... | I filed a proposal for the working group: https://github.com/rust-lang/project-error-handling/issues/53 | 2023-09-11T20:09:02Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,275 | hyperium__hyper-3275 | [
"2872"
] | a45d5d5a04369f93334fc893875d8d1a49054e04 | diff --git a/src/body/incoming.rs b/src/body/incoming.rs
--- a/src/body/incoming.rs
+++ b/src/body/incoming.rs
@@ -201,7 +201,16 @@ impl Body for Incoming {
ping.record_data(bytes.len());
return Poll::Ready(Some(Ok(Frame::data(bytes))));
... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -1338,7 +1338,7 @@ mod conn {
use bytes::{Buf, Bytes};
use futures_channel::{mpsc, oneshot};
use futures_util::future::{self, poll_fn, FutureExt, TryFutureExt};
- use http_body_util::{BodyExt, Empty, StreamBo... | Client: handle `RST_STREAM` with `NO_ERROR` set for the reason
**Version**
```
hyper = "0.14.18"
h2 = "0.3.13"
```
**Platform**
```
> uname -a
Linux <REDACTED> 5.17.5-76051705-generic #202204271406~1651504840~22.04~63e51bd SMP PREEMPT Mon May 2 15: x86_64 x86_64 x86_64 GNU/Linux
```
**Description**
I've ... | Yea, I think we've talked about this in a previous issue, but don't remember where. `h2` is making the "error" (the reset) trump any other frames that have been received. It should likely be changed to return all other received frames, and *then* return the error.
But _somewhere_ in the stack it should probably just su... | 2023-07-23T01:01:36Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,274 | hyperium__hyper-3274 | [
"2872"
] | d77c2599bc023b258b90a17f5b633c8b7b0cbd4b | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -323,7 +323,12 @@ impl Body {
ping.record_data(bytes.len());
Poll::Ready(Some(Ok(bytes)))
}
- Some(Err(e)) => Poll::Ready(Some(Err(crate::Error::new... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -3154,6 +3154,61 @@ mod conn {
.expect("client should be open");
}
+ #[tokio::test]
+ async fn http2_responds_before_consuming_request_body() {
+ // Test that a early-response from server works... | Client: handle `RST_STREAM` with `NO_ERROR` set for the reason
**Version**
```
hyper = "0.14.18"
h2 = "0.3.13"
```
**Platform**
```
> uname -a
Linux <REDACTED> 5.17.5-76051705-generic #202204271406~1651504840~22.04~63e51bd SMP PREEMPT Mon May 2 15: x86_64 x86_64 x86_64 GNU/Linux
```
**Description**
I've ... | Yea, I think we've talked about this in a previous issue, but don't remember where. `h2` is making the "error" (the reset) trump any other frames that have been received. It should likely be changed to return all other received frames, and *then* return the error.
But _somewhere_ in the stack it should probably just su... | 2023-07-23T01:01:19Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 3,261 | hyperium__hyper-3261 | [
"2730"
] | d92d3917d950e4c61c37c2170f3ce273d2a0f7d1 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -175,6 +175,13 @@ where
}
}
+ #[cfg(feature = "server")]
+ pub(crate) fn has_initial_read_write_state(&self) -> bool {
+ matches!(self.state.reading, Reading::Init)
+ ... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -31,6 +31,7 @@ use hyper::body::{Body, Incoming as IncomingBody};
use hyper::server::conn::{http1, http2};
use hyper::service::{service_fn, Service};
use hyper::{Method, Request, Response, StatusCode, Uri, Version};
+use to... | Connection::graceful_shutdown always waits for the first request.
**Version**
hyper 0.14.16
**Platform**
Linux DESKTOP-DHO88R7 4.19.104-microsoft-standard #1 SMP Wed Feb 19 06:37:35 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux
**Description**
If you gracefully shut down a server connection future before the first r... | Yea, I think this is behavior is currently on purpose. Whether it _should_ be is a fair question. I think at the time, I assumed that a _new_ connection would usually have a request incoming ASAP, whereas an idle connection might not, and so it was better to allow that request to come in.
We could alter that behavio... | 2023-07-06T18:47:14Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,257 | hyperium__hyper-3257 | [
"3253"
] | 297dc4c8ea2dbc844d030418f79a6869fd67f496 | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -602,17 +602,16 @@ impl Sender {
}
/// Aborts the body in an abnormal fashion.
- pub fn abort(self) {
+ pub fn abort(mut self) {
+ self.send_error(crate::Error::new_body_write_aborted());
+ }
+
... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -62,7 +62,7 @@ tokio = { version = "1", features = [
] }
tokio-test = "0.4"
tokio-util = { version = "0.7", features = ["codec"] }
-tower = { version = "0.4", features = ["make", "util"] }
+tower = { version = "0.4", default-features = false, ... | Missing error when reading stream of data out of an interrupted chunked-encoded request
**Version**
hyper 0.14.26
tokio 1.28.1
**Platform**
```Linux my-hostname 5.10.0-18-amd64 #1 SMP Debian 5.10.140-1 (2022-09-02) x86_64 GNU/Linux```
**Description**
Error is not propagated via stream in some cases when c... | I've been playing around with the demo on my own machine, and even without the timeout, I see what you're describing. When I turn on tracing, I see that the connection task encounters a _write_ error, because the socket is closed, and then that closes up the task.
I would guess that it depends on what exact option t... | 2023-06-19T18:36:20Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 3,254 | hyperium__hyper-3254 | [
"3252"
] | aa330bcba0ac0cb30868181ac870947604b9ecbf | diff --git a/src/proto/h1/dispatch.rs b/src/proto/h1/dispatch.rs
--- a/src/proto/h1/dispatch.rs
+++ b/src/proto/h1/dispatch.rs
@@ -366,7 +366,12 @@ where
self.conn.end_body()?;
}
} else {
- return Poll::Pending;
+ // If... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -92,6 +92,7 @@ mod response_body_lengths {
}
fn run_test(case: TestCase) {
+ let _ = pretty_env_logger::try_init();
assert!(
case.version == 0 || case.version == 1,
"TestCa... | Chunked HTTP/1.1 doesn't send the last zero-chunk when body is empty
**Version**
hyper 0.14.26, h2 0.3.19, http 0.2.9
**Platform**
Linux 5.15, Ubuntu 22.04
**Description**
In HTTP/1.1, when `transfer-encoding: chunked` is set, all the data should be sent at a format of chunk. However, in hyper, if the body par... | Oh, interesting. This is _supposed_ to work, and we have a matrix of `response_body_lengths` tests for a bunch of combinations (headers existing, body type knows it's own length, etc), and I noticed this specific combination wasn't included (chunked header set, known empty). Adding it, and the test does indeed hang. I'... | 2023-06-16T17:01:17Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,230 | hyperium__hyper-3230 | [
"3110"
] | f4b513009d81083081d1c60c1981847bbb17dd5d | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -315,7 +314,8 @@ impl Opts {
let mut client = rt.block_on(async {
if self.http2 {
- let io = tokio::net::TcpStream::connect(&addr).await.unwrap();
+ ... | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -4,8 +4,7 @@
extern crate test;
mod support;
-// TODO: Reimplement Opts::bench using hyper::server::conn and hyper::client::conn
-// (instead of Server and HttpClient).
+// TODO: Reimplement paralle... | hyper should use its own IO traits
This was actually brought up as [an unresolved question in the ROADMAP](https://github.com/hyperium/hyper/blob/master/docs/ROADMAP.md#should-there-be-hyperio-traits). I think I mentally dismissed it at some point as just being annoying, but in the past week as I've thought about how w... | cc @Noah-Kennedy @erickt @dhobsd
I am a fan of this if a proper trait could be found and the tokio experience has short-cuts such that the difference in experience with this change is minimal. But since that will go in util I don't see why hyper core it self shouldn't be based on its own io types.
I think you want to g... | 2023-05-17T21:38:21Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,185 | hyperium__hyper-3185 | [
"3178"
] | f9aa697ec371d36c6d553c988d84b6f709e63362 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -1,10 +1,12 @@
use std::fmt;
+#[cfg(feature = "server")]
+use std::future::Future;
use std::io;
use std::marker::{PhantomData, Unpin};
use std::pin::Pin;
use std::task::{Context, Poll};
#[cfg(feature ... | diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
--- a/src/proto/h1/io.rs
+++ b/src/proto/h1/io.rs
@@ -660,10 +630,8 @@ enum WriteStrategy {
#[cfg(test)]
mod tests {
- use crate::common::io::Compat;
- use crate::common::time::Time;
-
use super::*;
+ use crate::common::io::Compat;
use std::tim... | timeout while waiting for headers
There doesn't seem a way to specify, on a server, after a client connection has been accepted, a read timeout so as to close the client connection after a while when no client headers have been sent at all. See for instance the [ReadTimeout](https://blog.cloudflare.com/exposing-go-on-t... | Hm, I see that in #2675, it originally started the timer immediately, but it was suggested it should wait because some clients make connections eagerly. While there may be clients that do that, it does seem like the timer should probably start right away anyways. The servers resources are more constrained than a client... | 2023-03-24T19:15:51Z | 1.3 | aa7ff605da3b706e855f9633b8dddeb9463217d4 |
hyperium/hyper | 3,152 | hyperium__hyper-3152 | [
"2925"
] | 9feb70e9249d9fb99634ec96f83566e6bb3b3128 | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -24,6 +24,7 @@ jobs:
- ffi
- ffi-header
- doc
+ - check-external-types
steps:
- run: exit 0
diff --git /dev/null b/.github/workflows/external-types.to... | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -210,3 +211,26 @@ jobs:
- name: cargo doc
run: cargo rustdoc --features full,ffi -- --cfg docsrs --cfg hyper_unstable_ffi -D broken-intra-doc-links
+
+ check-external-type... | Set up CI to audit for public dependency types
We want strict control over what types from dependencies we expose, and there is a tool that can help us check that in CI: [cargo api-linter](https://github.com/awslabs/smithy-rs/tree/main/tools/api-linter).
We should start by adding a new CI job to `.github/workflows/C... | Looks like that has been refactored into [cargo-check-external-types](https://github.com/awslabs/smithy-rs/tree/main/tools/cargo-check-external-types). I'll pick up this up.
I ran this tool against the master branch (982e6a51385). Any objections to these types being exposed and added to the allowlist, @seanmonstar? The... | 2023-02-28T22:51:48Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,135 | hyperium__hyper-3135 | [
"3128"
] | 5bf16402f7a146417a9f997387401f9dc5a7d63d | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -316,11 +316,10 @@ impl Opts {
let mut client = rt.block_on(async {
if self.http2 {
let io = tokio::net::TcpStream::connect(&addr).await.unwrap();
- ... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -1922,8 +1922,7 @@ mod conn {
});
let io = tcp_connect(&addr).await.expect("tcp connect");
- let (mut client, conn) = conn::http2::Builder::new()
- .executor(TokioExecutor)
+ let (m... | `http2::handshake()` is useless in 1.0 given no default executor
**Version**
hyper 1.0.0-rc2
**Description**
`hyper::client::conn::http2::handshake(io).await` causes an instant panic. Internally it performs `Builder::new().handshake(io).await` which uses the `Exec::Default` executor. There is no longer a defau... | Good catch, thank you! | 2023-01-30T19:09:16Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,125 | hyperium__hyper-3125 | [
"3027"
] | d977f209bc6068d8f878b22803fc42d90c887fcc | diff --git a/benches/support/tokiort.rs b/benches/support/tokiort.rs
--- a/benches/support/tokiort.rs
+++ b/benches/support/tokiort.rs
@@ -41,6 +41,12 @@ impl Timer for TokioTimer {
inner: tokio::time::sleep_until(deadline.into()),
})
}
+
+ fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, ... | diff --git a/benches/support/tokiort.rs b/benches/support/tokiort.rs
--- a/benches/support/tokiort.rs
+++ b/benches/support/tokiort.rs
@@ -75,7 +81,10 @@ impl Future for TokioSleep {
}
}
-// Use HasSleep to get tokio::time::Sleep to implement Unpin.
-// see https://docs.rs/tokio/latest/tokio/time/struct.Sleep.h... | Timer::reset can't soundly have an optimized implementation
In 1.0.0-rc.1, the new `Timer` trait has a method to reset an existing `Sleep` to a new deadline. The default implementation simply creates a new `Sleep` and writes it over the old one, but presumably this method exists to it can be overridden with a better im... | Sigh, yea, I forgot about this. And Rust still hasn't made this any easier; we can't just say `trait Sleep: Any`. So, let's see, I think these are the options:
- Copy the methods from `Any` into `Sleep`, which allows checking `type_id` and then calling `downcast_mut`. To make it safe, it probably needs to implement th... | 2023-01-23T17:54:48Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,102 | hyperium__hyper-3102 | [
"3079"
] | 0368a41a6cc1a5c6f1eada0d88e38b7dce261587 | diff --git a/src/server/conn.rs b/src/server/conn.rs
--- a/src/server/conn.rs
+++ b/src/server/conn.rs
@@ -58,6 +58,11 @@ use crate::error::{Kind, Parse};
#[cfg(feature = "http1")]
use crate::upgrade::Upgraded;
+#[cfg(all(feature = "backports", feature = "http1"))]
+pub mod http1;
+#[cfg(all(feature = "backports", ... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -2641,6 +2641,144 @@ async fn http2_keep_alive_count_server_pings() {
.expect("timed out waiting for pings");
}
+// Tests for backported 1.0 APIs
+mod backports {
+ use super::*;
+ use hyper::server::conn::{h... | Backport the split server conn modules
In 1.0, we've split hyper::server::conn::Connection into per-version types. To ease upgrading (see https://github.com/hyperium/hyper/issues/3052), we can backport the addition of the two modules, hyper::server::conn::{http1, http2}. With them in place, we could then add a deprecat... | 2022-12-27T22:14:51Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 3,101 | hyperium__hyper-3101 | [
"3085"
] | 984760f76aaf5f0e20dddd119cad8188ca81e0e4 | diff --git a/examples/http_proxy.rs b/examples/http_proxy.rs
--- a/examples/http_proxy.rs
+++ b/examples/http_proxy.rs
@@ -31,8 +31,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
tokio::task::spawn(async move {
if let Err(err) = http1::Builder::new()
- .http1_pre... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -1197,7 +1197,7 @@ test! {
client:
options: {
- http1_title_case_headers: true,
+ title_case_headers: true,
},
request: {
method: GET,
diff --git a/tests/cli... | Remove version-specific prefixes from builder methods
With the split of the builders into per-version kinds (see #2842 and #2851), I feel there's a new question around whether we should remove the prefixes from the method names. They used to exist because the builders were combined over multiple HTTP versions, so the o... | Leaving for comments for a few days.
👍 Would it make sense to rename the builders `Http1Builder`, etc?
So, `http1::Http1Builder`? Seems contrary [RFC 356](http://rust-lang.github.io/rfcs/0356-no-module-prefixes.html). Users who want it can rename it on import: `use hyper::client::conn::http1::Builder as Http1Builder`.... | 2022-12-24T18:42:06Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,039 | hyperium__hyper-3039 | [
"3038"
] | 9ad4055fbfc899391f54ecbfc63de385cae711ef | diff --git a/src/server/tcp.rs b/src/server/tcp.rs
--- a/src/server/tcp.rs
+++ b/src/server/tcp.rs
@@ -43,24 +43,62 @@ impl TcpKeepaliveConfig {
}
}
- #[cfg(not(any(target_os = "openbsd", target_os = "redox", target_os = "solaris")))]
+ #[cfg(any(
+ target_os = "android",
+ target_os... | diff --git a/src/server/tcp.rs b/src/server/tcp.rs
--- a/src/server/tcp.rs
+++ b/src/server/tcp.rs
@@ -401,7 +439,17 @@ mod tests {
}
}
- #[cfg(not(any(target_os = "openbsd", target_os = "redox", target_os = "solaris")))]
+ #[cfg(any(
+ target_os = "android",
+ target_os = "dragonfly... | v0.14.21 broken build
**Version**
v0.14.21
**Platform**
MacOS and Linux
**Description**
Cannot build the newest hyper:
```
[2022-10-31T14:18:27.529Z] error[E0599]: no method named `with_interval` found for struct `TcpKeepalive` in the current scope
[2022-10-31T14:18:27.529Z] --> /root/.cargo/registry/sr... | I am also getting this error, had to downgrade it to v0.14.20 since my project would not build with v0.14.21
```
hyper = { version = "=0.14.20", features = ["full"] }
```
Looks like it needs a more complex blob of cfgs:
```rust
#[cfg(all(
feature = "all",
any(
target_os = "android",... | 2022-10-31T16:47:16Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 3,037 | hyperium__hyper-3037 | [
"3028"
] | 54eaf7fb1377dbb60c1b7a1f1e93388a58acd466 | diff --git a/benches/support/tokiort.rs b/benches/support/tokiort.rs
--- a/benches/support/tokiort.rs
+++ b/benches/support/tokiort.rs
@@ -8,6 +8,7 @@ use std::{
use futures_util::Future;
use hyper::rt::{Sleep, Timer};
+use pin_project_lite::pin_project;
#[derive(Clone)]
/// An Executor that uses the tokio runt... | diff --git a/benches/support/tokiort.rs b/benches/support/tokiort.rs
--- a/benches/support/tokiort.rs
+++ b/benches/support/tokiort.rs
@@ -59,15 +60,18 @@ where
// Use TokioSleep to get tokio::time::Sleep to implement Unpin.
// see https://docs.rs/tokio/latest/tokio/time/struct.Sleep.html
-pub(crate) struct TokioSl... | `Timer` methods should return `Pin<Box<dyn Sleep>>` and `Sleep` should drop the `Unpin` requirement
Otherwise, you need to double-box `!Unpin` timer futures like Tokio's.
| 2022-10-29T21:08:44Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 3,032 | hyperium__hyper-3032 | [
"2649"
] | 81e25fa868c86e4ea81d5a96fdca497a4b1ab3c1 | diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -90,7 +90,7 @@ impl<T, U> Sender<T, U> {
}
let (tx, rx) = oneshot::channel();
self.inner
- .send(Envelope(Some((val, Callback::Retry(tx)))))
+ .send(... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -2267,6 +2267,48 @@ mod conn {
done_tx.send(()).unwrap();
}
+ #[tokio::test]
+ async fn test_body_panics() {
+ let _ = pretty_env_logger::try_init();
+
+ let listener = TkTcpListener::bind(S... | Consider removing "dispatch dropped without returning error"
**Is your feature request related to a problem? Please describe.**
Hyper panics with "dispatch dropped without returning error" if the background dispatch task goes away, either because the runtime was dropped or some user-provided code such as a HttpBody im... | Yea, we can do better. We probably can't completely remove the panic, since the `Canceled` error is part of the oneshot contract. But we can improve two the existing cases that _can_ happen, to try to eliminate it so that panic never _can_ happen.
- The runtime is dropped, killing the dispatch task.
- The dispatch ... | 2022-10-28T19:07:59Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,022 | hyperium__hyper-3022 | [
"2971"
] | 0888623d3764e887706d4e38f82f0fb57c50bd1a | diff --git a/examples/echo.rs b/examples/echo.rs
--- a/examples/echo.rs
+++ b/examples/echo.rs
@@ -4,15 +4,16 @@ use std::net::SocketAddr;
use bytes::Bytes;
use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
-use hyper::body::Body as _;
use hyper::server::conn::http1;
use hyper::service::service_fn... | diff --git a/examples/web_api.rs b/examples/web_api.rs
--- a/examples/web_api.rs
+++ b/examples/web_api.rs
@@ -77,7 +77,7 @@ async fn api_get_response() -> Result<Response<BoxBody>> {
Ok(res)
}
-async fn response_examples(req: Request<Recv>) -> Result<Response<BoxBody>> {
+async fn response_examples(req: Reques... | Determine name for `Recv` body type
We temporarily renamed the old `hyper::Body` struct to `hyper::body::Recv` in #2966. That was to unblock #2839, since we wanted to use the name for the trait instead. But, the name should be properly considered.
The purpose of this type is: an implementation of `Body` to represent... | Pinging because you may have opinions about the name: @hawkw @LucioFranco @davidpdrsn.
Node.js uses IncomingMessage. Making the connection to Body clearer though would be good. Perhaps IncomingBody?
Assuming that the user would never construct these themselves then I like `IncomingBody`.
ReqBody?
It's the body of a Req... | 2022-10-25T19:20:26Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 3,020 | hyperium__hyper-3020 | [
"3010"
] | 91e83b7e486da956439df4439b32ad9e9977cbb2 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,8 +27,8 @@ futures-core = { version = "0.3", default-features = false }
futures-channel = "0.3"
futures-util = { version = "0.3", default-features = false }
http = "0.2"
-http-body = { git = "https://github.com/hyperium/http-body", rev = "... | diff --git a/benches/body.rs b/benches/body.rs
--- a/benches/body.rs
+++ b/benches/body.rs
@@ -6,7 +6,8 @@ extern crate test;
use bytes::Buf;
use futures_util::stream;
use futures_util::StreamExt;
-use http_body_util::StreamBody;
+use http_body::Frame;
+use http_body_util::{BodyExt, StreamBody};
macro_rules! benc... | Update to use new http-body trait
With #2840 completed, we need to update hyper to use the new trait.
| 2022-10-24T18:15:45Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 3,013 | hyperium__hyper-3013 | [
"3012"
] | fc4d3356cb7f2fffff5af9c474fa34c5adc5d6f1 | diff --git a/benches/pipeline.rs b/benches/pipeline.rs
--- a/benches/pipeline.rs
+++ b/benches/pipeline.rs
@@ -14,7 +14,7 @@ use http_body_util::Full;
use tokio::net::TcpListener;
use tokio::sync::oneshot;
-use hyper::server::conn::Http;
+use hyper::server::conn::http1;
use hyper::service::service_fn;
use hyper::... | diff --git a/benches/pipeline.rs b/benches/pipeline.rs
--- a/benches/pipeline.rs
+++ b/benches/pipeline.rs
@@ -41,7 +41,7 @@ fn hello_world_16(b: &mut test::Bencher) {
loop {
let (stream, _addr) = listener.accept().await.expect("accept");
- Http::new()
+ ... | Remove the combined-version server Connection type
With #2851 complete, we now have separate types for HTTP/1 and HTTP/2 server connections. We'll remove the combo `server::conn::{Http, Connection}` stuff for 1.0. A combined/auto type can live in `hyper-util`.
| 2022-10-14T20:45:05Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 2,987 | hyperium__hyper-2987 | [
"2960"
] | 9cc5e62f706b39c988167c6d04b8cf4389ab1603 | diff --git a/examples/client.rs b/examples/client.rs
--- a/examples/client.rs
+++ b/examples/client.rs
@@ -41,7 +41,7 @@ async fn fetch_url(url: hyper::Uri) -> Result<()> {
let addr = format!("{}:{}", host, port);
let stream = TcpStream::connect(addr).await?;
- let (mut sender, conn) = hyper::client::con... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -232,19 +232,17 @@ macro_rules! test {
// Wrapper around hyper::client::conn::Builder with set_host field to mimic
// hyper::client::Builder.
struct Builder {
- inner: hype... | Remove the client::conn combined-version types
The public client API for 1.0 will be the version-specific types at `client::conn::{http1, http2}`. The combined version may exist in `hyper-util`, but at least it should be removed from hyper proper. Doing so isn't particularly complex, but it will mean fixing up all the ... | `ffi::client` is also effected.
How would you like me to handle that?
Ohhh, I had forgotten about that. I guess a pared-down enum could be used in `ffi::client`. I can do that if it seems hairy, let me know. | 2022-09-20T00:06:01Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 2,975 | hyperium__hyper-2975 | [
"2857"
] | fee7d361c28c7eb42ef6bbfae0db14028d24bfee | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,6 +54,7 @@ serde_json = "1.0"
tokio = { version = "1", features = [
"fs",
"macros",
+ "net",
"io-std",
"io-util",
"rt",
diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -79,7 +80,6 @@ full... | diff --git a/src/client/mod.rs b/src/client/mod.rs
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -7,7 +7,7 @@
//! For a small example program simply fetching a URL, take a look at the
//! [full client example](https://github.com/hyperium/hyper/blob/master/examples/client.rs).
-#[cfg(all(test, feature = "runtim... | Remove the `runtime` cargo feature
With the removal of the [`tcp` feature](#2856) and the addition of the [`Timer`](https://github.com/hyperium/hyper/issues/2846) trait, we no longer have need of the `runtime` feature.
| This is blocked on the timer related issues (like #2848) being done first.
With a `Timer` added, we can now delete all `cfg(feature = "runtime")` stuff from hyper. | 2022-09-03T12:38:20Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 2,974 | hyperium__hyper-2974 | [
"2848"
] | 2988baa309f726a588d818e6708f8bd38f9d9ce9 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -96,7 +96,6 @@ server = []
runtime = [
"tokio/net",
"tokio/rt",
- "tokio/time",
]
# C-API support (currently unstable (no semver))
diff --git /dev/null b/benches/support/mod.rs
new file mode 100644
--- /dev/null
+++ b/benches/su... | diff --git /dev/null b/benches/support/tokiort.rs
new file mode 100644
--- /dev/null
+++ b/benches/support/tokiort.rs
@@ -0,0 +1,66 @@
+#![allow(dead_code)]
+//! Various runtimes for hyper
+use std::{
+ pin::Pin,
+ task::{Context, Poll},
+ time::{Duration, Instant},
+};
+
+use futures_util::Future;
+use hyper:... | Use a generic Timer to implement the timeouts and intervals
After adding a [generic `T: Timer`](https://github.com/hyperium/hyper/issues/2847), update the uses of `tokio::time` to use the generic timer instead.
- [ ] HTTP/2 keep-alive interval
- [ ] HTTP/2 keep-alive timeout
- [ ] HTTP/1 read headers timeout
| I'll look to take on the timer series of issues (#2847, #2846, #2848, #2857). | 2022-08-31T22:49:43Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 2,970 | hyperium__hyper-2970 | [
"2962"
] | 7a41da5f601f59632d8c1514a75af720ed43413e | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -61,7 +61,7 @@ enum Kind {
/// [`Body::channel()`]: struct.Body.html#method.channel
/// [`Sender::abort()`]: struct.Sender.html#method.abort
#[must_use = "Sender does nothing unless sent on"]
-pub struct Sender {
+pub(c... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -1325,6 +1325,7 @@ test! {
}
mod conn {
+ use std::error::Error;
use std::io::{self, Read, Write};
use std::net::{SocketAddr, TcpListener};
use std::pin::Pin;
diff --git a/tests/client.rs b/tests/client.r... | Make `body::Sender` type and `Body::channel()` constructor private.
This is an "easy" task, in that the changes aren't *complicated*:
- Change the `hyper::body::Sender` type to `pub(crate)`.
- Change the `Body::channel()` method to `pub(crate)`.
- Replace any usage in the examples, tests, or docs with an appropria... | I'll get started on this. | 2022-08-29T17:44:54Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 2,969 | hyperium__hyper-2969 | [
"2839"
] | d963e6a9504575116f63df2485d8480fdb9b6f0b | diff --git a/examples/client.rs b/examples/client.rs
--- a/examples/client.rs
+++ b/examples/client.rs
@@ -4,7 +4,7 @@ use std::env;
use bytes::Bytes;
use http_body_util::Empty;
-use hyper::{body::HttpBody as _, Request};
+use hyper::{body::Body as _, Request};
use tokio::io::{self, AsyncWriteExt as _};
use tokio... | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -386,7 +386,7 @@ mod tests {
use std::mem;
use std::task::Poll;
- use super::{DecodedLength, HttpBody, Recv, Sender, SizeHint};
+ use super::{Body, DecodedLength, Recv, Sender, SizeHint};
#[test]
... | Rename the HttpBody export to Body
When the concrete `Body` struct is removed, we can export the `http_body::Body` trait as just `Body`.
| What would be the advantage in case of import both trait and struct?
The struct will be removed, as detailed in #2345.
I am just starting up with Hyper so would like to work on this task (if that's ok). By renaming and exporting the `http_body::Body` trait as just `Body`, I assume you are talking about updating the fol... | 2022-08-28T14:30:00Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 2,958 | hyperium__hyper-2958 | [
"2922"
] | 952756b916eff4fc9482f7d38c6fb606614c2c12 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -181,11 +181,6 @@ name = "state"
path = "examples/state.rs"
required-features = ["full"]
-[[example]]
-name = "tower_server"
-path = "examples/tower_server.rs"
-required-features = ["full"]
-
[[example]]
name = "upgrades"
path = "examples/... | diff --git a/benches/pipeline.rs b/benches/pipeline.rs
--- a/benches/pipeline.rs
+++ b/benches/pipeline.rs
@@ -3,17 +3,20 @@
extern crate test;
+use std::convert::Infallible;
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::sync::mpsc;
use std::time::Duration;
+use bytes::Bytes;
+u... | Remove Body's `Once` variant
| It was noted that the FFI body type makes use of `Body::empty()`. I think there's 2 ways we can fix that:
1. Add a `pub(crate) fn ffi() -> Body` that just starts the type like this: https://github.com/hyperium/hyper/blob/509672aada0af68a91d963e69828c6e31c44cb7b/src/body/body.rs#L240
2. Or, keep an `Empty` variant. ... | 2022-08-24T00:25:01Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f |
hyperium/hyper | 2,949 | hyperium__hyper-2949 | [
"2948"
] | bb3af17ce1a3841e9170adabcce595c7c8743ea7 | diff --git a/src/client/connect/http.rs /dev/null
--- a/src/client/connect/http.rs
+++ /dev/null
@@ -1,252 +0,0 @@
-use std::error::Error as StdError;
-use std::fmt;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
-use std::sync::Arc;
-use std::time::Duration;
-
-//#[cfg(feature = "runtime")] use super::dns::T... | diff --git a/src/client/connect/dns.rs /dev/null
--- a/src/client/connect/dns.rs
+++ /dev/null
@@ -1,239 +0,0 @@
-//! DNS Resolution used by the `HttpConnector`.
-//!
-//! This module contains:
-//!
-//! - A [`GaiResolver`](GaiResolver) that is the default resolver for the
-//! `HttpConnector`.
-//! - The `Name` type... | Remove client connect module
| 2022-08-17T00:51:26Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 2,941 | hyperium__hyper-2941 | [
"2841"
] | 889fa2d87252108eb7668b8bf034ffcc30985117 | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -10,8 +10,6 @@ use http_body::{Body as HttpBody, SizeHint};
use super::DecodedLength;
use crate::common::Future;
-#[cfg(all(feature = "client", any(feature = "http1", feature = "http2")))]
-use crate::common::Never;
u... | diff --git a/src/client/client.rs /dev/null
--- a/src/client/client.rs
+++ /dev/null
@@ -1,1356 +0,0 @@
-use std::error::Error as StdError;
-use std::fmt;
-use std::mem;
-use std::time::Duration;
-
-use futures_channel::oneshot;
-use futures_util::future::{self, Either, FutureExt as _, TryFutureExt as _};
-use http::he... | Remove high-level pooling Client
The `hyper::Client` and support modules `hyper::client::connect` should be removed from hyper, and parts should reappear in hyper-util.
- [x] #2860
- [x] #2859
| 2022-08-13T00:19:51Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 2,932 | hyperium__hyper-2932 | [
"2849"
] | 491b076bca945ad9b62d49d0c14a4b989cb0106c | diff --git a/src/common/exec.rs b/src/common/exec.rs
--- a/src/common/exec.rs
+++ b/src/common/exec.rs
@@ -3,28 +3,17 @@ use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;
-#[cfg(all(feature = "server", any(feature = "http1", feature = "http2")))]
-use crate::body::Body;
#[cfg(feature = "server")]
us... | diff --git a/src/common/drain.rs /dev/null
--- a/src/common/drain.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-use std::mem;
-
-use pin_project_lite::pin_project;
-use tokio::sync::watch;
-
-use super::{task, Future, Pin, Poll};
-
-pub(crate) fn channel() -> (Signal, Watch) {
- let (tx, rx) = watch::channel(());
- (Signal... | Remove hyper::Server
Remove the `hyper::Server` and `Builder` types, and `Accept` trait from hyper. It's possible we can move something similar to hyper-util, but [the `Accept` trait needs some reworking](https://github.com/hyperium/hyper/blob/master/docs/ROADMAP.md#higher-level-client-and-server-problems).
| 2022-07-29T23:41:48Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 2,929 | hyperium__hyper-2929 | [
"2856"
] | d4b5bd4ee6af0ae8924cf05ab799cc3e19a3c62d | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -94,12 +94,6 @@ server = []
# Tokio support
runtime = [
- "tcp",
- "tokio/rt",
- "tokio/time",
-]
-tcp = [
- "socket2",
"tokio/net",
"tokio/rt",
"tokio/time",
diff --git a/examples/client.rs b/examples/client.rs
---... | diff --git a/benches/connect.rs b/benches/connect.rs
--- a/benches/connect.rs
+++ b/benches/connect.rs
@@ -3,35 +3,38 @@
extern crate test;
-use http::Uri;
-use hyper::client::connect::HttpConnector;
-use hyper::service::Service;
-use std::net::SocketAddr;
-use tokio::net::TcpListener;
+// TODO: Reimplement http_c... | Remove the `tcp` cargo feature
Remove the `tcp` cargo feature, and related `tokio::net::TcpStream` integration (`TcpStream::connect` and `TcpListener`) (since we are already removing `client::connect` and `server::accept`).
| 2022-07-28T20:21:55Z | 1.0 | 6fd696e10974f10b2c6b9d16393bbbfa21c2333f | |
hyperium/hyper | 2,836 | hyperium__hyper-2836 | [
"2835"
] | faf24c6ad8eee1c3d5ccc9a4d4835717b8e2903f | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -10,6 +8,8 @@ use bytes::BytesMut;
use http::header::ValueIter;
use http::header::{self, Entry, HeaderName, HeaderValue};
use http::{HeaderMap, Method, StatusCode, Version};
+#[cfg(all(feature = "server"... | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -1,8 +1,6 @@
use std::fmt::{self, Write};
use std::mem::MaybeUninit;
-#[cfg(all(feature = "server", feature = "runtime"))]
-use tokio::time::Instant;
#[cfg(any(test, feature = "server", feature = "ffi"... | Server incorrectly adds content-length: 0 to Http1 Head responses
**Version**
0.14.18
**Platform**
```
Darwin C02DN4K3MD6R 21.4.0 Darwin Kernel Version 21.4.0: Fri Mar 18 00:45:05 PDT 2022; root:xnu-8020.101.4~15/RELEASE_X86_64 x86_64 i386 MacBookPro16,1 Darwin
```
**Description**
Hyper incorrectly sets `con... | 2022-05-18T13:35:31Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,790 | hyperium__hyper-2790 | [
"2649"
] | 287d712483aec6671427438d60ed2a72f856fd9f | diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -86,7 +86,7 @@ impl<T, U> Sender<T, U> {
}
let (tx, rx) = oneshot::channel();
self.inner
- .send(Envelope(Some((val, Callback::Retry(tx)))))
+ .send(... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -3114,6 +3114,44 @@ mod conn {
done_tx.send(()).unwrap();
}
+ #[tokio::test]
+ async fn test_body_panics() {
+ use hyper::body::HttpBody;
+
+ let _ = pretty_env_logger::try_init();
+
+ ... | Consider removing "dispatch dropped without returning error"
**Is your feature request related to a problem? Please describe.**
Hyper panics with "dispatch dropped without returning error" if the background dispatch task goes away, either because the runtime was dropped or some user-provided code such as a HttpBody im... | Yea, we can do better. We probably can't completely remove the panic, since the `Canceled` error is part of the oneshot contract. But we can improve two the existing cases that _can_ happen, to try to eliminate it so that panic never _can_ happen.
- The runtime is dropped, killing the dispatch task.
- The dispatch ... | 2022-03-21T14:23:11Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,715 | hyperium__hyper-2715 | [
"2712"
] | ce8242571fc4dd6db8ccaad76eadab80ac009d32 | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -204,9 +204,14 @@ impl Body {
#[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
pub(crate) fn h2(
recv: h2::RecvStream,
- content_length: DecodedLength,
+ mut cont... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -361,6 +361,26 @@ mod response_body_lengths {
assert_eq!(res.headers().get("content-length").unwrap(), "10");
assert_eq!(res.body().size_hint().exact(), Some(10));
}
+
+ #[tokio::test]
+ async fn h... | body size
If a request without a body does not carry content-length or chunk, the size_hint method of the body can obtain the correct value in the HTTP1 scenario but cannot obtain the correct value in the H2 scenario.
```
fn size_hint(&self) -> SizeHint {
match self.kind {
Kind::Once(Som... | Whether the body size can be corrected based on is_end_stream to determine whether the request is empty.
```
/// Returns true if the receive half has reached the end of stream.
///
/// A return value of `true` means that calls to `poll` and `poll_trailers`
/// will both return `None`.
pub fn... | 2021-12-06T18:44:07Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,706 | hyperium__hyper-2706 | [
"2701"
] | 1010614a0de032b43306ef9dc6da5a3e8ebf7a09 | diff --git a/src/error.rs b/src/error.rs
--- a/src/error.rs
+++ b/src/error.rs
@@ -71,6 +71,7 @@ pub(super) enum Parse {
#[cfg(feature = "http1")]
VersionH2,
Uri,
+ UriTooLong,
Header(Header),
TooLarge,
Status,
diff --git a/src/error.rs b/src/error.rs
--- a/src/error.rs
+++ b/src/error.... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1025,6 +1025,23 @@ fn http_10_request_receives_http_10_response() {
assert_eq!(s(&buf[..expected.len()]), expected);
}
+#[test]
+fn http_11_uri_too_long() {
+ let server = serve();
+
+ let long_path = "a".repeat... | When the URL contains more than 65534 characters, the error code returned by Hyper is not 414.
The length of the from_shared method of the third-party library http::Uri is verified， The maximum length is (u16::MAX - 1).
| Good catch! We could add a check for the length just before calling `Uri::from_shared`, and if too long, return a `Parse` error. An integration test in `tests/server.rs` would be good too. | 2021-11-23T03:58:28Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,677 | hyperium__hyper-2677 | [
"2676"
] | b5022f3854d1f9ed3e76233dd63f319efc3b8f47 | diff --git a/src/client/client.rs b/src/client/client.rs
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -1022,6 +1022,23 @@ impl Builder {
self
}
+ /// Set whether HTTP/1 connections should try to use vectored writes,
+ /// or always flatten into a single buffer.
+ ///
+ /// Note t... | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -71,7 +71,6 @@ where
self.io.set_flush_pipeline(enabled);
}
- #[cfg(test)]
pub(crate) fn set_write_strategy_queue(&mut self) {
self.io.set_write_strategy_queue();
}
dif... | Provide a way to force the queue write strategy, again
Once upon a time, there was [a way](https://github.com/hyperium/hyper/issues/2282) to force Hyper to use the queue write strategy.
This functionality was then [removed](https://github.com/hyperium/hyper/pull/2338) from Hyper 0.14.0.
Unfortunately, the heurist... | 2021-10-27T12:13:00Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,675 | hyperium__hyper-2675 | [
"2457",
"2661"
] | d0b1d9ed3a10013ab356bc7d9b283e179857a672 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -100,6 +100,7 @@ stream = []
runtime = [
"tcp",
"tokio/rt",
+ "tokio/time",
]
tcp = [
"socket2",
diff --git a/src/error.rs b/src/error.rs
--- a/src/error.rs
+++ b/src/error.rs
@@ -44,6 +44,9 @@ pub(super) enum Kind {
#[c... | diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
--- a/src/proto/h1/io.rs
+++ b/src/proto/h1/io.rs
@@ -693,6 +726,9 @@ mod tests {
cached_headers: &mut None,
req_method: &mut None,
h1_parser_config: Default::default(),
+ h1_header_read_timeout: None,... | Defends against slow HTTP attacks.
I think hyper needs to add capabilities such as client_header_timeout and client_body_timeout to defend against slow attacks.
The Nginx defense method is as follows:
https://www.nginx.com/blog/mitigating-ddos-attacks-with-nginx-and-nginx-plus/#client_header_timeout
feat(h1): add h... | 2021-10-26T09:05:32Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,646 | hyperium__hyper-2646 | [
"2643"
] | e3ab409808a6aa06ebacaaa936cb926785913d24 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -461,7 +466,7 @@ where
}
}
match self.state.writing {
- Writing::Init => true,
+ Writing::Init => self.io.can_headers_buf(),
_ => false,
... | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -71,6 +71,11 @@ where
self.io.set_flush_pipeline(enabled);
}
+ #[cfg(test)]
+ pub(crate) fn set_write_strategy_queue(&mut self) {
+ self.io.set_write_strategy_queue();
+ }
+
... | Panic via reqwest when sending large body in debug mode
**Version**
hyper-0.14.12
reqwest-0.11.4 (blocking)
**Platform**
Manjaro Linux x86_64
**Description**
When sending large requests **repeatedly too fast**, a panic happens in debug mode.
I tried this code in debug mode:
```
fn main() {
let client ... | Thanks for the report, yep, definitely a bug! I'll take a look-see.
Huh, so I set up an example just as you did, but with hyper as the server, and instead of a panic, I see an IO error since the hyper server closed the connection after writing the 200 OK. I'm guessing actix does something a little different, and that's... | 2021-09-14T23:23:02Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,576 | hyperium__hyper-2576 | [
"2575"
] | 08b2138e4036c5ae3e4c6f5c85763d45fb869922 | diff --git a/capi/include/hyper.h b/capi/include/hyper.h
--- a/capi/include/hyper.h
+++ b/capi/include/hyper.h
@@ -371,6 +371,17 @@ void hyper_clientconn_options_exec(struct hyper_clientconn_options *opts,
*/
enum hyper_code hyper_clientconn_options_http2(struct hyper_clientconn_options *opts, int enabled);
+/*
+ ... | diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
--- a/src/proto/h1/io.rs
+++ b/src/proto/h1/io.rs
@@ -675,6 +677,8 @@ mod tests {
h1_parser_config: Default::default(),
preserve_header_case: false,
h09_responses: false,
+ #[cfg(feature = "ffi")]
+ ... | C API: Provide a way to get the raw response header bytes
What if... the C API provided an option to ask for the original header data, as a single unaltered buffer? It'd be cheap in hyper, just a ref count bump on that buffer, and in curl you wouldn't need to re-stitch together the headers into lines, or have a discrep... | 2021-06-11T21:13:44Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,545 | hyperium__hyper-2545 | [
"2532"
] | 684f2fa76d44fa2b1b063ad0443a1b0d16dfad0e | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -115,17 +111,23 @@ impl Http1Transaction for Server {
// but we *never* read any of it until after httparse has assigned
// values into it. By not zeroing out the stack memory, this saves
... | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -1,9 +1,5 @@
-// `mem::uninitialized` replaced with `mem::MaybeUninit`,
-// can't upgrade yet
-#![allow(deprecated)]
-
use std::fmt::{self, Write};
-use std::mem;
+use std::mem::{self, MaybeUninit};
#[c... | Replace usage of `mem::uninitialized` with `MaybeUninit`
When the following comment was added in #1845, hyper's minimum supported rust version was `1.27.0`
https://github.com/hyperium/hyper/blob/4e9a006498c7bdb5bb2ccb76a4c877f6da7e23b2/src/proto/h1/role.rs#L1-L3
which I assume is why [`std::mem::MaybeUninit`](htt... | Good call!
Refactored the code. | 2021-05-11T12:01:41Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,523 | hyperium__hyper-2523 | [
"2508"
] | be9677a1e782d33c4402772e0fc4ef0a4c49d507 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,7 +31,7 @@ http = "0.2"
http-body = "0.4"
httpdate = "1.0"
httparse = "1.4"
-h2 = { version = "0.3", optional = true }
+h2 = { version = "0.3.3", optional = true }
itoa = "0.4.1"
tracing = { version = "0.1", default-features = false, fea... | diff --git a/src/body/length.rs b/src/body/length.rs
--- a/src/body/length.rs
+++ b/src/body/length.rs
@@ -3,6 +3,17 @@ use std::fmt;
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) struct DecodedLength(u64);
+#[cfg(any(feature = "http1", feature = "http2"))]
+impl From<Option<u64>> for DecodedLength {
+ fn fro... | Support CONNECT over h2
There is [a h2 issue](https://github.com/hyperium/h2/issues/234) but even if support for CONNECT was perfect in h2, there are still details to sort out on hyper itself too. I'm filing this issue because I started working on that today and will probably need some help.
| AFAICT for the client part we mostly want to patch this match arm:
https://github.com/hyperium/hyper/blob/117cc492a62c4051c75e7eec0f624b30db8a20e5/src/proto/h2/client.rs#L217-L290
Specifically, ultimately we want to patch this snippet so that it inserts an `OnUpgrade` extension in the returned response, with its ... | 2021-04-28T09:22:09Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,488 | hyperium__hyper-2488 | [
"2483"
] | c7ab1aace102688ca3ad1bba6b5a7c5fd93b21b6 | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -147,10 +146,6 @@ jobs:
command: build
args: --features client,http1,http2,ffi
- # TODO: re-enable check once figuring out how to get it working in CI
- # -... | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -17,6 +17,7 @@ jobs:
- test
- features
- ffi
+ - ffi-header
- doc
steps:
- run: exit 0
diff --git a/.github/workflows/CI.yml b/.github/workflows/... | Errors running gen_header.sh
I'm trying to fix some of the errors you get when you run the curl test suite with the Hyper backend. I tried to pick an easy one to start - Curl expects you to return CURLE_UNSUPPORTED_PROTOCOL when a server returns HTTP/1.2, but Hyper/c-hyper.c currently doesn't.
So I wanted to add an... | I was able to get past that issue by adding the following patch to capi/gen_header.sh
```patch
diff --git a/capi/gen_header.sh b/capi/gen_header.sh
index 4cd1a26c..27f2c4cf 100755
--- a/capi/gen_header.sh
+++ b/capi/gen_header.sh
@@ -1,5 +1,7 @@
#!/usr/bin/env bash
+set -ex
+
CAPI_DIR="$( cd "$( dirnam... | 2021-04-01T17:30:18Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,486 | hyperium__hyper-2486 | [
"2482"
] | 98e7e0bd15642cf9e4bf07b3b03d8b4e538623ba | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -66,6 +66,8 @@ jobs:
- rust: nightly
features: "--features full,nightly"
benches: true
+ - rust: 1.46
+ features: "--features full"
... | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -51,7 +51,7 @@ jobs:
- stable
- beta
- nightly
- - 1.45.2
+ - 1.46
os:
- ubuntu-latest
| The update to socket2 v0.4 raised the MSRV to 1.46
CI didn't catch it because MSRV is tested only with default features.
```
$ cargo +1.45.2 c --features tcp
Checking socket2 v0.4.0
Checking tokio v1.4.0
error[E0658]: `match` is not allowed in a `const fn`
--> /.cargo/registry/src/github.com-1ecc6299db... | Oh shucks. Probably need to revert that commit for now, unless socket2 can reduce it's dependent features, but I doubt it.
cc @Thomasdezeeuw
I'm afraid socket2's MSRV can't easily be lowered. Rust 1.46 was released August 27th, if that isn't old enough then I guess it needs to be reverted.
You could just pin socket2 ... | 2021-03-31T11:49:43Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,480 | hyperium__hyper-2480 | [
"2313"
] | 117cc492a62c4051c75e7eec0f624b30db8a20e5 | diff --git a/src/client/client.rs b/src/client/client.rs
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -997,6 +997,17 @@ impl Builder {
self
}
+ /// Set whether HTTP/1 connections will write header names as provided
+ /// at the socket level.
+ ///
+ /// Note that this setting doe... | diff --git /dev/null b/src/ext.rs
new file mode 100644
--- /dev/null
+++ b/src/ext.rs
@@ -0,0 +1,64 @@
+//! HTTP extensions
+
+use bytes::Bytes;
+#[cfg(feature = "http1")]
+use http::header::{HeaderName, IntoHeaderName, ValueIter};
+use http::HeaderMap;
+
+/// A map from header names to their original casing as receive... | Option to preserve header's title case
I am building a HTTP proxy with hyper, and I realize that headers are all converted to lower case for HTTP/1.x.
There was an issue about adding `http1_title_case_headers` for clients: https://github.com/hyperium/hyper/issues/1492 , but we don't have a way to preserve the **resp... | As always, I've suggest filing a bug with the thing that expects a certain casing, since in HTTP/1 header casing is defined as case-insensitive, and in HTTP2 and 3, it's forced to lowercase. So the Switch is definitely wrong here.
That said, I realize it's not always controllable, and so I'm exploring providing supp... | 2021-03-26T11:26:07Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,473 | hyperium__hyper-2473 | [
"2468"
] | 41f99578a53845e5e0bb999c101bef8307e1ce5f | diff --git a/src/client/client.rs b/src/client/client.rs
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -972,6 +972,14 @@ impl Builder {
self
}
+ /// Set whether HTTP/0.9 responses should be tolerated.
+ ///
+ /// Default is false.
+ pub fn http09_responses(&mut self, val: bool) ->... | diff --git a/src/lib.rs b/src/lib.rs
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,3 @@
-#![doc(html_root_url = "https://docs.rs/hyper/0.14.4")]
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
#![cfg_attr(test, deny(rust_2018_idioms))]
diff --git a/src/proto/h1/io.rs b/src/proto/h1/io.rs
--- a/src/prot... | Support HTTP/0.9 responses in the client
There are servers out there that sometimes reply with HTTP/0.9 responses, even modern-ish stack (we saw such responses from MSFT servers for example).
I'm filing this here and not on the httparse repo because this is a substantial change worth discussing in the open, and beca... | 👀 This is the first time I've seen HTTP/0.9 support asked for. I would have assumed that since HTTP/1.0 came out (double checks) over 25 years ago, people would have moved on. Oh well.
If a client sends a request to a server that happens to not speak HTTP at all, what's the proposed way to notice that versus just a... | 2021-03-19T13:57:22Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,471 | hyperium__hyper-2471 | [
"2470"
] | eb0e7186963bbe4fa1ad4478ac493f75ddc92ae5 | diff --git a/src/headers.rs b/src/headers.rs
--- a/src/headers.rs
+++ b/src/headers.rs
@@ -42,26 +42,26 @@ pub(super) fn content_length_parse_all_values(values: ValueIter<'_, HeaderValue>
// be alright if they all contain the same value, and all parse
// correctly. If not, then it's an error.
- let folde... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -1043,6 +1043,30 @@ test! {
error: |err| err.to_string() == "request has unsupported HTTP version",
}
+test! {
+ name: client_handles_contentlength_values_on_same_line,
+
+ server:
+ expected: "GET /fo... | Support multiple Content-Length values
Hi,
I try to work on some [failing tests](https://github.com/servo/servo/blob/master/tests/wpt/web-platform-tests/fetch/content-length/resources/content-lengths.json) of servo. To summarize the issue : the `fetch` specification has been recently updated to handle multiple value... | I coulda sworn hyper supported this, and so dug a little. hyper _does_ correctly support if the multiple values are on multiple lines, but not if comma-separated. So, this works:
```
HTTP/1.1 200 OK
content-length: 3
content-length: 3
hey
```
But not `content-length: 3,3`. Seems like something to fix, and ... | 2021-03-17T21:17:40Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,422 | hyperium__hyper-2422 | [
"2421"
] | 48d4594930da4e227039cfa254411b85c98b63c5 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ httparse = "1.0"
h2 = { version = "0.3", optional = true }
itoa = "0.4.1"
tracing = { version = "0.1", default-features = false, features = ["std"] }
-pin-project-lite = "0.2.4"
+pin-project = "1.0"
tower-service = "0.3"
tokio... | diff --git a/src/client/pool.rs b/src/client/pool.rs
--- a/src/client/pool.rs
+++ b/src/client/pool.rs
@@ -777,7 +776,7 @@ mod tests {
use std::time::Duration;
use super::{Connecting, Key, Pool, Poolable, Reservation, WeakOpt};
- use crate::common::{exec::Exec, task, Future, Pin};
+ use crate::common:... | Build failure with v0.14.3
Hi,
I get some build errors in CI with the newly released hyper v0.14.3:
In https://github.com/spruceid/didkit/runs/1842461977#step:6:437
```
error[E0433]: failed to resolve: could not find `h2` in `proto`
--> /home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/hyper-0.1... | This is interesting. Did it work fine for v0.14.2? What features do you have enabled?
@seanmonstar
Yes, it completed with v0.14.2, in this run: https://github.com/spruceid/didkit/runs/1842355682#step:6:434
Features are: `["server", "client", "http1", "stream"]`
Edit: I can reproduce the errors locally using thes... | 2021-02-05T23:41:20Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,410 | hyperium__hyper-2410 | [
"2409"
] | 1928682b33f98244435ba6d574677546205a15ec | diff --git a/src/headers.rs b/src/headers.rs
--- a/src/headers.rs
+++ b/src/headers.rs
@@ -117,9 +117,9 @@ pub(super) fn add_chunked(mut entry: http::header::OccupiedEntry<'_, HeaderValue
// + 2 for ", "
let new_cap = line.as_bytes().len() + CHUNKED.len() + 2;
let mut buf = BytesMut::with_cap... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -401,6 +401,36 @@ test! {
body: None,
}
+test! {
+ name: client_transfer_encoding_repair,
+
+ server:
+ expected: "\
+ GET / HTTP/1.1\r\n\
+ transfer-encoding: foo, chunked\r\... | "Transfer-Encoding" correction code causes a panic
Repro code:
```rust
use hyper::server::Server;
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Client, Request, Response};
use std::convert::Infallible;
#[tokio::main]
async fn main() {
let make_service = make_service_fn(|_conn| asyn... | 2021-01-26T18:04:04Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,400 | hyperium__hyper-2400 | [
"2390"
] | a15f3f7f0f536c74d51636bbc00f6b5ec110472b | diff --git a/src/client/conn.rs b/src/client/conn.rs
--- a/src/client/conn.rs
+++ b/src/client/conn.rs
@@ -272,7 +272,7 @@ where
ResponseFuture { inner }
}
- pub(crate) fn send_request_retryable(
+ pub(super) fn send_request_retryable(
&mut self,
req: Request<B>,
) -> impl F... | diff --git a/src/lib.rs b/src/lib.rs
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,6 +2,7 @@
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
#![cfg_attr(test, deny(rust_2018_idioms))]
+#![cfg_attr(all(test, feature = "full"), deny(unreachable_pub))]
#![cfg_attr(test, deny(warnings))]
#![cfg_attr(all(test,... | Lint for unreachable_pub
This is a good clean up to help detect any types or methods that seem public but aren't really. By adjusting their privacy, we can reduce accidentally making things public in case we later on made some module the re-exports them public.
To do this, start by adding `#![deny(unreachable_pub)]`... | 2021-01-13T11:12:22Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,393 | hyperium__hyper-2393 | [
"2388"
] | 2c8121f1735aa8efeb0d5e4ef595363c373ba470 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ httparse = "1.0"
h2 = { version = "0.3", optional = true }
itoa = "0.4.1"
tracing = { version = "0.1", default-features = false, features = ["std"] }
-pin-project = "1.0"
+pin-project-lite = "0.2.4"
tower-service = "0.3"
tokio... | diff --git a/src/client/mod.rs b/src/client/mod.rs
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -52,8 +52,7 @@
pub use self::connect::HttpConnector;
pub mod connect;
-#[cfg(test)]
-#[cfg(feature = "runtime")]
+#[cfg(all(test, feature = "runtime"))]
mod tests;
cfg_feature! {
diff --git a/src/client/pool.rs... | Switch from pin-project to pin-project-lite
futures-rs [just switched](https://github.com/rust-lang/futures-rs/pull/2273) and tokio has been using the `-lite` one since 0.2.0. I haven't used either so I don't actually know how hard switching is, but it seems like a good idea since it greatly improves compile times for ... | Considered, and agreed! It should be done!
This may require https://github.com/taiki-e/pin-project-lite/pull/43.
UPDATE: merged and released in pin-project-lite 0.2.4.
I'll take a stab at implementing this.
Depends on https://github.com/taiki-e/pin-project-lite/pull/25 because of https://github.com/hyperium/hype... | 2021-01-11T23:13:37Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,387 | hyperium__hyper-2387 | [
"2260"
] | 257d6a99193c9404ce055727833e1490c23a7197 | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -5,8 +5,6 @@ use std::fmt;
use bytes::Bytes;
use futures_channel::mpsc;
-#[cfg(any(feature = "http1", feature = "http2"))]
-#[cfg(feature = "client")]
use futures_channel::oneshot;
use futures_core::Stream; // for mp... | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -628,7 +651,7 @@ mod tests {
assert_eq!(
mem::size_of::<Sender>(),
- mem::size_of::<usize>() * 4,
+ mem::size_of::<usize>() * 5,
"Sender"
);
| Add sending trailers on Body channel
The `Body::channel()` variant is a common simple way to send data as a `Body`. It would be useful to also be able to send trailers on it.
### Implementation
The code to change is on the `hyper::body::Sender`, and the relevant `Kind` variant. I could imagine two possible ways t... | 2021-01-06T15:58:46Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,377 | hyperium__hyper-2377 | [
"2376"
] | 3d6bdbe85006e623eae83d7c3ce9a45680d6c2c8 | diff --git a/src/client/connect/http.rs b/src/client/connect/http.rs
--- a/src/client/connect/http.rs
+++ b/src/client/connect/http.rs
@@ -27,6 +27,7 @@ use super::{Connected, Connection};
///
/// Sets the [`HttpInfo`](HttpInfo) value on responses, which includes
/// transport information such as the remote socket a... | diff --git /dev/null b/src/client/client.rs
new file mode 100644
--- /dev/null
+++ b/src/client/client.rs
@@ -0,0 +1,1233 @@
+use std::error::Error as StdError;
+use std::fmt;
+use std::mem;
+use std::time::Duration;
+
+use futures_channel::oneshot;
+use futures_util::future::{self, Either, FutureExt as _, TryFutureExt... | Connector implementation crates have to pick http1/http2
The low-level connection APIs like `Connected`/`Connection`/`HttpConnector` all require one of `http1` or `http2` to be set. This means that external crates like `hyper-openssl` have to pick one of those features to enable, which is kind of out of scope for what ... | 2020-12-24T23:14:58Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,372 | hyperium__hyper-2372 | [
"2373"
] | c784a10174deb461b2eaa59ed9fabae5c315eb68 | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -132,4 +132,4 @@ jobs:
uses: actions-rs/cargo@v1
with:
command: rustdoc
- args: --features full -- -D broken-intra-doc-links
+ args: --features... | diff --git a/src/lib.rs b/src/lib.rs
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,7 @@
#![cfg_attr(test, deny(rust_2018_idioms))]
#![cfg_attr(test, deny(warnings))]
#![cfg_attr(all(test, feature = "nightly"), feature(test))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
//! # hyper
//!
| 0.14 docs failed to build
https://docs.rs/crate/hyper/0.14.0
| 2020-12-23T19:35:19Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,371 | hyperium__hyper-2371 | [
"2352"
] | fad42acc79b54ce38adf99c58c894f29fa2665ad | diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,75 @@
+## v0.14.0 (2020-12-23)
+
+
+#### Bug Fixes
+
+* **client:** log socket option errors instead of returning error (#2361) ([dad5c879](https://github.com/hyperium/hyper/commit/dad5c8792fec7b586b41b5237bc161d8f0c09f72), closes... | diff --git a/src/lib.rs b/src/lib.rs
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,4 @@
-#![doc(html_root_url = "https://docs.rs/hyper/0.13.9")]
+#![doc(html_root_url = "https://docs.rs/hyper/0.14.0")]
#![deny(missing_docs)]
#![deny(missing_debug_implementations)]
#![cfg_attr(test, deny(rust_2018_idioms))]
| v0.14 Release Checklist
The [v0.14 milestone](https://github.com/hyperium/hyper/milestone/6) is complete, meaning all major features are merged. This is a checklist of some administrata to have a smooth release!
- [x] Release Tokio 1.0, and then upgrade hyper (https://github.com/hyperium/hyper/issues/2370)
- [x] Re... | Here's an update on the exact release situation. This is based on the expectation that Tokio 1.0 will be released by EOY 2020. Considering that plan, I see 3 options:
1. Wait the 2 weeks for Tokio 1.0, and release hyper 0.14 at the same time (with Tokio 1.0 support).
2. Release hyper v0.14 right now, and then relea... | 2020-12-23T18:45:34Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,369 | hyperium__hyper-2369 | [
"2370"
] | dad5c8792fec7b586b41b5237bc161d8f0c09f72 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,20 +22,20 @@ include = [
]
[dependencies]
-bytes = "0.6"
+bytes = "1"
futures-core = { version = "0.3", default-features = false }
futures-channel = "0.3"
futures-util = { version = "0.3", default-features = false }
http = "0.2"
-http... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -62,8 +62,8 @@ tokio = { version = "0.3", features = [
"time",
"test-util",
] }
-tokio-test = "0.3"
-tokio-util = { version = "0.5", features = ["codec"] }
+tokio-test = "0.4"
+tokio-util = { version = "0.6", features = ["codec"] }
to... | Upgrade to Tokio 1.0
It's not released yet, but will be *very* soon.
Relevant PRs:
- [x] http-body: https://github.com/hyperium/http-body/pull/31
- [x] h2: https://github.com/hyperium/h2/pull/504
- [x] hyper: https://github.com/hyperium/hyper/pull/2369
| 2020-12-22T20:18:36Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,363 | hyperium__hyper-2363 | [
"2171"
] | 42560c7c40d8f934658624114fda4eb819cefda8 | diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
--- a/src/proto/h1/decode.rs
+++ b/src/proto/h1/decode.rs
@@ -55,6 +55,8 @@ enum ChunkedState {
Body,
BodyCr,
BodyLf,
+ Trailer,
+ TrailerLf,
EndCr,
EndLf,
End,
diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
-... | diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
--- a/src/proto/h1/decode.rs
+++ b/src/proto/h1/decode.rs
@@ -537,6 +561,15 @@ mod tests {
assert_eq!("1234567890abcdef", &result);
}
+ #[tokio::test]
+ async fn test_read_chunked_trailer_with_missing_lf() {
+ let mut mock_buf = &... | Decoding response from gRPC REST proxy results in "Invalid chunk end CR" error
I am integrating with a go application that uses the gRPC REST proxy to provide an HTTP API.
My HTTP client is `reqwest` which uses `hyper:0.13.3` at this stage.
The go application sends the following response:
```
HTTP/1.1 500 Inter... | That is actually valid chunked encoding, using chunked trailers. hyper just hasn't supported them, because practically _nothing_ has ever used them and they are annoying to deal with.
gRPC of HTTP/1.1 decided "oh hey, we can do trailers with this obscure detail of chunked encoding". Grumble.
Checking [RFC7230](https:/... | 2020-12-16T16:25:18Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,357 | hyperium__hyper-2357 | [
"2171"
] | 7d9a5806e146798d0cbe67672bbe3ad5ae680393 | diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
--- a/src/proto/h1/decode.rs
+++ b/src/proto/h1/decode.rs
@@ -55,6 +55,8 @@ enum ChunkedState {
Body,
BodyCr,
BodyLf,
+ Trailer,
+ TrailerLf,
EndCr,
EndLf,
End,
diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
-... | diff --git a/src/proto/h1/decode.rs b/src/proto/h1/decode.rs
--- a/src/proto/h1/decode.rs
+++ b/src/proto/h1/decode.rs
@@ -538,6 +562,15 @@ mod tests {
assert_eq!("1234567890abcdef", &result);
}
+ #[tokio::test]
+ async fn test_read_chunked_trailer_with_missing_lf() {
+ let mut mock_buf = &... | Decoding response from gRPC REST proxy results in "Invalid chunk end CR" error
I am integrating with a go application that uses the gRPC REST proxy to provide an HTTP API.
My HTTP client is `reqwest` which uses `hyper:0.13.3` at this stage.
The go application sends the following response:
```
HTTP/1.1 500 Inter... | That is actually valid chunked encoding, using chunked trailers. hyper just hasn't supported them, because practically _nothing_ has ever used them and they are annoying to deal with.
gRPC of HTTP/1.1 decided "oh hey, we can do trailers with this obscure detail of chunked encoding". Grumble.
Checking [RFC7230](https:/... | 2020-12-13T05:51:51Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,348 | hyperium__hyper-2348 | [
"2347"
] | a470446deb2cb2c0e3700f67d9f70097d0d7d75f | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -68,7 +68,7 @@ tower-util = "0.3"
url = "1.0"
[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dev-dependencies]
-pnet = "0.25.0"
+pnet_datalink = "0.27.2"
[features]
# Nothing by default
| diff --git a/src/client/connect/http.rs b/src/client/connect/http.rs
--- a/src/client/connect/http.rs
+++ b/src/client/connect/http.rs
@@ -723,7 +723,7 @@ mod tests {
let mut ip_v4 = None;
let mut ip_v6 = None;
- let ips = pnet::datalink::interfaces()
+ let ips = pnet_datalink::interfa... | Known vulnerability in dependency 'pnet' v 0.25.0
I ran `cargo audit` on the current master and got a match for a known vulnerability in pnet 0.25.0:
__ID__: RUSTSEC-2019-0037
__Package__: pnet
__Version__: 0.25.0
__Fixed in__: not yet fixed
__Title__: Compiler optimisation for next_with_timeout in pnet::transpo... | > **Fixed in**: >=0.26.0
> **Issue**: [pnet GitHub issue #449](https://github.com/libpnet/libpnet/issues/449)
This doesn't really seem to have been fixed yet. (https://github.com/libpnet/libpnet/pull/455)
> > **Fixed in**: >=0.26.0
>
> > **Issue**: [pnet GitHub issue #449](https://github.com/libpnet/libpnet/is... | 2020-11-27T21:36:22Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,346 | hyperium__hyper-2346 | [
"1937"
] | a470446deb2cb2c0e3700f67d9f70097d0d7d75f | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -9,21 +9,21 @@
//! # Resolvers are `Service`s
//!
//! A resolver is just a
-//! `Service<Name, Response = impl Iterator<Item = IpAddr>>`.
+//! `Service<Name, Response = impl Iterator<... | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -366,42 +366,42 @@ mod tests {
let v4_addr = (ip_v4, 80).into();
let v6_addr = (ip_v6, 80).into();
- let (mut preferred, mut fallback) = IpAddrs {
+ let... | feat(client): allow connecting to IPv6 link-local addresses
| Note: requires https://github.com/hyperium/http/pull/343 to work (patch in Cargo.toml)
Addressed the review comments, so this is ready for review again.
Uploaded as a separate commit, I can of course squash/rebase if desired.
I'm not up-to-speed on IPv6 zone IDs. It identifies a specific port? Or, why is this changi... | 2020-11-26T01:33:40Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,337 | hyperium__hyper-2337 | [
"2086"
] | 751c122589cfd9935e8e3239cd0d692e573784c5 | diff --git a/examples/http_proxy.rs b/examples/http_proxy.rs
--- a/examples/http_proxy.rs
+++ b/examples/http_proxy.rs
@@ -58,7 +58,7 @@ async fn proxy(client: HttpClient, req: Request<Body>) -> Result<Response<Body>,
// `on_upgrade` future.
if let Some(addr) = host_addr(req.uri()) {
toki... | diff --git a/src/upgrade.rs b/src/upgrade.rs
--- a/src/upgrade.rs
+++ b/src/upgrade.rs
@@ -277,6 +280,38 @@ impl<T: AsyncRead + AsyncWrite + Unpin + 'static> Io for ForwardsWriteBuf<T> {
}
}
+mod sealed {
+ use super::OnUpgrade;
+
+ pub trait CanUpgrade {
+ fn on_upgrade(self) -> OnUpgrade;
+ }
... | Move HTTP upgrades API off the Body type
Introduced in https://github.com/hyperium/hyper/pull/1563, the HTTP Upgrade/`CONNECT` API currently is accessed via `hyper::Body::on_upgrade`. This has some downsides that I'd like to address with a modified API:
- It makes the `Body` type fatter.
- It requires people keep t... | Just my 2¢, and I don't know how you or others would feel about it, but at this early stage it should be fine IMO to just release a 0.14 with it changed to the way you believe it should be. I suspect that only a few of us users have gone far upgrading to 0.13 yet and and its just another version to bump in our Cargo.t... | 2020-11-19T22:30:09Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,319 | hyperium__hyper-2319 | [
"2302"
] | cc7d3058e84b63d26697026f44cdc153b208de9a | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,3 +1,4 @@
+
[package]
name = "hyper"
version = "0.14.0-dev" # don't forget to update html_root_url
diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,12 +31,12 @@ http = "0.2"
http-body = "0.3.1"
httpdate = "0.3... | diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -39,7 +39,7 @@ jobs:
- stable
- beta
- nightly
- - 1.39.0
+ - 1.45.2
os:
- ubuntu-latest
diff --git a/Cargo.toml b/Ca... | Upgrade to Tokio v0.3
Tokio v0.3 [just released](https://tokio.rs/blog/2020-10-tokio-0-3), we should upgrade as part of hyper v0.14.
Prerequisites:
- [x] Upgrade `h2` to Tokio v0.3
- [ ] Add back functionality to Tokio v0.3
- [x] Reintroduce `oneshot::Sender::poll_closed` https://github.com/tokio-rs/tokio/pul... | https://github.com/hyperium/h2/pull/491 is a PR for updating `h2`.
> [hyperium/h2#491](https://github.com/hyperium/h2/pull/491) is a PR for updating `h2`.
The PR just landed 🎉
As soon it is part of a new release we can proceed here 😄 | 2020-11-05T22:07:58Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 |
hyperium/hyper | 2,315 | hyperium__hyper-2315 | [
"2310"
] | fb19f3a86997af1c8a31a7d5ce6f2b018c9b5a0d | diff --git a/src/proto/h2/ping.rs b/src/proto/h2/ping.rs
--- a/src/proto/h2/ping.rs
+++ b/src/proto/h2/ping.rs
@@ -442,7 +442,16 @@ impl KeepAlive {
let interval = shared.last_read_at() + self.interval;
self.timer.reset(interval);
}
- KeepAliveState::Scheduled |... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1903,6 +1903,94 @@ async fn http2_keep_alive_with_responsive_client() {
client.send_request(req).await.expect("client.send_request");
}
+fn is_ping_frame(buf: &[u8]) -> bool {
+ buf[3] == 6
+}
+
+fn assert_ping_fra... | Only one HTTP2 Ping is sent with keep alive enabled
I believe there is a bug in the HTTP2 keep alive implementation, more concretely in `src/proto/h2/ping.rs`.
This issue was originally detected in https://github.com/hyperium/tonic/issues/474, credits to @alce.
It seems that when enabling HTTP2 server keep alive,... | Thanks for the nice write-up! It does seem like there's a bug in here. Would be good to get this fixed, probably writing a test for this might get trickier...
Hi @seanmonstar ,
Can you help me to see if I'm on the right track here?
To test the fix I suggested above, we could write a test like below.
Basically w... | 2020-10-29T15:13:29Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,264 | hyperium__hyper-2264 | [
"2263"
] | 3de81c822e6ac5a5b0640059f53838d0906f68c4 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -12,6 +12,7 @@ use super::{Decoder, Encode, EncodedBuf, Encoder, Http1Transaction, ParseContext
use crate::common::{task, Pin, Poll, Unpin};
use crate::headers::connection_keep_alive;
use crate::proto::{... | diff --git a/src/proto/h1/encode.rs b/src/proto/h1/encode.rs
--- a/src/proto/h1/encode.rs
+++ b/src/proto/h1/encode.rs
@@ -405,7 +406,7 @@ mod tests {
assert_eq!(dst, b"foo bar");
assert!(!encoder.is_eof());
- encoder.end::<()>().unwrap_err();
+ encoder.end::<()>().unwrap();
... | Sending a streamed non-chunked request will hang when body sender is dropped early
When sending a streaming request (using `Body::channel`) without content-length, the request terminates when dropping the `Sender`. But when a content-length is set, dropping the `Sender` before all bytes are sent will result in a reques... | Currently the writing state just gets closed, [here](https://github.com/hyperium/hyper/blob/3de81c822e6ac5a5b0640059f53838d0906f68c4/src/proto/h1/conn.rs#L604). Instead, `end_body` should probably be changed to return a `crate::Result<()>`, and that case should return an error that will shutdown the connection. | 2020-08-10T23:08:55Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,216 | hyperium__hyper-2216 | [
"2215"
] | f162ca2f2fd14681e11dd8b9ba8d1469b2b9271b | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -562,13 +562,13 @@ impl Http1Transaction for Server {
}
}
None | Some(BodyLength::Known(0)) => {
- if msg.head.subject != StatusCode... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1330,8 +1330,9 @@ async fn upgrades_new() {
let mut buf = [0; 256];
tcp.read(&mut buf).expect("read 1");
- let expected = "HTTP/1.1 101 Switching Protocols\r\n";
- assert_eq!(s(&buf[..expecte... | Hyper should skip automatic Content-Length header for HTTP 1xx responses
Similar to issue #1797 hyper should not set a content-length header for a number of different scenario's. Quoting [RFC 7230, section 3.3.2](https://tools.ietf.org/html/rfc7230#section-3.3.2) 6th paragraph:
> A server MUST NOT send a Content-Le... | 2020-06-03T09:57:53Z | 0.14 | a24f0c0af8e1f4c6b7cc3a47c83eb6e4af88aca6 | |
hyperium/hyper | 2,202 | hyperium__hyper-2202 | [
"2188"
] | 203621e3be6b0dab6b79d1914482c556075a19ff | diff --git a/src/body/mod.rs b/src/body/mod.rs
--- a/src/body/mod.rs
+++ b/src/body/mod.rs
@@ -22,17 +22,14 @@ pub use self::aggregate::aggregate;
pub use self::body::{Body, Sender};
pub use self::to_bytes::to_bytes;
-pub(crate) use self::payload::Payload;
-
mod aggregate;
mod body;
-mod payload;
mod to_bytes;
... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -258,7 +258,7 @@ mod response_body_lengths {
fn auto_response_with_unknown_length() {
run_test(TestCase {
version: 1,
- // no headers means trying to guess from Payload
+ // no ... | refactor: use HttpBody with extra bounds instead of Payload trait
I've done most of the legwork, but I'm confused about the interaction of the error types that the compiler is complaining about at this point. If someone else wants to take a look, that'd be great.
| 2020-05-14T20:17:18Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 | |
hyperium/hyper | 2,193 | hyperium__hyper-2193 | [
"2176"
] | e08a271eb93711f7209da98ab6261851f92da235 | diff --git a/examples/README.md b/examples/README.md
--- a/examples/README.md
+++ b/examples/README.md
@@ -39,7 +39,7 @@ pretty_env_logger = "0.4"
* [`params`](params.rs) - A webserver that accept a form, with a name and a number, checks the parameters are presents and validates the input.
-* [`send_file`](send_fi... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -51,6 +51,7 @@ serde_derive = "1.0"
serde_json = "1.0"
tokio = { version = "0.2.2", features = ["fs", "macros", "io-std", "rt-util", "sync", "time", "test-util"] }
tokio-test = "0.2"
+tokio-util = { version = "0.3", features = ["codec"] }
tow... | Serve a file through a readable stream
I want to send a file without putting the whole file in memory, for that i use futures-fs who creat a readable stream, but i cant give to a Hyper response, with the Body::wrap_stream function:
Code:
```rust
use hyper::service::{ make_service_fn, service_fn };
use hyper::{ Body... | I think this is because futures-fs crate uses `Future`s and `Stream`s from [futures](https://crates.io/crates/futures) crate of version 0.1
But hyper 0.13 works with futures of version 0.3, these versions are incompatible.
There is a way to convert file into stream by [tokio-util](https://crates.io/crates/tokio-uti... | 2020-04-24T08:56:16Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,119 | hyperium__hyper-2119 | [
"838"
] | a354580e3f7f22dfebb872df0b9de67d0e1f1840 | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -11,7 +11,7 @@ use futures_util::TryStreamExt;
use http::HeaderMap;
use http_body::{Body as HttpBody, SizeHint};
-use crate::common::{task, Future, Never, Pin, Poll};
+use crate::common::{task, watch, Future, Never, Pi... | diff --git a/src/body/body.rs b/src/body/body.rs
--- a/src/body/body.rs
+++ b/src/body/body.rs
@@ -507,11 +525,29 @@ impl Sender {
}
}
+impl fmt::Debug for Sender {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ #[derive(Debug)]
+ struct Open;
+ #[derive(Debug)]
+ ... | Change 100-continue behavior to send when Body has been polled
Use of the 100 (Continue) Status (https://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3):
> The purpose of the 100 (Continue) status (see section 10.1.1) is to allow a client that is sending a request message with a request body to determine if t... | > master - looks like this feature is forgotten.
Not so much forgotten, I just wanted to come up with a better design. What you outline here seems like it should work on master:
``` rust
fn on_request(&mut self, req: Request) -> Next {
match request.headers().get() {
Some(&ContentLength(len)) if len > 10... | 2020-01-27T23:30:38Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,115 | hyperium__hyper-2115 | [
"2114"
] | ba2a144f8b81042247088215425f91760d8694a1 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -902,7 +902,6 @@ impl State {
}
fn prepare_upgrade(&mut self) -> crate::upgrade::OnUpgrade {
- debug_assert!(self.upgrade.is_none());
let (tx, rx) = crate::upgrade::pending();
... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1323,6 +1323,46 @@ async fn upgrades_new() {
assert_eq!(s(&vec), "bar=foo");
}
+#[tokio::test]
+async fn upgrades_ignored() {
+ let _ = pretty_env_logger::try_init();
+ let mut listener = tcp_bind(&"127.0.0.1:0"... | 'assertion failed: self.upgrade.is_none()' when reusing connection with ignored upgrade header
Hyper threads panic (though the server remains running) when a client makes multiple requests with an upgrade header (which hyper ignores). The first request is handled without issue, but when the second request is made the h... | Looks like a `debug_assert`, but I can't possibly remember why it's there... | 2020-01-24T00:27:24Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,077 | hyperium__hyper-2077 | [
"2067"
] | bfda3906170b3b7f184e586d18bdcfa2f7b8e941 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,7 +25,7 @@ futures-core = { version = "0.3", default-features = false }
futures-channel = "0.3"
futures-util = { version = "0.3", default-features = false }
http = "0.2"
-http-body = "0.3"
+http-body = "0.3.1"
httparse = "1.0"
h2 = "0.2.... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -146,7 +146,7 @@ macro_rules! test {
);
)*
- let body = rt.block_on(concat(res.into_body()))
+ let body = rt.block_on(concat(res))
.expect("body concat wai... | Consider implementing HttpBody for Request and Response
In https://github.com/hyperium/http/issues/107, we didn't implement `Stream` for `http::{Request, Response}` so as to not have the external dependency. However, in `http-body`, since we define the trait and import `http`, we could provide this implementation.
I... | I think this makes sense but forces http to be async I guess unless we put it behind a feature flag. Otherwise, I think this could be a great addition.
How does it force http to be async? It'd only implement in the `http-body` crate.
Ah you're right, if the impl is in the http-body crate then I am +1 | 2019-12-13T18:20:56Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,075 | hyperium__hyper-2075 | [
"2058"
] | e12329054a6707d05bed342a249e1c75a932d52f | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -800,7 +800,7 @@ impl Client {
Ok(Some((DecodedLength::CHUNKED, false)))
} else {
trace!("not chunked, read till eof");
- Ok(Some((DecodedLength... | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -1441,7 +1441,7 @@ mod tests {
",
);
- // transfer-encoding
+ // transfer-encoding: chunked
assert_eq!(
parse(
"\
diff --git a/s... | Transfer-Encoding: identity
I have a web service that returns its content with "Transfer-Encoding: identity". If I read the spec correctly that means that the content should not be touched and interpreted as it is.
Unfortunately hyper seems to assume that whenever transfer encoding is present in a response header it... | Yep, that line looks wrong indeed! | 2019-12-12T21:04:25Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,048 | hyperium__hyper-2048 | [
"1931"
] | c56ccfb03366036dcc48d037e4c212d1f0fc7eb9 | diff --git a/examples/web_api.rs b/examples/web_api.rs
--- a/examples/web_api.rs
+++ b/examples/web_api.rs
@@ -3,7 +3,7 @@
use futures_util::{StreamExt, TryStreamExt};
use hyper::client::HttpConnector;
use hyper::service::{make_service_fn, service_fn};
-use hyper::{header, Body, Chunk, Client, Method, Request, Respo... | diff --git a/src/body/chunk.rs /dev/null
--- a/src/body/chunk.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-use std::fmt;
-
-use bytes::{Buf, Bytes};
-
-/// A piece of a message body.
-///
-/// These are returned by [`Body`](::Body). It is an efficient buffer type.
-///
-/// A `Chunk` can be easily created by many of Rust's stan... | Remove Chunk in favor of using Bytes directly
Compared to `Bytes`, `Chunk` is pointless and kinda frustrating:
* It's a trivial wrapper around `Bytes` but `Bytes` is exposed via the `From`/`Into` impl anyways so it's not like it's keeping it out of the public API
* `Chunk` adds 0 new functionality over `Bytes`, all... | I'm a firm +1 to this suggestion. I'd also be okay with _maybe_ replacing `Bytes` usage with _just_ `Vec<u8>`, but I feel less strongly about the latter point.
I haven't checked if `BytesMut` is reused internally once all strong refs are gone. I assumed that was the major reason for using `Bytes` in the first place.
I ... | 2019-12-06T00:58:05Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,044 | hyperium__hyper-2044 | [
"1673"
] | edbd10ac96c5cc6dbeca80ada80f143dbd13d118 | diff --git a/src/client/pool.rs b/src/client/pool.rs
--- a/src/client/pool.rs
+++ b/src/client/pool.rs
@@ -2,11 +2,13 @@ use std::collections::{HashMap, HashSet, VecDeque};
use std::fmt;
use std::ops::{Deref, DerefMut};
use std::sync::{Arc, Mutex, Weak};
+
+#[cfg(not(feature = "runtime"))]
use std::time::{Duration,... | diff --git /dev/null b/.github/workflows/CI.yml
new file mode 100644
--- /dev/null
+++ b/.github/workflows/CI.yml
@@ -0,0 +1,76 @@
+name: CI
+on:
+ pull_request:
+ push:
+ branches:
+ - master
+
+env:
+ RUST_BACKTRACE: 1
+
+jobs:
+ test:
+ name: Test ${{ matrix.rust }} on ${{ matrix.os }}
+
+ strategy... | Switch from Travis and AppVeyor to GitHub Actions
AppVeyor is quite slow, and the current script in hyper tests Windows nightly, which can mean Windows testing can be flaky. It'd be nice to move to Travis-CI's new Windows support, running the tests on the same matrix as AppVeyor, but probably sticking with just stable ... | I'm noticing this more and more, since AppVeyor won't build any jobs in parallel, nor branches, so if a couple PRs appear, it can take a couple hours to get run (and even just a single PR will run 4 jobs at around ~6-7minutes each, for ~30mins total).
Previous attempt: https://github.com/hyperium/hyper/pull/1690
Appare... | 2019-12-05T01:55:47Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,042 | hyperium__hyper-2042 | [
"2034"
] | aa66de4f27748cad84efe8113744f607e7b6b79a | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -69,8 +70,8 @@ tcp = [
"tokio/time",
]
-# unstable features
-unstable-stream = []
+# `impl Stream` for things
+stream = []
# internal features used in CI
nightly = []
diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.t... | diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,11 +5,11 @@ matrix:
fast_finish: true
include:
- rust: nightly
- env: FEATURES="--no-default-features --features runtime,unstable-stream,nightly"
+ env: FEATURES="--no-default-features --features runtim... | Rename `unstable-stream` feature to just `stream`
While hyper is pre-1.0, it's not really fair to say other pre-1.0 dependencies are unstable.
Should `stream` be enabled by default?
| To me, `Stream` seemed like a core trait, just like `Future`, so I was surprised when I had to switch it on in hyper.
I know that the reality around what’s core at the moment is a bit more complicated at the moment, but the above is just my initial reaction.
I would vote yes for `stream` as default, but perhaps ... | 2019-12-05T00:50:21Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,040 | hyperium__hyper-2040 | [
"2039"
] | 4d7a2266b88b2c5c92231bcd2bd75d5842198add | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,7 +25,7 @@ futures-core = { version = "0.3", default-features = false }
futures-channel = "0.3"
futures-util = { version = "0.3", default-features = false }
http = "0.2"
-http-body = "0.2"
+http-body = "0.3"
httparse = "1.0"
h2 = "0.2"
... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -49,7 +49,7 @@ spmc = "0.3"
serde = "1.0"
serde_derive = "1.0"
serde_json = "1.0"
-tokio = { version = "0.2.2", features = ["fs", "macros", "rt-util", "sync", "time", "test-util"] }
+tokio = { version = "0.2.2", features = ["fs", "macros", "io... | Update to http-body 0.3
| 2019-12-05T00:30:16Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 | |
hyperium/hyper | 2,030 | hyperium__hyper-2030 | [
"2025"
] | 131962c86ab0a31c2413261cf4532eca88d67dcb | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,35 +20,28 @@ include = [
]
[dependencies]
-bytes = "0.4.6"
-futures-core = "0.3.1"
-futures-channel = "0.3.1"
-futures-util = "0.3.1"
-http = "0.1.15"
-http-body = "=0.2.0-alpha.3"
+bytes = "0.5"
+futures-core = { version = "0.3", default... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -56,9 +49,8 @@ spmc = "0.3"
serde = "1.0"
serde_derive = "1.0"
serde_json = "1.0"
-tokio = "=0.2.0-alpha.6" # using #[tokio::test] attributes
-tokio-fs = "=0.2.0-alpha.6"
-tokio-test = "=0.2.0-alpha.6"
+tokio = { version = "0.2.2", features = ... | Update to tokio 0.2
- [ ] Blocked on `h2`: https://github.com/hyperium/h2/milestone/2
| looks like the blocker is gone now? :)
The h2 change was just commited to the code repository and no new release uploaded to `crates.io`. :disappointed:
A follow up change is needed to `h2` to restore all behavior: https://github.com/hyperium/h2/pull/429
Please keep in mind that in the US it's Thanksgiving weekend,... | 2019-12-04T00:07:28Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 2,019 | hyperium__hyper-2019 | [
"1984"
] | 19a7aab51f4b70ef1561ecd912c988d9ddfc7532 | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -21,18 +21,16 @@
//! Ok::<_, Infallible>(iter::once(IpAddr::from([127, 0, 0, 1])))
//! });
//! ```
-use std::{fmt, io, vec};
use std::error::Error;
-use std::net::{
- IpAddr, ... | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -326,33 +334,49 @@ mod sealed {
}
}
+pub(crate) async fn resolve<R>(resolver: &mut R, name: Name) -> Result<R::Addrs, R::Error>
+where
+ R: Resolve,
+{
+ futures_util::futu... | Rewrite HttpConnector internals with async/await
The internal code handling the `HttpConnector` is messy from manual future implementations. I believe it could be much cleaner if written with `async fn` and `await`.
| 2019-11-19T17:39:03Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 | |
hyperium/hyper | 2,011 | hyperium__hyper-2011 | [
"1903"
] | 039281b89cf1ab54a0ecc10c5e7fee56d4da0cf4 | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -1,11 +1,26 @@
-//! The `Resolve` trait, support types, and some basic implementations.
+//! DNS Resolution used by the `HttpConnector`.
//!
//! This module contains:
//!
//! - A [`G... | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -299,6 +279,41 @@ impl Future for TokioThreadpoolGaiFuture {
}
}
+mod sealed {
+ use tower_service::Service;
+ use crate::common::{Future, Poll, task};
+ use super::{IpA... | Change `Resolve` to alias `Service`
After #1782 is done, the `Resolve` trait should be changed to basically an alias for a `Service<Name>`. This would allow more composability, being able to use ServiceExt to customize resolvers.
| Now that #1792 is closed, what do you have in mind by "basically an alias"? I assume this isn't referring to waiting for https://github.com/rust-lang/rust/issues/41517 , so what should `Resolve` become?
It'd be similar to `HttpService`, basically just bounds that mean `R: Service<Name, Response = impl Iterator<Item = I... | 2019-11-12T20:08:57Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,983 | hyperium__hyper-1983 | [
"1843"
] | a1fe383c9d86a813fb2574cc1145ec654ee47e0d | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -151,7 +151,9 @@ where I: AsyncRead + AsyncWrite + Unpin,
self.state.version = msg.head.version;
if msg.decode == DecodedLength::ZERO {
- debug_assert!(!msg.expect_continue, "... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -724,6 +724,28 @@ fn expect_continue_sends_100() {
assert_eq!(body, msg);
}
+#[test]
+fn expect_continue_but_no_body_is_ignored() {
+ let server = serve();
+ let mut req = connect(server.addr());
+ server.repl... | server debug panic on `Expect: 100-continue` without `Content-Length`
This is related to #1842 but seems distinct enough to warrant its own issue.
When doing Icecast streaming, the client typically sends an authorization header and an `Expect: 100-continue` to wait for authorization before trying to upload a stream.... | 2019-10-18T22:34:09Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 | |
hyperium/hyper | 1,981 | hyperium__hyper-1981 | [
"1764"
] | 8e7ebd80cd81d3b1ad900debd150667812c8d8e3 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -38,7 +38,7 @@ where I: AsyncRead + AsyncWrite + Unpin,
Conn {
io: Buffered::new(io),
state: State {
- allow_half_close: true,
+ allow_half_c... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -945,6 +945,7 @@ fn disable_keep_alive_post_request() {
#[test]
fn empty_parse_eof_does_not_return_error() {
+ let _ = pretty_env_logger::try_init();
let mut rt = Runtime::new().unwrap();
let listener = tcp_bi... | 100% CPU usage on client disconnection when serving a streamed response
I ran into an issue when load testing my server application based on Hyper 0.12.23. The servers provides very long (video) streams to clients. The problem is that sometimes when a client disconnects, the server ends up in an infinite loop trying to... | I can see the same behaviour with the latest Hyper v0.12.24 (tokio v0.1.15, tokio-io v0.1.11). The application works correctly when I put it behind nginx proxy.
Hm, sounds like it's looping here? https://github.com/hyperium/hyper/blob/877606d5c81195374259561aa98b973a00fa6056/src/proto/h1/io.rs#L215
Does the log mess... | 2019-10-18T20:14:19Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,947 | hyperium__hyper-1947 | [
"1945"
] | dc54ee199f2d19d65913d224b900a61ab3bf2415 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,21 +27,21 @@ futures-util-preview = { version = "=0.3.0-alpha.18" }
http = "0.1.15"
http-body = "=0.2.0-alpha.1"
httparse = "1.0"
-h2 = "=0.2.0-alpha.1"
+h2 = "=0.2.0-alpha.2"
iovec = "0.1"
itoa = "0.4.1"
log = "0.4"
net2 = { version =... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,9 +52,9 @@ spmc = "0.3"
serde = "1.0"
serde_derive = "1.0"
serde_json = "1.0"
-tokio = "=0.2.0-alpha.4" # using #[tokio::test] attributes
-tokio-fs = "=0.2.0-alpha.4"
-tokio-test = "=0.2.0-alpha.4"
+tokio = "=0.2.0-alpha.5" # using #[tokio... | Update to tokio alpha 5
- [ ] update h2
- [ ] update hyper
| h2 update: https://github.com/hyperium/h2/pull/409 | 2019-09-22T04:13:15Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,926 | hyperium__hyper-1926 | [
"1925"
] | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -781,31 +781,44 @@ impl Client {
impl Client {
fn set_length(head: &mut RequestHead, body: Option<BodyLength>) -> Encoder {
- if let Some(body) = body {
- let can_chunked = head.ve... | diff --git a/tests/client.rs b/tests/client.rs
--- a/tests/client.rs
+++ b/tests/client.rs
@@ -356,7 +356,7 @@ test! {
}
test! {
- name: client_get_implicitly_empty,
+ name: client_get_req_body_implicitly_empty,
server:
expected: "GET / HTTP/1.1\r\nhost: {addr}\r\n\r\n",
diff --git a/tests/cli... | Client GET requests with transfer-encoding are wrongly stripped
The client wrongly strips `transfer-encoding: chunked` from GET requests, thinking that GET requests shouldn't have payloads. However, [that's not explicitly true](https://tools.ietf.org/html/rfc7231#section-4.3.1):
> A payload within a GET request m... | 2019-09-04T21:33:38Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 | |
hyperium/hyper | 1,912 | hyperium__hyper-1912 | [
"1902"
] | 4f2743991c227836c3886778512afe1297df3e5b | diff --git a/src/client/connect/http.rs b/src/client/connect/http.rs
--- a/src/client/connect/http.rs
+++ b/src/client/connect/http.rs
@@ -3,6 +3,7 @@ use std::error::Error as StdError;
use std::io;
use std::mem;
use std::net::{IpAddr, SocketAddr};
+use std::sync::Arc;
use std::time::Duration;
use http::uri::{Sc... | diff --git a/src/client/connect/http.rs b/src/client/connect/http.rs
--- a/src/client/connect/http.rs
+++ b/src/client/connect/http.rs
@@ -671,7 +698,15 @@ mod tests {
use tokio::runtime::current_thread::Runtime;
use tokio_net::driver::Handle;
- use super::{Connect, Destination, HttpConnector};
+ use ... | Change `Connect` trait to alias `Service`
After #1782 is done, the `Connect` trait should be changed to basically an alias for a `Service<Destination>`. This would allow more composability, being able to use `ServiceExt` to customize connectors.
| I just remember there is also `MakeConnection` in tower, perhaps that can just be used instead. One difference is that hyper's `Connect` currently returns a `Connected` metadata type.
@seanmonstar I totally missed this issue! But we should drop the connected struct and use `http_connection::HttpConnection` trait. Which... | 2019-08-21T22:19:24Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,906 | hyperium__hyper-1906 | [
"1851"
] | 4920f5e264c57f87dc8b91e7ed9a575359cc093c | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ futures-util-preview = { version = "0.3.0-alpha.17" }
http = "0.1.15"
http-body = "0.1"
httparse = "1.0"
-h2 = "0.1.10"
+h2 = { git = "https://github.com/hyperium/h2" }
iovec = "0.1"
itoa = "0.4.1"
log = "0.4"
diff --git a/sr... | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -64,18 +64,14 @@ fn http1_parallel_x10_req_10mb(b: &mut test::Bencher) {
}
#[bench]
-#[ignore]
fn http2_get(b: &mut test::Bencher) {
- // FIXME: re-implement tests when `h2` upgrades to `async/a... | Update h2 to std::future
As part of the upgrade to `std::future` (#1805), the HTTP2 support was left as `unimplemented!`. This needs to be re-enabled, but depends on the `h2` crate updating.
| Is there an issue/PR/branch that is tracking the update of h2 to `std::future`, is anyone working on it currently?
Related issue in the h2 repo: https://github.com/hyperium/h2/issues/385
The relevant work in the `h2` crate has merged! Next up: re-enabling the http2 stuff inside hyper. It should be a bit easier, mostly ... | 2019-08-19T22:27:17Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,894 | hyperium__hyper-1894 | [
"1893"
] | 9d5299b655b7db86462fdb3929acf16ce5c2f74d | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,15 +36,15 @@ log = "0.4"
net2 = { version = "0.2.32", optional = true }
pin-utils = "0.1.0-alpha.4"
time = "0.1"
-tokio = { git = "https://github.com/tokio-rs/tokio", optional = true, default-features = false, features = ["rt-full"] }
-tok... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -55,8 +55,8 @@ spmc = "0.2"
serde = "1.0"
serde_derive = "1.0"
serde_json = "1.0"
-tokio-fs = { git = "https://github.com/tokio-rs/tokio" }
-tokio-test = { git = "https://github.com/tokio-rs/tokio" }
+tokio-fs = "0.2.0-alpha.1"
+tokio-test = "... | Update to use tokio alpha from crates.io instead of from git
| 2019-08-09T01:55:54Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 | |
hyperium/hyper | 1,865 | hyperium__hyper-1865 | [
"1863"
] | f93463b3d98d30f47653acde12bf3e42ba278f68 | diff --git a/examples/echo.rs b/examples/echo.rs
--- a/examples/echo.rs
+++ b/examples/echo.rs
@@ -1,7 +1,5 @@
#![feature(async_await)]
-#![deny(warnings)]
-
-extern crate hyper;
+//#![deny(warnings)]
use hyper::{Body, Method, Request, Response, Server, StatusCode};
use hyper::service::{make_service_fn, service_fn... | diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -25,7 +25,7 @@ matrix:
# fi
script:
- - cargo build $FEATURES
+ - cargo build $FEATURES --all-targets
# Disable tests temporarily
# - 'if [ "$BUILD_ONLY" != "1" ]; then cargo test $FEATURES -- --test-threads=1; fi'
# - 'if [... | master branch fails to build with --all-targets
````
cargo check --all-targets
Checking hyper v0.13.0-a.0 (/tmp/hyper)
error[E0463]: can't find crate for `futures`
--> tests/client.rs:4:1
|
4 | extern crate futures;
| ^^^^^^^^^^^^^^^^^^^^^ can't find crate
error: aborting due to previous error
... | Ah, I didn't realize others were testing hyper master for things. As part of #1836, master disabled running its tests in CI since they aren't updated yet.
I've seen the pattern of moving disabled things to a `tests_disabled` directory in other projects, I think doing that here would fix this? | 2019-07-12T20:30:29Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,847 | hyperium__hyper-1847 | [
"1777"
] | 79ae89e066f5fbfc1ce3612299671a14f7b35230 | diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,7 +13,7 @@ matrix:
- rust: stable
env: FEATURES="--no-default-features"
# Minimum Supported Rust Version
- - rust: 1.27.0
+ - rust: 1.31.0
env: FEATURES="--no-default-features --featur... | diff --git a/src/body/chunk.rs b/src/body/chunk.rs
--- a/src/body/chunk.rs
+++ b/src/body/chunk.rs
@@ -176,7 +176,7 @@ mod tests {
let mut dst = Vec::with_capacity(128);
b.iter(|| {
- let chunk = ::Chunk::from(s);
+ let chunk = crate::Chunk::from(s);
dst.put(chunk)... | Migration to Rust 2018
I think this can be done before `std::future` stabilized.
Currently, hyper doesn't follow some Rust 2018 manner;
* module rules (include `extern crate`)
* hidden lifetime parameter
* bare trait
| hyper has tried when possible to link new compiler requirements with breaking changes. While we can sometimes use config flags to only enable things on newer version, I don't think there's a way to do that here, since this also requires putting `edition = "2018"` in the `Cargo.toml`...
@seanmonstar hyper does not reall... | 2019-07-09T21:51:16Z | 0.13 | 42560c7c40d8f934658624114fda4eb819cefda8 |
hyperium/hyper | 1,801 | hyperium__hyper-1801 | [
"1797"
] | 7fde9ba6b8a6cbc1880a518ee303aeb3e08f7847 | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -476,14 +476,20 @@ impl Http1Transaction for Server {
},
None |
Some(BodyLength::Known(0)) => {
- extend(dst, b"content-length: 0\r\n");... | diff --git a/src/proto/h1/role.rs b/src/proto/h1/role.rs
--- a/src/proto/h1/role.rs
+++ b/src/proto/h1/role.rs
@@ -1591,4 +1597,3 @@ mod tests {
})
}
}
-
diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -1687,6 +1687,51 @@ fn http2_service_poll_ready_error_sen... | Hyper should skip automatic Content-Length header for HTTP 304 responses
It's unnecessary, see [RFC 7232](https://tools.ietf.org/html/rfc7232#section-4.1).
Currently Hyper for empty bodies with Content-Length header unset automatically sets the value 0 which is incorrect for HTTP 304 responses, the correct values ar... | This gets set here: https://github.com/hyperium/hyper/blob/8d70baca611869c1997571e8513717396b13328b/src/proto/h1/role.rs#L479
A check could be added there for cases when there should be no header added. | 2019-04-25T01:33:34Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 |
hyperium/hyper | 1,741 | hyperium__hyper-1741 | [
"1740"
] | ec7b93c982dfaf7b213170d967bab809dbe53d8a | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -7,11 +7,13 @@
//! - The [`Resolve`](Resolve) trait and related types to build a custom
//! resolver for use with the `HttpConnector`.
use std::{fmt, io, vec};
+use std::error::Erro... | diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/connect/dns.rs
+++ b/src/client/connect/dns.rs
@@ -317,4 +345,10 @@ mod tests {
assert!(preferred.next().unwrap().is_ipv6());
assert!(fallback.next().unwrap().is_ipv4());
}
+
+ #[test]
+ fn test_name_from_st... | Add FromStr impl for hyper::client::connect::dns::Name
To allow people to construct a `Name`, such as when unit testing a `Resolve` implementation. Providing a `FromStr` impl instead of just `new(String) -> Name` allows us to add in validation in the future if need be.
| 2019-01-10T10:02:14Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 | |
hyperium/hyper | 1,725 | hyperium__hyper-1725 | [
"1708"
] | a6fff13a392d3394cacb1215f83bd8ec87671566 | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -96,6 +116,11 @@ impl Opts {
self
}
+ fn response_body(mut self, body: &'static [u8]) -> Self {
+ self.response_body = body;
+ self
+ }
+
fn parallel(mut self, c... | diff --git a/benches/end_to_end.rs b/benches/end_to_end.rs
--- a/benches/end_to_end.rs
+++ b/benches/end_to_end.rs
@@ -29,6 +29,26 @@ fn http1_post(b: &mut test::Bencher) {
.bench(b)
}
+#[bench]
+fn http1_body_100kb(b: &mut test::Bencher) {
+ let body = &[b'x'; 1024 * 100];
+ opts()
+ .method(M... | Adaptive Read Buffer
Add an adaptive read buffer strategy for `proto::h1::io::Buffered`, such that the size of the read buffer changes depending on the amount of bytes that are found on the transport for each `read` operation. This concept is similar to Netty's [AdaptiveRecvByteBufAllocator](https://github.com/netty/ne... | 2018-11-28T01:02:13Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 | |
hyperium/hyper | 1,723 | hyperium__hyper-1723 | [
"1716"
] | c35bdca8fab3facfc69a2d85c2fe4eb46887e716 | diff --git a/src/proto/h1/conn.rs b/src/proto/h1/conn.rs
--- a/src/proto/h1/conn.rs
+++ b/src/proto/h1/conn.rs
@@ -38,6 +38,7 @@ where I: AsyncRead + AsyncWrite,
Conn {
io: Buffered::new(io),
state: State {
+ allow_half_close: true,
cached_headers: None... | diff --git a/tests/server.rs b/tests/server.rs
--- a/tests/server.rs
+++ b/tests/server.rs
@@ -991,6 +991,71 @@ fn nonempty_parse_eof_returns_error() {
rt.block_on(fut).expect_err("partial parse eof is error");
}
+#[test]
+fn socket_half_closed() {
+ let _ = pretty_env_logger::try_init();
+ let mut rt = R... | Response future not dropped on disconnect
In certain cases I see Response future is not dropped when the connection closes. I have a minimal reproduction here: https://github.com/luben/repro-hyper
The reproduction is simplified work queue - workers wait on `GET /next`, clients submit work to `POST /`, worker submit... | I haven't really investigated, could the fix for #1717 have fixed this too?
I will try and report back tomorrow.
I tried. It's not fixed. The way to reproduce it:
1. Run the broker.
2. Run the worker.
...
3. Restart the worker. The broker should report "Dropping Next()" but does not.
next curl request fails.
I thi... | 2018-11-27T00:24:56Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 |
hyperium/hyper | 1,686 | hyperium__hyper-1686 | [
"1485"
] | bf188b28fe1f2c1c368824926a77df78f0d00a13 | diff --git a/src/client/conn.rs b/src/client/conn.rs
--- a/src/client/conn.rs
+++ b/src/client/conn.rs
@@ -466,6 +466,7 @@ impl Builder {
T: AsyncRead + AsyncWrite + Send + 'static,
B: Payload + 'static,
{
+ trace!("client handshake HTTP/{}", if self.http2 { 2 } else { 1 });
Hands... | diff --git a/src/client/pool.rs b/src/client/pool.rs
--- a/src/client/pool.rs
+++ b/src/client/pool.rs
@@ -190,7 +191,7 @@ impl<T: Poolable> Pool<T> {
#[cfg(feature = "runtime")]
#[cfg(test)]
pub(super) fn h1_key(&self, s: &str) -> Key {
- (Arc::new(s.to_string()), Ver::Http1)
+ Arc::new(s.... | Add ALPN/HTTP2 support to Connect
The `Connect` trait allows to provide information to the connector in the `Destination` type. It should be augmented to allow requesting ALPN for HTTP2, and the returned `Connected` type should include a way for the connector to inform the `Client` whether HTTP2 was negotiated.
| Talking through this a bit on IRC, here's some clarification. A user likely has various ways they want to declare when to use HTTP/1 vs HTTP/2. A major way to do is with TLS' ALPN mechanism, but that seems best handled in the `Connect` implementation, since hyper has delegated all transport negotiation and establishmen... | 2018-10-27T02:00:20Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 |
hyperium/hyper | 1,678 | hyperium__hyper-1678 | [
"1676"
] | 6fe532da4cbbd7395589e7774de79d3728184395 | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,6 +35,7 @@ tokio-io = "0.1"
tokio-reactor = { version = "0.1", optional = true }
tokio-tcp = { version = "0.1", optional = true }
tokio-timer = { version = "0.2", optional = true }
+tokio-threadpool = { version = "0.1", optional = true }
... | diff --git a/Cargo.toml b/Cargo.toml
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -62,6 +63,7 @@ runtime = [
"tokio-reactor",
"tokio-tcp",
"tokio-timer",
+ "tokio-threadpool",
]
nightly = []
__internal_flaky_tests = []
diff --git a/src/client/connect/dns.rs b/src/client/connect/dns.rs
--- a/src/client/conn... | Consider a Resolver that uses tokio-threadpool::blocking instead of futures-cpupool
Using `tokio_threadpool::blocking` can reduce some overhead, and make resolving use an existing threadpool instead of needing a separate dedicated one. It can't be the default, since it only works if the executor is `tokio_threadpool`, ... | cc @sfackler | 2018-10-20T17:56:38Z | 0.12 | a1609fbb332fccffbeb85d16f1cc0bf98c6ede21 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.