trinity-1686a/garage
2
0
Fork 0
forked from Deuxfleurs/garage
Code Issues Pull requests 1 Projects Releases Wiki Activity

[dep-upgrade-202402] prepare migration to http/hyper 1.0

Browse source
This commit is contained in:
Alex 2024-02-05 14:44:12 +01:00
parent 6e4229e29c
commit 6e69a1fffc
Signed by untrusted user: lx
GPG key ID: 0E496D15096376BE
17 changed files with 67 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.nix
View file

@ -2569,8 +2569,10 @@ in
registry = "registry+https://github.com/rust-lang/crates.io-index";
src = fetchCratesIo { inherit name version; sha256 = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"; };
features = builtins.concatLists [
[ "backports" ]
[ "client" ]
[ "default" ]
[ "deprecated" ]
(lib.optional (rootFeatures' ? "garage/opentelemetry-otlp" || rootFeatures' ? "garage/telemetry-otlp") "full")
[ "h2" ]
[ "http1" ]

2
Cargo.toml
View file

@ -96,7 +96,7 @@ form_urlencoded = "1.0.0"
http = "0.2"
httpdate = "1.0"
http-range = "0.1"
hyper = { version = "0.14", features = ["server", "http1", "runtime", "tcp", "stream"] }
hyper = { version = "0.14", features = ["server", "http1", "runtime", "tcp", "stream", "backports", "deprecated"] }
hyperlocal = { version = "0.8.0", default-features = false, features = ["server"] }
multer = "3.0"
percent-encoding = "2.2"

4
src/api/helpers.rs
View file

@ -1,4 +1,4 @@
use hyper::{Body, Request, Response};
use hyper::{body::HttpBody, Body, Request, Response};
use idna::domain_to_unicode;
use serde::{Deserialize, Serialize};
@ -139,7 +139,7 @@ pub fn key_after_prefix(pfx: &str) -> Option<String> {
}
pub async fn parse_json_body<T: for<'de> Deserialize<'de>>(req: Request<Body>) -> Result<T, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
let resp: T = serde_json::from_slice(&body).ok_or_bad_request("Invalid JSON")?;
Ok(resp)
}

5
src/api/k2v/item.rs
View file

@ -3,7 +3,7 @@ use std::sync::Arc;
use base64::prelude::*;
use http::header;
use hyper::{Body, Request, Response, StatusCode};
use hyper::{body::HttpBody, Body, Request, Response, StatusCode};
use garage_util::data::*;
@ -137,7 +137,8 @@ pub async fn handle_insert_item(
.map(CausalContext::parse_helper)
.transpose()?;
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
let value = DvvsValue::Value(body.to_vec());
garage

4
src/api/s3/bucket.rs
View file

@ -1,7 +1,7 @@
use std::collections::HashMap;
use std::sync::Arc;
use hyper::{Body, Request, Response, StatusCode};
use hyper::{body::HttpBody, Body, Request, Response, StatusCode};
use garage_model::bucket_alias_table::*;
use garage_model::bucket_table::Bucket;
@ -119,7 +119,7 @@ pub async fn handle_create_bucket(
api_key: Key,
bucket_name: String,
) -> Result<Response<Body>, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
if let Some(content_sha256) = content_sha256 {
verify_signed_content(content_sha256, &body[..])?;

4
src/api/s3/cors.rs
View file

@ -5,7 +5,7 @@ use http::header::{
ACCESS_CONTROL_ALLOW_HEADERS, ACCESS_CONTROL_ALLOW_METHODS, ACCESS_CONTROL_ALLOW_ORIGIN,
ACCESS_CONTROL_EXPOSE_HEADERS, ACCESS_CONTROL_REQUEST_HEADERS, ACCESS_CONTROL_REQUEST_METHOD,
};
use hyper::{header::HeaderName, Body, Method, Request, Response, StatusCode};
use hyper::{body::HttpBody, header::HeaderName, Body, Method, Request, Response, StatusCode};
use serde::{Deserialize, Serialize};
@ -64,7 +64,7 @@ pub async fn handle_put_cors(
req: Request<Body>,
content_sha256: Option<Hash>,
) -> Result<Response<Body>, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
if let Some(content_sha256) = content_sha256 {
verify_signed_content(content_sha256, &body[..])?;

4
src/api/s3/delete.rs
View file

@ -1,6 +1,6 @@
use std::sync::Arc;
use hyper::{Body, Request, Response, StatusCode};
use hyper::{body::HttpBody, Body, Request, Response, StatusCode};
use garage_util::data::*;
@ -75,7 +75,7 @@ pub async fn handle_delete_objects(
req: Request<Body>,
content_sha256: Option<Hash>,
) -> Result<Response<Body>, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
if let Some(content_sha256) = content_sha256 {
verify_signed_content(content_sha256, &body[..])?;

4
src/api/s3/lifecycle.rs
View file

@ -1,7 +1,7 @@
use quick_xml::de::from_reader;
use std::sync::Arc;
use hyper::{Body, Request, Response, StatusCode};
use hyper::{body::HttpBody, Body, Request, Response, StatusCode};
use serde::{Deserialize, Serialize};
@ -57,7 +57,7 @@ pub async fn handle_put_lifecycle(
req: Request<Body>,
content_sha256: Option<Hash>,
) -> Result<Response<Body>, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
if let Some(content_sha256) = content_sha256 {
verify_signed_content(content_sha256, &body[..])?;

8
src/api/s3/multipart.rs
View file

@ -1,9 +1,9 @@
use std::collections::HashMap;
use std::sync::Arc;
use futures::prelude::*;
use futures::{prelude::*, TryStreamExt};
use hyper::body::Body;
use hyper::{Request, Response};
use hyper::{body::HttpBody, Request, Response};
use md5::{Digest as Md5Digest, Md5};
use garage_table::*;
@ -87,7 +87,7 @@ pub async fn handle_put_part(
// Read first chuck, and at the same time try to get object to see if it exists
let key = key.to_string();
let body = req.into_body().map_err(Error::from);
let body = TryStreamExt::map_err(req.into_body(), Error::from);
let mut chunker = StreamChunker::new(body, garage.config.block_size);
let ((_, _, mut mpu), first_block) = futures::try_join!(
@ -217,7 +217,7 @@ pub async fn handle_complete_multipart_upload(
upload_id: &str,
content_sha256: Option<Hash>,
) -> Result<Response<Body>, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = HttpBody::collect(req.into_body()).await?.to_bytes();
if let Some(content_sha256) = content_sha256 {
verify_signed_content(content_sha256, &body[..])?;

4
src/api/s3/website.rs
View file

@ -1,7 +1,7 @@
use quick_xml::de::from_reader;
use std::sync::Arc;
use hyper::{Body, Request, Response, StatusCode};
use hyper::{body::HttpBody, Body, Request, Response, StatusCode};
use serde::{Deserialize, Serialize};
use crate::s3::error::*;
@ -63,7 +63,7 @@ pub async fn handle_put_website(
req: Request<Body>,
content_sha256: Option<Hash>,
) -> Result<Response<Body>, Error> {
let body = hyper::body::to_bytes(req.into_body()).await?;
let body = req.into_body().collect().await?.to_bytes();
if let Some(content_sha256) = content_sha256 {
verify_signed_content(content_sha256, &body[..])?;

7
src/garage/tests/k2v/batch.rs
View file

@ -7,7 +7,7 @@ use base64::prelude::*;
use serde_json::json;
use crate::json_body;
use hyper::{Method, StatusCode};
use hyper::{body::HttpBody, Method, StatusCode};
#[tokio::test]
async fn test_batch() {
@ -77,10 +77,7 @@ async fn test_batch() {
.unwrap()
.to_string(),
);
let res_body = hyper::body::to_bytes(res.into_body())
.await
.unwrap()
.to_vec();
let res_body = res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res_body, values.get(sk).unwrap().as_bytes());
}

22
src/garage/tests/k2v/item.rs
View file

@ -7,7 +7,7 @@ use base64::prelude::*;
use serde_json::json;
use crate::json_body;
use hyper::{Method, StatusCode};
use hyper::{body::HttpBody, Method, StatusCode};
#[tokio::test]
async fn test_items_and_indices() {
@ -83,10 +83,7 @@ async fn test_items_and_indices() {
.to_str()
.unwrap()
.to_string();
let res_body = hyper::body::to_bytes(res.into_body())
.await
.unwrap()
.to_vec();
let res_body = res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res_body, content);
// ReadIndex -- now there should be some stuff
@ -152,10 +149,7 @@ async fn test_items_and_indices() {
res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream"
);
let res_body = hyper::body::to_bytes(res.into_body())
.await
.unwrap()
.to_vec();
let res_body = res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res_body, content2);
// ReadIndex -- now there should be some stuff
@ -394,10 +388,7 @@ async fn test_item_return_format() {
.to_str()
.unwrap()
.to_string();
let res_body = hyper::body::to_bytes(res.into_body())
.await
.unwrap()
.to_vec();
let res_body = res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res_body, single_value);
// f1: not specified
@ -434,10 +425,7 @@ async fn test_item_return_format() {
res.headers().get("content-type").unwrap().to_str().unwrap(),
"application/octet-stream"
);
let res_body = hyper::body::to_bytes(res.into_body())
.await
.unwrap()
.to_vec();
let res_body = res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res_body, single_value);
// f3: json

16
src/garage/tests/k2v/poll.rs
View file

@ -1,5 +1,5 @@
use base64::prelude::*;
use hyper::{Method, StatusCode};
use hyper::{body::HttpBody, Method, StatusCode};
use std::time::Duration;
use assert_json_diff::assert_json_eq;
@ -47,11 +47,8 @@ async fn test_poll_item() {
.unwrap()
.to_string();
let res2_body = hyper::body::to_bytes(res2.into_body())
.await
.unwrap()
.to_vec();
assert_eq!(res2_body, b"Initial value");
let res2_body = res2.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res2_body, b"Initial value"[..]);
// Start poll operation
let poll = {
@ -95,11 +92,8 @@ async fn test_poll_item() {
assert_eq!(poll_res.status(), StatusCode::OK);
let poll_res_body = hyper::body::to_bytes(poll_res.into_body())
.await
.unwrap()
.to_vec();
assert_eq!(poll_res_body, b"New value");
let poll_res_body = poll_res.into_body().collect().await.unwrap().to_bytes();
assert_eq!(poll_res_body, b"New value"[..]);
}
#[tokio::test]

9
src/garage/tests/k2v/simple.rs
View file

@ -1,6 +1,6 @@
use crate::common;
use hyper::{Method, StatusCode};
use hyper::{body::HttpBody, Method, StatusCode};
#[tokio::test]
async fn test_simple() {
@ -32,9 +32,6 @@ async fn test_simple() {
.unwrap();
assert_eq!(res2.status(), StatusCode::OK);
let res2_body = hyper::body::to_bytes(res2.into_body())
.await
.unwrap()
.to_vec();
assert_eq!(res2_body, b"Hello, world!");
let res2_body = res2.into_body().collect().await.unwrap().to_bytes();
assert_eq!(res2_body, b"Hello, world!"[..]);
}

11
src/garage/tests/lib.rs
View file

@ -11,15 +11,10 @@ mod k2v;
#[cfg(feature = "k2v")]
mod k2v_client;
use hyper::{Body, Response};
use hyper::{body::HttpBody, Body, Response};
pub async fn json_body(res: Response<Body>) -> serde_json::Value {
let res_body: serde_json::Value = serde_json::from_slice(
&hyper::body::to_bytes(res.into_body())
.await
.unwrap()
.to_vec()[..],
)
.unwrap();
let body = res.into_body().collect().await.unwrap().to_bytes();
let res_body: serde_json::Value = serde_json::from_slice(&body).unwrap();
res_body
}

45
src/garage/tests/s3/website.rs
View file

@ -9,7 +9,7 @@ use aws_sdk_s3::{
};
use http::{Request, StatusCode};
use hyper::{
body::{to_bytes, Body},
body::{Body, HttpBody},
Client,
};
use serde_json::json;
@ -49,7 +49,7 @@ async fn test_website() {
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
); /* check that we do not leak body */
@ -87,7 +87,7 @@ async fn test_website() {
resp = client.request(req()).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
);
@ -107,10 +107,10 @@ async fn test_website() {
.unwrap()
};
let mut admin_resp = client.request(admin_req()).await.unwrap();
let admin_resp = client.request(admin_req()).await.unwrap();
assert_eq!(admin_resp.status(), StatusCode::OK);
assert_eq!(
to_bytes(admin_resp.body_mut()).await.unwrap().as_ref(),
admin_resp.into_body().collect().await.unwrap().to_bytes(),
format!("Domain '{bname}' is managed by Garage").as_bytes()
);
}
@ -124,7 +124,7 @@ async fn test_website() {
resp = client.request(req()).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
); /* check that we do not leak body */
@ -260,7 +260,7 @@ async fn test_website_s3_api() {
.body(Body::empty())
.unwrap();
let mut resp = client.request(req).await.unwrap();
let resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(
@ -268,7 +268,7 @@ async fn test_website_s3_api() {
"*"
);
assert_eq!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
);
}
@ -285,11 +285,11 @@ async fn test_website_s3_api() {
.body(Body::empty())
.unwrap();
let mut resp = client.request(req).await.unwrap();
let resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_eq!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY_ERR.as_ref()
);
}
@ -305,7 +305,7 @@ async fn test_website_s3_api() {
.body(Body::empty())
.unwrap();
let mut resp = client.request(req).await.unwrap();
let resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(
@ -313,7 +313,7 @@ async fn test_website_s3_api() {
"*"
);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
);
}
@ -329,11 +329,11 @@ async fn test_website_s3_api() {
.body(Body::empty())
.unwrap();
let mut resp = client.request(req).await.unwrap();
let resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
);
}
@ -370,11 +370,11 @@ async fn test_website_s3_api() {
.body(Body::empty())
.unwrap();
let mut resp = client.request(req).await.unwrap();
let resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
resp.into_body().collect().await.unwrap().to_bytes(),
BODY.as_ref()
);
}
@ -396,17 +396,12 @@ async fn test_website_s3_api() {
.body(Body::empty())
.unwrap();
let mut resp = client.request(req).await.unwrap();
let resp = client.request(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY_ERR.as_ref()
);
assert_ne!(
to_bytes(resp.body_mut()).await.unwrap().as_ref(),
BODY.as_ref()
);
let resp_bytes = resp.into_body().collect().await.unwrap().to_bytes();
assert_ne!(resp_bytes, BODY_ERR.as_ref());
assert_ne!(resp_bytes, BODY.as_ref());
}
}

10
src/k2v-client/lib.rs
View file

@ -9,7 +9,7 @@ use percent_encoding::{utf8_percent_encode, AsciiSet, NON_ALPHANUMERIC};
use http::header::{ACCEPT, CONTENT_TYPE};
use http::status::StatusCode;
use http::{HeaderName, HeaderValue, Request};
use hyper::{body::Bytes, Body};
use hyper::{body::Bytes, body::HttpBody, Body};
use hyper::{client::connect::HttpConnector, Client as HttpClient};
use hyper_rustls::HttpsConnector;
@ -416,12 +416,16 @@ impl K2vClient {
};
let body = match res.status {
StatusCode::OK => hyper::body::to_bytes(body).await?,
StatusCode::OK => body.collect().await?.to_bytes(),
StatusCode::NO_CONTENT => Bytes::new(),
StatusCode::NOT_FOUND => return Err(Error::NotFound),
StatusCode::NOT_MODIFIED => Bytes::new(),
s => {
let err_body = hyper::body::to_bytes(body).await.unwrap_or_default();
let err_body = body
.collect()
.await
.map(|x| x.to_bytes())
.unwrap_or_default();
let err_body_str = std::str::from_utf8(&err_body)
.map(String::from)
.unwrap_or_else(|_| BASE64_STANDARD.encode(&err_body));