58 lines
1.9 KiB
Rust
58 lines
1.9 KiB
Rust
use hyper::client::Client;
|
|
use hyper::client::HttpConnector;
|
|
use hyper::http::uri::Authority;
|
|
use hyper::http::uri::Parts;
|
|
use hyper::http::uri::Scheme;
|
|
use hyper::service::{make_service_fn, service_fn};
|
|
use hyper::Uri;
|
|
use hyper::{Body, Request, Response, Server};
|
|
use std::convert::Infallible;
|
|
use std::net::SocketAddr;
|
|
|
|
pub mod client;
|
|
|
|
async fn handle(mut req: Request<Body>) -> Result<Response<Body>, hyper::Error> {
|
|
// We modify the request by changing its URI.
|
|
// let uri = req.uri();
|
|
// let scheme = uri.scheme().unwrap_or(&Scheme::HTTP);
|
|
// let authority = "localhost:5000";
|
|
// let path_and_query =
|
|
// println!("{:?}", uri);
|
|
// let new_uri = Uri::builder()
|
|
// .scheme(uri.scheme().clone().unwrap_or(&Scheme::HTTP))
|
|
// .authority("http://localhost:5000")
|
|
// .path_and_query(uri.path_and_query().unwrap().clone())
|
|
// .build()
|
|
// .unwrap();
|
|
println!("{:?}", req);
|
|
let req_parts = req.uri().clone().into_parts();
|
|
let mut parts = Parts::default();
|
|
parts.scheme = req_parts.scheme.or_else(|| Some(Scheme::HTTP));
|
|
parts.authority = Some(Authority::from_static("localhost:5000"));
|
|
parts.path_and_query = req_parts.path_and_query;
|
|
|
|
let new_uri = Uri::from_parts(parts).unwrap();
|
|
*req.uri_mut() = new_uri;
|
|
|
|
let client: Client<HttpConnector, Body> = Client::builder().build_http();
|
|
|
|
client.request(req).await
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
// Construct our SocketAddr to listen on...
|
|
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
|
|
|
|
// And a MakeService to handle each connection...
|
|
let make_service = make_service_fn(|_conn| async { Ok::<_, hyper::Error>(service_fn(handle)) });
|
|
|
|
// Then bind and serve...
|
|
let server = Server::bind(&addr).serve(make_service);
|
|
|
|
// And run forever...
|
|
if let Err(e) = server.await {
|
|
eprintln!("server error: {}", e);
|
|
}
|
|
}
|