I am trying to get the data from http get and once I receive the data I want to log the same before returning a response to the user but somehow when I decode the response to byte it gets corrupted.
Sample line of code for decoding response
let (resp_parts, res_body) = backend_res.into_parts();
let body_str = hyper::body::to_bytes(res_body).await.unwrap();
let body_string = String::from_utf8(body_str.to_vec()).unwrap();
use std::borrow::Borrow;
use std::collections::HashMap;
use std::convert::Infallible;
use std::error::Error;
use std::hash::Hasher;
use std::sync::{Arc, Mutex};
use std::time::{Duration, SystemTime};
use hyper::{Body, Client, Request, Response, Server};
use hyper::{body::HttpBody as _, Uri};
use hyper::{Method, StatusCode};
use hyper::client::HttpConnector;
use hyper::server::conn::Http;
use hyper::service::{make_service_fn, service_fn};
use hyper_tls::HttpsConnector;
use lazy_static::lazy_static;
use xxhash_rust::xxh3::xxh3_64;
async fn logResponse(req: Request<Body>) -> Result<Response<Body>, Infallible> {
let mut backend_req = Request::builder()
.method(req.method())
.uri(format!("https://blockstream.info/api/blocks/0"))
.version(req.version());
for (header_name, header_value) in req.headers() {
backend_req = backend_req.header(header_name, header_value);
}
let https = hyper_tls::HttpsConnector::new();
let client = Client::builder().build::<_, hyper::Body>(https);
let body = backend_req.body(Body::empty()).unwrap();
let backend_res = client.request(body).await.unwrap();
let mut res = Response::builder()
.status(backend_res.status())
.version(backend_res.version());
for (header_name, header_value) in backend_res.headers() {
res = res.header(header_name, header_value);
}
/*
Comment from next line to Ok(response) and
uncomment Ok(res.body(backend_res.into_body()).unwrap()) to get working code
*/
let (resp_parts, res_body) = backend_res.into_parts();
/*In below line response to byte array is giving wrong byte array*/
let body_str = hyper::body::to_bytes(res_body).await.unwrap();
let body_string = String::from_utf8(body_str.to_vec()).unwrap();
println!("*************{}",body_string);
let response : Response<Body> = Response::from_parts(resp_parts, body_string.clone().into());
Ok(response)
/*If you uncomment below code you can see correct result is given*/
//Ok(res.body(backend_res.into_body()).unwrap())
}
#[tokio::main]
async fn main() {
// Set up a new HTTP server
let addr = ([0, 0, 0, 0], 3000).into();
let make_svc = make_service_fn(|_conn| async {
Ok::<_, Infallible>(service_fn(logResponse))
});
let server = Server::bind(&addr).serve(make_svc);
// Start the server
println!("Listening on http://{}", addr);
if let Err(e) = server.await {
eprintln!("server error: {}", e);
}
}
Cargo.toml
[package]
name = "minigrep"
version = "0.1.0"
edition = "2021"
[rust]
debug = true
debuginfo-level = 2
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
hyper = "0.13.0-alpha.4"
hyper-tls = "0.4.1"
tokio = { version = "0.2.22", features = ["full"] }
pretty_env_logger = "0.3.1"
xxhash-rust = { version = "0.8.6", features = ["xxh3", "const_xxh3"] }
lazy_static = "1.4.0"