[Rust Server] Update templates so generated client and server compile (OpenAPITools#17876)

Author: azriel-healthpoint

modules/openapi-generator/src/main/resources/rust-server/Cargo.mustache

@@ -50,7 +50,7 @@ client = [
     "serde_ignored", "regex", "percent-encoding", "lazy_static",
 {{/hasCallbacks}}
 {{! Anything added to the list below, should probably be added to the callbacks list below }}
-    "hyper", "hyper-openssl", "hyper-tls", "native-tls", "openssl", "url"
+    "hyper", "hyper-util/http1", "hyper-util/http2", "hyper-openssl", "hyper-tls", "native-tls", "openssl", "url"
 ]
 server = [
 {{#apiUsesMultipart}}
@@ -89,7 +89,7 @@ openssl = { version = "0.10", optional = true }
 async-trait = "0.1.88"
 chrono = { version = "0.4", features = ["serde"] }
 futures = "0.3"
-swagger = { version = "7.0.0-rc1", features = ["serdejson", "server", "client", "tls", "tcp"] }
+swagger = { version = "7.0.0-rc1", features = ["serdejson", "server", "client", "tls"] }
 log = "0.4.27"
 mime = "0.3"
 
@@ -114,7 +114,10 @@ uuid = { version = "1.17.0", features = ["serde", "v4"]}
 {{/apiUsesUuid}}
 
 # Common between server and client features
+bytes = "1.10.1"
+http-body-util = "0.1.3"
 hyper = { version = "1.6", features = ["full"], optional = true }
+hyper-util = { version = "0.1.12", features = ["service"] }
 {{#apiUsesMultipartRelated}}
 mime_multipart = { version = "0.5", optional = true }
 hyper_0_10 = {package = "hyper", version = "0.10", default-features = false, optional=true }
@@ -126,6 +129,7 @@ url = { version = "2.5", optional = true }
 {{#usesUrlEncodedForm}}
 serde_urlencoded = { version = "0.6.1", optional = true }
 {{/usesUrlEncodedForm}}
+tower-service = "0.3.3"
 
 # Server, and client callback-specific
 lazy_static = { version = "1.5", optional = true }
@@ -136,8 +140,7 @@ regex = { version = "1.11", optional = true }
 anyhow = { version = "1", optional = true }
 clap-verbosity-flag = { version = "3.0", optional = true }
 simple_logger = { version = "5.0", features = ["stderr"], optional = true }
-structopt = { version = "0.3", optional = true }
-tokio = { version = "1.45", features = ["rt-threaded", "macros", "stream"], optional = true }
+tokio = { version = "1.45", features = ["rt-multi-thread", "macros"], optional = true }
 {{#apiHasDeleteMethods}}
 dialoguer = { version = "0.8", optional = true }
 {{/apiHasDeleteMethods}}

modules/openapi-generator/src/main/resources/rust-server/auth.mustache

@@ -1,7 +1,7 @@
 use std::collections::BTreeSet;
 use crate::server::Authorization;
 use serde::{Deserialize, Serialize};
-use swagger::{ApiError, auth::{Basic, Bearer}};
+use swagger::{ApiError, auth::AuthData};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Claims {
@@ -17,14 +17,14 @@ pub struct Claims {
 pub trait AuthenticationApi {
 
     /// Method should be implemented (see example-code) to map Bearer-token to an Authorization
-    fn bearer_authorization(&self, token: &Bearer) -> Result<Authorization, ApiError>;
+    fn bearer_authorization(&self, token: &str) -> Result<Authorization, ApiError>;
 
     /// Method should be implemented (see example-code) to map ApiKey to an Authorization
     fn apikey_authorization(&self, token: &str) -> Result<Authorization, ApiError>;
 
     /// Method should be implemented (see example-code) to map Basic (Username:password) to an Authorization
-    fn basic_authorization(&self, basic: &Basic) -> Result<Authorization, ApiError>;
-} 
+    fn basic_authorization(&self, username: &str, password: &str) -> Result<Authorization, ApiError>;
+}
 
 // Implement it for AllowAllAuthenticator (dummy is needed, but should not used as we have Bearer authorization)
 use swagger::auth::{AllowAllAuthenticator, RcBound, Scopes};
@@ -46,7 +46,7 @@ where
     RC::Result: Send + 'static {
 
     /// Get method to map Bearer-token to an Authorization
-    fn bearer_authorization(&self, _token: &Bearer) -> Result<Authorization, ApiError> {
+    fn bearer_authorization(&self, _token: &str) -> Result<Authorization, ApiError> {
         Ok(dummy_authorization())
     }
 
@@ -56,7 +56,7 @@ where
     }
 
     /// Get method to map basic token to an Authorization
-    fn basic_authorization(&self, _basic: &Basic) -> Result<Authorization, ApiError> {
+    fn basic_authorization(&self, _username: &str, _password: &str) -> Result<Authorization, ApiError> {
         Ok(dummy_authorization())
     }
 }

modules/openapi-generator/src/main/resources/rust-server/cargo-config

@@ -6,7 +6,8 @@ rustflags = [
 
     "-W", "trivial_numeric_casts",  # detects trivial casts of numeric types which could be removed
 
-    "-W", "unsafe_code",  # usage of `unsafe` code
+    # unsafe is used in `TokioIo` bridging code copied from `hyper`.
+    # "-W", "unsafe_code",  # usage of `unsafe` code
 
     "-W", "unused_qualifications",  # detects unnecessarily qualified names
 

modules/openapi-generator/src/main/resources/rust-server/client-imports.mustache

@@ -1,7 +1,9 @@
 use async_trait::async_trait;
+use bytes::Bytes;
 use futures::{Stream, future, future::BoxFuture, stream, future::TryFutureExt, future::FutureExt, stream::StreamExt};
+use http_body_util::{combinators::BoxBody, Full};
 use hyper::header::{HeaderName, HeaderValue, CONTENT_TYPE};
-use hyper::{Body, Request, Response, service::Service, Uri};
+use hyper::{body::{Body, Incoming}, Request, Response, service::Service, Uri};
 use percent_encoding::{utf8_percent_encode, AsciiSet};
 use std::borrow::Cow;
 use std::convert::TryInto;
@@ -18,6 +20,7 @@ use std::string::ToString;
 use std::task::{Context, Poll};
 use swagger::{ApiError, AuthData, BodyExt, Connector, DropContextService, Has, XSpanIdString};
 use url::form_urlencoded;
+use tower_service::Service as _;
 
 {{#apiUsesMultipartFormData}}
 use mime::Mime;

modules/openapi-generator/src/main/resources/rust-server/client-mod.mustache

@@ -29,8 +29,8 @@ fn into_base_path(input: impl TryInto<Uri, Error=hyper::http::uri::InvalidUri>,
 /// A client that implements the API by making HTTP calls out to a server.
 pub struct Client<S, C> where
     S: Service<
-           (Request<Body>, C),
-           Response=Response<Body>> + Clone + Sync + Send + 'static,
+           (Request<BoxBody<Bytes, Infallible>>, C),
+           Response=Response<Incoming>> + Clone + Sync + Send + 'static,
     S::Future: Send + 'static,
     S::Error: Into<crate::ServiceError> + fmt::Display,
     C: Clone + Send + Sync + 'static
@@ -47,8 +47,8 @@ pub struct Client<S, C> where
 
 impl<S, C> fmt::Debug for Client<S, C> where
     S: Service<
-           (Request<Body>, C),
-           Response=Response<Body>> + Clone + Sync + Send + 'static,
+           (Request<BoxBody<Bytes, Infallible>>, C),
+           Response=Response<Incoming>> + Clone + Sync + Send + 'static,
     S::Future: Send + 'static,
     S::Error: Into<crate::ServiceError> + fmt::Display,
     C: Clone + Send + Sync + 'static
@@ -60,8 +60,8 @@ impl<S, C> fmt::Debug for Client<S, C> where
 
 impl<S, C> Clone for Client<S, C> where
     S: Service<
-           (Request<Body>, C),
-           Response=Response<Body>> + Clone + Sync + Send + 'static,
+           (Request<BoxBody<Bytes, Infallible>>, C),
+           Response=Response<Incoming>> + Clone + Sync + Send + 'static,
     S::Future: Send + 'static,
     S::Error: Into<crate::ServiceError> + fmt::Display,
     C: Clone + Send + Sync + 'static
@@ -75,8 +75,19 @@ impl<S, C> Clone for Client<S, C> where
     }
 }
 
-impl<Connector, C> Client<DropContextService<hyper::client::Client<Connector, Body>, C>, C> where
-    Connector: hyper::client::connect::Connect + Clone + Send + Sync + 'static,
+impl<Connector, C> Client<
+    DropContextService<
+        hyper_util::service::TowerToHyperService<
+            hyper_util::client::legacy::Client<
+                Connector,
+                BoxBody<Bytes, Infallible>
+            >
+        >,
+        C
+    >,
+    C
+> where
+    Connector: hyper_util::client::legacy::connect::Connect + Clone + Send + Sync + 'static,
     C: Clone + Send + Sync + 'static,
 {
     /// Create a client with a custom implementation of hyper::client::Connect.
@@ -99,8 +110,8 @@ impl<Connector, C> Client<DropContextService<hyper::client::Client<Connector, Bo
         connector: Connector,
     ) -> Result<Self, ClientInitError>
     {
-        let client_service = hyper::client::Client::builder().build(connector);
-        let client_service = DropContextService::new(client_service);
+        let client_service = hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new()).build(connector);
+        let client_service = DropContextService::new(hyper_util::service::TowerToHyperService::new(client_service));
 
         Ok(Self {
             client_service,
@@ -112,26 +123,19 @@ impl<Connector, C> Client<DropContextService<hyper::client::Client<Connector, Bo
 
 #[derive(Debug, Clone)]
 pub enum HyperClient {
-    Http(hyper::client::Client<hyper::client::HttpConnector, Body>),
-    Https(hyper::client::Client<HttpsConnector, Body>),
+    Http(hyper_util::client::legacy::Client<hyper_util::client::legacy::connect::HttpConnector, BoxBody<Bytes, Infallible>>),
+    Https(hyper_util::client::legacy::Client<HttpsConnector, BoxBody<Bytes, Infallible>>),
 }
 
-impl Service<Request<Body>> for HyperClient {
-    type Response = Response<Body>;
-    type Error = hyper::Error;
-    type Future = hyper::client::ResponseFuture;
-
-    fn poll_ready(&mut self, cx: &mut Context) -> Poll<Result<(), Self::Error>> {
-       match self {
-          HyperClient::Http(client) => client.poll_ready(cx),
-          HyperClient::Https(client) => client.poll_ready(cx),
-       }
-    }
+impl Service<Request<BoxBody<Bytes, Infallible>>> for HyperClient {
+    type Response = Response<Incoming>;
+    type Error = hyper_util::client::legacy::Error;
+    type Future = hyper_util::client::legacy::ResponseFuture;
 
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
+    fn call(&self, req: Request<BoxBody<Bytes, Infallible>>) -> Self::Future {
        match self {
-          HyperClient::Http(client) => client.call(req),
-          HyperClient::Https(client) => client.call(req)
+          HyperClient::Http(client) => client.request(req),
+          HyperClient::Https(client) => client.request(req)
        }
     }
 }
@@ -155,13 +159,13 @@ impl<C> Client<DropContextService<HyperClient, C>, C> where
 
         let client_service = match scheme.as_str() {
             "http" => {
-                HyperClient::Http(hyper::client::Client::builder().build(connector.build()))
+                HyperClient::Http(hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new()).build(connector.build()))
             },
             "https" => {
                 let connector = connector.https()
                    .build()
                    .map_err(ClientInitError::SslError)?;
-                HyperClient::Https(hyper::client::Client::builder().build(connector))
+                HyperClient::Https(hyper_util::client::legacy::Client::builder(hyper_util::rt::TokioExecutor::new()).build(connector))
             },
             _ => {
                 return Err(ClientInitError::InvalidScheme);
@@ -178,7 +182,18 @@ impl<C> Client<DropContextService<HyperClient, C>, C> where
     }
 }
 
-impl<C> Client<DropContextService<hyper::client::Client<hyper::client::HttpConnector, Body>, C>, C> where
+impl<C> Client<
+    DropContextService<
+        hyper_util::service::TowerToHyperService<
+            hyper_util::client::legacy::Client<
+                HttpsConnector,
+                BoxBody<Bytes, Infallible>
+            >
+        >,
+        C
+    >,
+    C
+> where
     C: Clone + Send + Sync + 'static
 {
     /// Create an HTTP client.
@@ -200,7 +215,18 @@ type HttpsConnector = hyper_tls::HttpsConnector<hyper::client::HttpConnector>;
 #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
 type HttpsConnector = hyper_openssl::HttpsConnector<hyper::client::HttpConnector>;
 
-impl<C> Client<DropContextService<hyper::client::Client<HttpsConnector, Body>, C>, C> where
+impl<C> Client<
+    DropContextService<
+        hyper_util::service::TowerToHyperService<
+            hyper_util::client::legacy::Client<
+                HttpsConnector,
+                BoxBody<Bytes, Infallible>
+            >
+        >,
+        C
+    >,
+    C
+> where
     C: Clone + Send + Sync + 'static
 {
     /// Create a client with a TLS connection to the server
@@ -268,8 +294,8 @@ impl<C> Client<DropContextService<hyper::client::Client<HttpsConnector, Body>, C
 
 impl<S, C> Client<S, C> where
     S: Service<
-           (Request<Body>, C),
-           Response=Response<Body>> + Clone + Sync + Send + 'static,
+           (Request<BoxBody<Bytes, Infallible>>, C),
+           Response=Response<Incoming>> + Clone + Sync + Send + 'static,
     S::Future: Send + 'static,
     S::Error: Into<crate::ServiceError> + fmt::Display,
     C: Clone + Send + Sync + 'static
@@ -331,22 +357,19 @@ impl Error for ClientInitError {
     }
 }
 
+fn body_from_string(s: String) -> BoxBody<Bytes, Infallible> {
+    BoxBody::new(Full::new(Bytes::from(s)))
+}
+
 #[async_trait]
 impl<S, C> Api<C> for Client<S, C> where
     S: Service<
-       (Request<Body>, C),
-       Response=Response<Body>> + Clone + Sync + Send + 'static,
+       (Request<BoxBody<Bytes, Infallible>>, C),
+       Response=Response<Incoming>> + Clone + Sync + Send + 'static,
     S::Future: Send + 'static,
     S::Error: Into<crate::ServiceError> + fmt::Display,
     C: Has<XSpanIdString> {{#hasAuthMethods}}+ Has<Option<AuthData>>{{/hasAuthMethods}} + Clone + Send + Sync + 'static,
 {
-    fn poll_ready(&self, cx: &mut Context) -> Poll<Result<(), crate::ServiceError>> {
-        match self.client_service.clone().poll_ready(cx) {
-            Poll::Ready(Err(e)) => Poll::Ready(Err(e.into())),
-            Poll::Ready(Ok(o)) => Poll::Ready(Ok(o)),
-            Poll::Pending => Poll::Pending,
-        }
-    }
 
 {{#apiInfo}}
   {{#apis}}

modules/openapi-generator/src/main/resources/rust-server/client-operation.mustache

@@ -81,7 +81,7 @@
         let mut request = match Request::builder()
             .method("{{{vendorExtensions.x-http-method}}}")
             .uri(uri)
-            .body(Body::empty()) {
+            .body(BoxBody::new(http_body_util::Empty::new())) {
                 Ok(req) => req,
                 Err(e) => return Err(ApiError(format!("Unable to create request: {}", e)))
         };
@@ -208,9 +208,10 @@
 {{/headers}}
 {{#dataType}}
                 let body = response.into_body();
-                let body = body
-                        .into_raw()
-                        .map_err(|e| ApiError(format!("Failed to read response: {}", e))).await?;
+                let body = http_body_util::BodyExt::collect(body)
+                        .await
+                        .map(|f| f.to_bytes().to_vec())
+                        .map_err(|e| ApiError(format!("Failed to read response: {}", e)))?;
 
 {{>client-response-body-instance}}
 
@@ -248,9 +249,9 @@
 {{/responses}}
             code => {
                 let headers = response.headers().clone();
-                let body = response.into_body()
-                       .take(100)
-                       .into_raw().await;
+                let body = http_body_util::BodyExt::collect(response.into_body())
+                        .await
+                        .map(|f| f.to_bytes().to_vec());
                 Err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
                     code,
                     headers,

modules/openapi-generator/src/main/resources/rust-server/client-request-body-instance.mustache

@@ -21,7 +21,7 @@
         });
 
         // Add the message body to the request object.
-        *request.body_mut() = Body::from(body);
+        *request.body_mut() = BoxBody::new(Full::new(Bytes::from(body)));
   {{/x-consumes-multipart-related}}
   {{#x-consumes-form}}
 
@@ -94,7 +94,7 @@
         let body = serde_json::to_string(&param_{{{paramName}}}).expect("impossible to fail to serialize");
         {{/x-consumes-json}}
       {{/vendorExtensions}}
-        *request.body_mut() = Body::from(body);
+        *request.body_mut() = body_from_string(body);
       {{^required}}
         }
       {{/required}}

modules/openapi-generator/src/main/resources/rust-server/client-request-body-multipart-form.mustache

@@ -57,7 +57,7 @@
             (body_string, multipart_header)
         };
 
-        *request.body_mut() = Body::from(body_string);
+        *request.body_mut() = body_from_string(body_string);
 
         request.headers_mut().insert(CONTENT_TYPE, match HeaderValue::from_str(&multipart_header) {
             Ok(h) => h,