Revert changes to use typed auth in rust-server. Run sample generation.

Author: dsteeley

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::AuthData};
+use swagger::{ApiError, auth::{Basic, Bearer}};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Claims {
@@ -17,13 +17,13 @@ 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: &str) -> Result<Authorization, ApiError>;
+    fn bearer_authorization(&self, token: &Bearer) -> 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, username: &str, password: &str) -> Result<Authorization, ApiError>;
+    fn basic_authorization(&self, basic: &Basic) -> Result<Authorization, ApiError>;
 }
 
 // Implement it for AllowAllAuthenticator (dummy is needed, but should not used as we have Bearer authorization)
@@ -46,7 +46,7 @@ where
     RC::Result: Send + 'static {
 
     /// Get method to map Bearer-token to an Authorization
-    fn bearer_authorization(&self, _token: &str) -> Result<Authorization, ApiError> {
+    fn bearer_authorization(&self, _token: &Bearer) -> Result<Authorization, ApiError> {
         Ok(dummy_authorization())
     }
 
@@ -56,7 +56,7 @@ where
     }
 
     /// Get method to map basic token to an Authorization
-    fn basic_authorization(&self, _username: &str, _password: &str) -> Result<Authorization, ApiError> {
+    fn basic_authorization(&self, _basic: &Basic) -> Result<Authorization, ApiError> {
         Ok(dummy_authorization())
     }
 }

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

@@ -1,5 +1,6 @@
 use swagger::{
     ApiError,
+    auth::{Basic, Bearer},
     Has,
     XSpanIdString};
 use {{{externCrateName}}}::{AuthenticationApi, Claims};
