[Rust Server] Regenerate samples.

Author: azriel-healthpoint

samples/server/petstore/rust-server/output/multipart-v3/.cargo/config.toml

@@ -0,0 +1,19 @@
+[build]
+rustflags = [
+    "-W", "missing_docs",  # detects missing documentation for public members
+
+    "-W", "trivial_casts",  # detects trivial casts which could be removed
+
+    "-W", "trivial_numeric_casts",  # detects trivial casts of numeric types which could be removed
+
+    # unsafe is used in `TokioIo` bridging code copied from `hyper`.
+    # "-W", "unsafe_code",  # usage of `unsafe` code
+
+    "-W", "unused_qualifications",  # detects unnecessarily qualified names
+
+    "-W", "unused_extern_crates",  # extern crates that are never used
+
+    "-W", "unused_import_braces",  # unnecessary braces around an imported item
+
+    "-D", "warnings", # all warnings should be denied
+]

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

@@ -1,4 +1,4 @@
-.cargo/config
+.cargo/config.toml
 .gitignore
 Cargo.toml
 README.md
@@ -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-rc2", 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))
 }

samples/server/petstore/rust-server/output/multipart-v3/examples/client/main.rs

@@ -9,7 +9,7 @@ use multipart_v3::{Api, ApiNoContext, Claims, Client, ContextWrapperExt, models,
                       MultipartRequestPostResponse,
                       MultipleIdenticalMimeTypesPostResponse,
                      };
-use clap::{App, Arg};
+use clap::{Command, Arg};
 
 // NOTE: Set environment variable RUST_LOG to the name of the executable (or "cargo run") to activate console logging for all loglevels.
 //     See https://docs.rs/env_logger/latest/env_logger/  for more details
@@ -32,27 +32,25 @@ use client_auth::build_token;
 fn main() {
     env_logger::init();
 
-    let matches = App::new("client")
-        .arg(Arg::with_name("operation")
+    let matches = Command::new("client")
+        .arg(Arg::new("operation")
             .help("Sets the operation to run")
-            .possible_values(&[
+            .value_parser([
                 "MultipartRelatedRequestPost",
                 "MultipartRequestPost",
                 "MultipleIdenticalMimeTypesPost",
             ])
             .required(true)
             .index(1))
-        .arg(Arg::with_name("https")
+        .arg(Arg::new("https")
             .long("https")
             .help("Whether to use HTTPS or not"))
-        .arg(Arg::with_name("host")
+        .arg(Arg::new("host")
             .long("host")
-            .takes_value(true)
             .default_value("localhost")
             .help("Hostname to contact"))
-        .arg(Arg::with_name("port")
+        .arg(Arg::new("port")
             .long("port")
-            .takes_value(true)
             .default_value("8080")
             .help("Port to contact"))
         .get_matches();
@@ -76,22 +74,22 @@ fn main() {
             b"secret").unwrap();
 
     let auth_data = if !auth_token.is_empty() {
-        Some(AuthData::Bearer(swagger::auth::Bearer { token: auth_token}))
+        Some(AuthData::Bearer(auth_token))
     } else {
         // No Bearer-token available, so return None
         None
     };
 
-    let is_https = matches.is_present("https");
+    let is_https = matches.contains_id("https");
     let base_url = format!("{}://{}:{}",
         if is_https { "https" } else { "http" },
-        matches.value_of("host").unwrap(),
-        matches.value_of("port").unwrap());
+        matches.get_one::<String>("host").unwrap(),
+        matches.get_one::<u16>("port").unwrap());
 
     let context: ClientContext =
         swagger::make_context!(ContextBuilder, EmptyContext, auth_data, XSpanIdString::default());
 
-    let mut client : Box<dyn ApiNoContext<ClientContext>> = if matches.is_present("https") {
+    let mut client : Box<dyn ApiNoContext<ClientContext>> = if is_https {
         // Using Simple HTTPS
         let client = Box::new(Client::try_new_https(&base_url)
             .expect("Failed to create HTTPS client"));
@@ -106,7 +104,7 @@ fn main() {
 
     let mut rt = tokio::runtime::Runtime::new().unwrap();
 
-    match matches.value_of("operation") {
+    match matches.get_one::<String>("operation") {
         Some("MultipartRelatedRequestPost") => {
             let result = rt.block_on(client.multipart_related_request_post(
                   swagger::ByteArray(Vec::from("BINARY_DATA_HERE")),

samples/server/petstore/rust-server/output/multipart-v3/examples/server/main.rs

@@ -3,26 +3,27 @@
 
 #![allow(missing_docs)]
 
-
-use clap::{App, Arg};
+use clap::{Arg, Command};
 
 mod server;
 mod server_auth;
-
+mod tokio_io;
 
 /// Create custom server, wire it to the autogenerated router,
 /// and pass it to the web server.
 #[tokio::main]
 async fn main() {
     env_logger::init();
 
-    let matches = App::new("server")
-        .arg(Arg::with_name("https")
-            .long("https")
-            .help("Whether to use HTTPS or not"))
+    let matches = Command::new("server")
+        .arg(
+            Arg::new("https")
+                .long("https")
+                .help("Whether to use HTTPS or not"),
+        )
         .get_matches();
 
     let addr = "127.0.0.1:8080";
 
-    server::create(addr, matches.is_present("https")).await;
+    server::create(addr, matches.contains_id("https")).await;
 }