chore(volo-http): combine C/S Request and C/S Response types (#534)

Since `Body` types of client and server have been combined, this
commit combine `ClientRequest` and `ServerResquest` to `Request`,
`ClientResponse` and `ServerResponse` to `Response`.

Signed-off-by: Yu Li <[email protected]>

Author: yukiiiteru

examples/src/http/example-http-server.rs

@@ -4,16 +4,16 @@ use async_stream::stream;
 use bytes::Bytes;
 use faststr::FastStr;
 use futures::Stream;
-use http::{header, Method, Request, StatusCode, Uri};
+use http::{header, Method, StatusCode, Uri};
 use http_body::Frame;
 use serde::{Deserialize, Serialize};
 use tokio_stream::StreamExt;
 use volo::{catch_panic, service::service_fn};
 use volo_http::{
     body::{Body, BodyConversion},
     context::ServerContext,
-    request::ServerRequest,
-    response::ServerResponse,
+    request::Request,
+    response::Response,
     server::{
         extract::{Form, FullUri, Json, MaybeInvalid, Query},
         layer::{FilterLayer, TimeoutLayer},
@@ -105,16 +105,16 @@ async fn post_with_form(Form(info): Form<Login>) -> Result<String, StatusCode> {
 
 async fn test_body_and_err(
     _: &mut ServerContext,
-    _: ServerRequest<FastStr>,
-) -> Result<ServerResponse, StatusCode> {
-    Ok(ServerResponse::default())
+    _: Request<FastStr>,
+) -> Result<Response, StatusCode> {
+    Ok(Response::default())
 }
 
 async fn map_body_and_err_inner(
     cx: &mut ServerContext,
-    req: ServerRequest<Bytes>,
+    req: Request<Bytes>,
     next: Next<FastStr, StatusCode>,
-) -> ServerResponse {
+) -> Response {
     let (parts, body) = req.into_parts();
     let body = FastStr::from_bytes(body).unwrap_or_default();
     let req = Request::from_parts(parts, body);
@@ -123,9 +123,9 @@ async fn map_body_and_err_inner(
 
 async fn map_body_and_err_outer(
     cx: &mut ServerContext,
-    req: ServerRequest,
+    req: Request,
     next: Next<Bytes>,
-) -> ServerResponse {
+) -> Response {
     let (parts, body) = req.into_parts();
     let body = body.into_bytes().await.unwrap();
     let req = Request::from_parts(parts, body);
@@ -206,7 +206,7 @@ async fn extension(Extension(state): Extension<Arc<State>>) -> String {
     format!("State {{ foo: {}, bar: {} }}\n", state.foo, state.bar)
 }
 
-async fn service_fn_test(cx: &mut ServerContext, req: ServerRequest) -> Result<String, Infallible> {
+async fn service_fn_test(cx: &mut ServerContext, req: Request) -> Result<String, Infallible> {
     Ok(format!("cx: {cx:?}, req: {req:?}"))
 }
 
@@ -334,9 +334,9 @@ async fn tracing_from_fn(
     peer: Address,
     cookie_jar: CookieJar,
     cx: &mut ServerContext,
-    req: ServerRequest,
+    req: Request,
     next: Next,
-) -> ServerResponse {
+) -> Response {
     tracing::info!("{:?}", *cookie_jar);
     let count = cookie_jar.get("count").map_or(0usize, |val| {
         val.value().to_string().parse().unwrap_or(0usize)
@@ -361,7 +361,7 @@ async fn tracing_from_fn(
         .into_response()
 }
 
-async fn headers_map_response(response: ServerResponse) -> impl IntoResponse {
+async fn headers_map_response(response: Response) -> impl IntoResponse {
     (
         [
             ("Access-Control-Allow-Origin", "*"),

volo-http/src/client/cookie.rs

@@ -10,8 +10,8 @@ use tokio::sync::RwLock;
 use crate::{
     context::ClientContext,
     error::ClientError,
-    request::{ClientRequest, RequestPartsExt},
-    response::ClientResponse,
+    request::{Request, RequestPartsExt},
+    response::Response,
     utils::cookie::CookieStore,
 };
 
@@ -32,9 +32,9 @@ impl<S> CookieService<S> {
     }
 }
 
-impl<S, B> Service<ClientContext, ClientRequest<B>> for CookieService<S>
+impl<S, B> Service<ClientContext, Request<B>> for CookieService<S>
 where
-    S: Service<ClientContext, ClientRequest<B>, Response = ClientResponse, Error = ClientError>
+    S: Service<ClientContext, Request<B>, Response = Response, Error = ClientError>
         + Send
         + Sync
         + 'static,
@@ -46,7 +46,7 @@ where
     async fn call(
         &self,
         cx: &mut ClientContext,
-        mut req: ClientRequest<B>,
+        mut req: Request<B>,
     ) -> Result<Self::Response, Self::Error> {
         let url = req.url();
 
@@ -58,7 +58,7 @@ where
                     .await
                     .add_cookie_header(&mut parts.headers, url);
             }
-            req = ClientRequest::from_parts(parts, body);
+            req = Request::from_parts(parts, body);
         }
 
         let resp = self.inner.call(cx, req).await?;

volo-http/src/client/layer/fail_on_status.rs

@@ -8,7 +8,7 @@ use volo::context::Context;
 use crate::{
     error::{client::request_error, ClientError},
     request::RequestPartsExt,
-    response::ClientResponse,
+    response::Response,
 };
 
 /// [`Layer`] for throwing service error with the response's error status code.
@@ -87,7 +87,7 @@ impl<Cx, Req, S, B> Service<Cx, Req> for FailOnStatusService<S>
 where
     Cx: Context + Send,
     Req: RequestPartsExt + Send,
-    S: Service<Cx, Req, Response = ClientResponse<B>, Error = ClientError> + Send + Sync,
+    S: Service<Cx, Req, Response = Response<B>, Error = ClientError> + Send + Sync,
 {
     type Response = S::Response;
     type Error = S::Error;
@@ -159,25 +159,25 @@ mod fail_on_status_tests {
     use super::FailOnStatus;
     use crate::{
         body::Body, client::test_helpers::MockTransport, context::ClientContext,
-        error::ClientError, request::ClientRequest, response::ClientResponse, ClientBuilder,
+        error::ClientError, request::Request, response::Response, ClientBuilder,
     };
 
     struct ReturnStatus;
 
-    impl Service<ClientContext, ClientRequest> for ReturnStatus {
-        type Response = ClientResponse;
+    impl Service<ClientContext, Request> for ReturnStatus {
+        type Response = Response;
         type Error = ClientError;
 
         fn call(
             &self,
             _: &mut ClientContext,
-            req: ClientRequest,
+            req: Request,
         ) -> impl std::future::Future<Output = Result<Self::Response, Self::Error>> + Send {
             let path = req.uri().path();
             assert_eq!(&path[..1], "/");
             let status_code = path[1..].parse::<u16>().expect("invalid uri");
             let status_code = StatusCode::from_u16(status_code).expect("invalid status code");
-            let mut resp = ClientResponse::new(Body::empty());
+            let mut resp = Response::new(Body::empty());
             *resp.status_mut() = status_code;
             async { Ok(resp) }
         }

volo-http/src/client/layer/header.rs

@@ -21,7 +21,7 @@ use volo::{
 use crate::{
     client::{dns::Port, target::is_default_port},
     error::client::{builder_error, Result},
-    request::ClientRequest,
+    request::Request,
 };
 
 /// [`Layer`] for inserting a header to requests.
@@ -85,17 +85,17 @@ pub struct HeaderService<S> {
     val: HeaderValue,
 }
 
-impl<Cx, B, S> Service<Cx, ClientRequest<B>> for HeaderService<S>
+impl<Cx, B, S> Service<Cx, Request<B>> for HeaderService<S>
 where
-    S: Service<Cx, ClientRequest<B>>,
+    S: Service<Cx, Request<B>>,
 {
     type Response = S::Response;
     type Error = S::Error;
 
     fn call(
         &self,
         cx: &mut Cx,
-        mut req: ClientRequest<B>,
+        mut req: Request<B>,
     ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
         req.headers_mut().insert(self.key.clone(), self.val.clone());
         self.inner.call(cx, req)
@@ -185,18 +185,18 @@ fn gen_host_by_ep(ep: &Endpoint) -> Option<HeaderValue> {
     gen_host(scheme, name, addr, port)
 }
 
-impl<Cx, B, S> Service<Cx, ClientRequest<B>> for HostService<S>
+impl<Cx, B, S> Service<Cx, Request<B>> for HostService<S>
 where
     Cx: Context,
-    S: Service<Cx, ClientRequest<B>>,
+    S: Service<Cx, Request<B>>,
 {
     type Response = S::Response;
     type Error = S::Error;
 
     fn call(
         &self,
         cx: &mut Cx,
-        mut req: ClientRequest<B>,
+        mut req: Request<B>,
     ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
         if !req.headers().contains_key(header::HOST) {
             if let Some(val) = gen_host_by_ep(cx.rpc_info().callee()) {
@@ -256,17 +256,17 @@ pub struct UserAgentService<S> {
     val: HeaderValue,
 }
 
-impl<Cx, B, S> Service<Cx, ClientRequest<B>> for UserAgentService<S>
+impl<Cx, B, S> Service<Cx, Request<B>> for UserAgentService<S>
 where
-    S: Service<Cx, ClientRequest<B>>,
+    S: Service<Cx, Request<B>>,
 {
     type Response = S::Response;
     type Error = S::Error;
 
     fn call(
         &self,
         cx: &mut Cx,
-        mut req: ClientRequest<B>,
+        mut req: Request<B>,
     ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
         if !req.headers().contains_key(header::USER_AGENT) {
             req.headers_mut()

volo-http/src/client/loadbalance.rs

@@ -25,8 +25,8 @@ use crate::{
         client::{lb_error, no_available_endpoint},
         ClientError,
     },
-    request::ClientRequest,
-    response::ClientResponse,
+    request::Request,
+    response::Response,
 };
 
 /// Default load balance with [`DnsResolver`]
@@ -146,13 +146,11 @@ where
     }
 }
 
-impl<LB, D, S, B> Service<ClientContext, ClientRequest<B>> for LoadBalanceService<LB, D, S>
+impl<LB, D, S, B> Service<ClientContext, Request<B>> for LoadBalanceService<LB, D, S>
 where
     LB: LoadBalance<D>,
     D: Discover,
-    S: Service<ClientContext, ClientRequest<B>, Response = ClientResponse, Error = ClientError>
-        + Send
-        + Sync,
+    S: Service<ClientContext, Request<B>, Response = Response, Error = ClientError> + Send + Sync,
     B: Send,
 {
     type Response = S::Response;
@@ -161,7 +159,7 @@ where
     async fn call(
         &self,
         cx: &mut ClientContext,
-        req: ClientRequest<B>,
+        req: Request<B>,
     ) -> Result<Self::Response, Self::Error> {
         let callee = cx.rpc_info().callee();
 

volo-http/src/client/mod.rs

@@ -47,8 +47,8 @@ use crate::{
         client::{builder_error, Result},
         BoxError, ClientError,
     },
-    request::ClientRequest,
-    response::ClientResponse,
+    request::Request,
+    response::Response,
 };
 
 mod callopt;
@@ -856,9 +856,9 @@ impl<S> Client<S> {
     }
 }
 
-impl<S, B> OneShotService<ClientContext, ClientRequest<B>> for Client<S>
+impl<S, B> OneShotService<ClientContext, Request<B>> for Client<S>
 where
-    S: Service<ClientContext, ClientRequest<B>, Error = ClientError> + Send + Sync,
+    S: Service<ClientContext, Request<B>, Error = ClientError> + Send + Sync,
     B: Send,
 {
     type Response = S::Response;
@@ -867,7 +867,7 @@ where
     async fn call(
         self,
         cx: &mut ClientContext,
-        mut req: ClientRequest<B>,
+        mut req: Request<B>,
     ) -> Result<Self::Response, Self::Error> {
         // set target
         self.inner.target.clone().apply(cx)?;
@@ -912,9 +912,9 @@ where
     }
 }
 
-impl<S, B> Service<ClientContext, ClientRequest<B>> for Client<S>
+impl<S, B> Service<ClientContext, Request<B>> for Client<S>
 where
-    S: Service<ClientContext, ClientRequest<B>, Error = ClientError> + Send + Sync,
+    S: Service<ClientContext, Request<B>, Error = ClientError> + Send + Sync,
     B: Send,
 {
     type Response = S::Response;
@@ -923,7 +923,7 @@ where
     fn call(
         &self,
         cx: &mut ClientContext,
-        req: ClientRequest<B>,
+        req: Request<B>,
     ) -> impl Future<Output = Result<Self::Response, Self::Error>> + Send {
         OneShotService::call(self.clone(), cx, req)
     }
@@ -943,7 +943,7 @@ impl<S> MkClient<Client<S>> for DefaultMkClient {
 static CLIENT: LazyLock<DefaultClient> = LazyLock::new(Default::default);
 
 /// Create a GET request to the specified URI.
-pub async fn get<U>(uri: U) -> Result<ClientResponse>
+pub async fn get<U>(uri: U) -> Result<Response>
 where
     U: TryInto<Uri>,
     U::Error: Into<BoxError>,