@@ -94,10 +95,10 @@ fn get_jwt_error_string(error: JwtError::Error) -> String {
 impl<C> AuthenticationApi for Server<C> where C: Has<XSpanIdString> + Send + Sync {
 
     /// Implementation of the method to map a Bearer-token to an Authorization
-    fn bearer_authorization(&self, token: &str) -> Result<Authorization, ApiError> {
+    fn bearer_authorization(&self, bearer: &Bearer) -> Result<Authorization, ApiError> {
         debug!("\tAuthorizationApi: Received Bearer-token, {token:#?}");
 
-        match extract_token_data(token, b"secret") {
+        match extract_token_data(&bearer.token, b"secret") {
             Ok(auth_data) => {
                 debug!("\tUnpack auth_data as: {auth_data:#?}");
                 let authorization = build_authorization(auth_data.claims);
@@ -123,8 +124,8 @@ impl<C> AuthenticationApi for Server<C> where C: Has<XSpanIdString> + Send + Syn
     }
 
     /// Implementation of the method to map a basic authentication (username and password) to an Authorization
-    fn basic_authorization(&self, username: &str, _password: &str) -> Result<Authorization, ApiError> {
-        debug!("\tAuthorizationApi: Received Basic-token, {username}");
+    fn basic_authorization(&self, basic: &Basic) -> Result<Authorization, ApiError> {
+        debug!("\tAuthorizationApi: Received Basic-token, {basic:#?}");
 
         // TODO: insert the logic to map received apikey to the set of claims
         let claims = full_permission_claim();

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

@@ -3,6 +3,7 @@ use crate::{Api, AuthenticationApi};
 use swagger::{
     ApiError,
     Authorization,
+    auth::{Basic, Bearer},
     Has,
     XSpanIdString
 };
@@ -12,17 +13,17 @@ T: Api<C> + Clone + Send + 'static + AuthenticationApi,
 C: Has<XSpanIdString> + Has<Option<Authorization>> + Send + Sync + 'static {
 
     /// Passthrough of the task to the api-implementation
-    fn bearer_authorization(&self, token: &str) -> Result<Authorization, ApiError> {
+    fn bearer_authorization(&self, token: &Bearer) -> Result<Authorization, ApiError> {
         self.api_impl.bearer_authorization(token)
     }
 
     /// Passthrough of the task to the api-implementation
-    fn apikey_authorization(&self, token: &str) -> Result<Authorization, ApiError> {
+    fn apikey_authorization(&self, token: &Bearer) -> Result<Authorization, ApiError> {
         self.api_impl.apikey_authorization(token)
     }
 
     /// Passthrough of the task to the api-implementation
-    fn basic_authorization(&self, username: &str, password: &str) -> Result<Authorization, ApiError> {
+    fn basic_authorization(&self, basic: &Basic) -> Result<Authorization, ApiError> {
         self.api_impl.basic_authorization(username, password)
     }
 }

samples/server/petstore/rust-server/output/multipart-v3/.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
 

samples/server/petstore/rust-server/output/multipart-v3/.openapi-generator/FILES

@@ -16,6 +16,7 @@ examples/server-key.pem
 examples/server/main.rs
 examples/server/server.rs
 examples/server/server_auth.rs
+examples/server/tokio_io.rs
 src/auth.rs
 src/client/mod.rs
 src/context.rs

samples/server/petstore/rust-server/output/multipart-v3/Cargo.toml

@@ -13,7 +13,7 @@ client = [
     "mime_0_2",
     "multipart", "multipart/client", "swagger/multipart_form",
     "hyper_0_10", "mime_multipart", "swagger/multipart_related",
-    "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 = [
     "mime_0_2",
@@ -22,71 +22,76 @@ server = [
    "serde_ignored", "hyper", "regex", "percent-encoding", "url", "lazy_static"
 ]
 cli = [
-  "anyhow", "clap-verbosity-flag", "simple_logger", "structopt", "tokio"
+  "anyhow", "clap", "clap-verbosity-flag", "simple_logger", "tokio"
 ]
 conversion = ["frunk", "frunk_derives", "frunk_core", "frunk-enum-core", "frunk-enum-derive"]
 
 [target.'cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))'.dependencies]
 native-tls = { version = "0.2", optional = true }
-hyper-tls = { version = "0.5", optional = true }
+hyper-tls = { version = "0.6", optional = true }
 
 [target.'cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))'.dependencies]
-hyper-openssl = { version = "0.9", optional = true }
-openssl = {version = "0.10", optional = true }
+hyper-openssl = { version = "0.10", optional = true }
+openssl = { version = "0.10", optional = true }
 
 [dependencies]
 # Common
-async-trait = "0.1.24"
+async-trait = "0.1.88"
 chrono = { version = "0.4", features = ["serde"] }
 futures = "0.3"
-swagger = { version = "6.1", features = ["serdejson", "server", "client", "tls", "tcp"] }
-log = "0.4.0"
+swagger = { version = "7.0.0-rc1", features = ["serdejson", "server", "client", "tls"] }
+log = "0.4.27"
 mime = "0.3"
 
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-validator = { version = "0.16", features = ["derive"] }
+validator = { version = "0.20", features = ["derive"] }
 
 # Crates included if required by the API definition
 mime_0_2 = { package = "mime", version = "0.2.6", optional = true }
 multipart = { version = "0.16", default-features = false, optional = true }
 
 # Common between server and client features
-hyper = {version = "0.14", features = ["full"], optional = true}
-mime_multipart = {version = "0.5", optional = true}
-hyper_0_10 = {package = "hyper", version = "0.10", default-features = false, optional=true}
-serde_ignored = {version = "0.1.1", optional = true}
-url = {version = "2.1", optional = true}
+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"] }
+mime_multipart = { version = "0.5", optional = true }
+hyper_0_10 = {package = "hyper", version = "0.10", default-features = false, optional=true }
+serde_ignored = { version = "0.1.12", optional = true }
+url = { version = "2.5", optional = true }
 
 # Client-specific
+tower-service = "0.3.3"
 
 # Server, and client callback-specific
-lazy_static = { version = "1.4", optional = true }
-percent-encoding = {version = "2.1.0", optional = true}
-regex = {version = "1.3", optional = true}
+lazy_static = { version = "1.5", optional = true }
+percent-encoding = { version = "2.3.1", optional = true }
+regex = { version = "1.11", optional = true }
 
 # CLI-specific
 anyhow = { version = "1", optional = true }
-clap-verbosity-flag = { version = "0.3", optional = true }
-simple_logger = { version = "2.0", features = ["stderr"], optional = true }
-structopt = { version = "0.3", optional = true }
-tokio = { version = "0.2", features = ["rt-threaded", "macros", "stream"], optional = true }
+clap-verbosity-flag = { version = "3.0", optional = true }
+simple_logger = { version = "5.0", features = ["stderr"], optional = true }
+tokio = { version = "1.45", features = ["rt-multi-thread", "macros"], optional = true }
 
 # Conversion
-frunk = { version = "0.4.0", optional = true }
-frunk_derives = { version = "0.4.0", optional = true }
-frunk_core = { version = "0.4.0", optional = true }
+frunk = { version = "0.4.3", optional = true }
+frunk_derives = { version = "0.4.3", optional = true }
+frunk_core = { version = "0.4.3", optional = true }
 frunk-enum-derive = { version = "0.3.0", optional = true }
 frunk-enum-core = { version = "0.3.0", optional = true }
 
 # Bearer authentication
-jsonwebtoken = { version = "9.3.0", optional = false }
+jsonwebtoken = { version = "9.3.1", optional = false }
 
 [dev-dependencies]
-clap = "2.25"
+always_send = "0.1.1"
+clap = "4.5"
 env_logger = "0.11"
-tokio = { version = "1.14", features = ["full"] }
+tokio = { version = "1.45", features = ["full"] }
 native-tls = "0.2"
+pin-project = "1.1.10"
 
 [target.'cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))'.dev-dependencies]
 tokio-openssl = "0.6"

samples/server/petstore/rust-server/output/multipart-v3/bin/cli.rs

@@ -1,5 +1,6 @@
 //! CLI tool driving the API client
 use anyhow::{anyhow, Context, Result};
+use clap::Parser;
 use log::{debug, info};
 // models may be unused if all inputs are primitive types
 #[allow(unused_imports)]
@@ -10,7 +11,6 @@ use multipart_v3::{
     MultipleIdenticalMimeTypesPostResponse,
 };
 use simple_logger::SimpleLogger;
-use structopt::StructOpt;
 use swagger::{AuthData, ContextBuilder, EmptyContext, Push, XSpanIdString};
 
 type ClientContext = swagger::make_context_ty!(
@@ -20,65 +20,65 @@ type ClientContext = swagger::make_context_ty!(
     XSpanIdString
 );
 
-#[derive(StructOpt, Debug)]
-#[structopt(
+#[derive(Parser, Debug)]
+#[clap(
     name = "Multipart OpenAPI V3 Rust Server Test",
     version = "1.0.7",
     about = "CLI access to Multipart OpenAPI V3 Rust Server Test"
 )]
 struct Cli {
-    #[structopt(subcommand)]
+    #[clap(subcommand)]
     operation: Operation,
 
     /// Address or hostname of the server hosting this API, including optional port
-    #[structopt(short = "a", long, default_value = "http://localhost")]
+    #[clap(short = 'a', long, default_value = "http://localhost")]
     server_address: String,
 
     /// Path to the client private key if using client-side TLS authentication
     #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-    #[structopt(long, requires_all(&["client-certificate", "server-certificate"]))]
+    #[clap(long, requires_all(&["client-certificate", "server-certificate"]))]
     client_key: Option<String>,
 
     /// Path to the client's public certificate associated with the private key
     #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-    #[structopt(long, requires_all(&["client-key", "server-certificate"]))]
+    #[clap(long, requires_all(&["client-key", "server-certificate"]))]
     client_certificate: Option<String>,
 
     /// Path to CA certificate used to authenticate the server
     #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
-    #[structopt(long)]
+    #[clap(long)]
     server_certificate: Option<String>,
 
     /// If set, write output to file instead of stdout
-    #[structopt(short, long)]
+    #[clap(short, long)]
     output_file: Option<String>,
 
-    #[structopt(flatten)]
+    #[command(flatten)]
     verbosity: clap_verbosity_flag::Verbosity,
 }
 
-#[derive(StructOpt, Debug)]
+#[derive(Parser, Debug)]
 enum Operation {
     MultipartRelatedRequestPost {
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<swagger::ByteArray>)]
         required_binary_field: swagger::ByteArray,
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<models::MultipartRequestObjectField>)]
         object_field: Option<models::MultipartRequestObjectField>,
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<swagger::ByteArray>)]
         optional_binary_field: Option<swagger::ByteArray>,
     },
     MultipartRequestPost {
         string_field: String,
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<swagger::ByteArray>)]
         binary_field: swagger::ByteArray,
         optional_string_field: Option<String>,
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<models::MultipartRequestObjectField>)]
         object_field: Option<models::MultipartRequestObjectField>,
     },
     MultipleIdenticalMimeTypesPost {
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<swagger::ByteArray>)]
         binary1: Option<swagger::ByteArray>,
-        #[structopt(parse(try_from_str = parse_json))]
+        #[clap(value_parser = parse_json::<swagger::ByteArray>)]
         binary2: Option<swagger::ByteArray>,
     },
 }
@@ -118,7 +118,7 @@ fn create_client(args: &Cli, context: ClientContext) -> Result<Box<dyn ApiNoCont
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    let args = Cli::from_args();
+    let args = Cli::parse();
     if let Some(log_level) = args.verbosity.log_level() {
         SimpleLogger::new().with_level(log_level.to_level_filter()).init()?;
     }
@@ -210,6 +210,6 @@ async fn main() -> Result<()> {
 
 // May be unused if all inputs are primitive types
 #[allow(dead_code)]
-fn parse_json<'a, T: serde::de::Deserialize<'a>>(json_string: &'a str) -> Result<T> {
+fn parse_json<T: serde::de::DeserializeOwned>(json_string: &str) -> Result<T> {
     serde_json::from_str(json_string).map_err(|err| anyhow!("Error parsing input: {}", err))
 }