[rust-server] asynchronous support via hyper v0.11 (#7896)

* End use of deprecated openssl method

* Enhance rust-server to use hyper 0.11 to support handling operations asynchronously

The changes are complete and working (at least for microservices tested within Metaswitch).  This isn't completely compatible with the (previous/current) synchronous swagger-codegen.  Specifically,

*   `Client` is no longer `Send + Sync`
*   Api implementations used by Server are no longer expected to be `Send + Sync` (which is good, because it's quite hard if `Client` isn't)
*   the code to create `Client`s and `Server`s, and hook them into `hyper` or `tokio` is different.

Importantly, though, the business logic itself should be unchanged.

* Re-adds the `basePath` element to all server endpoints. This mean clients and servers can talk to each other again.

* Fix multipart formdata codegen

* Fix up handling of multipart messages
* Fix server -> client multipart message response
* Correct handling of optional file types

* Add authorization header to requests with basic auth

* Add client support for `application/x-www-form-urlencoded`

* Import uuid library if headers use UUID type

* Add BASE_PATH to the server module.

* Wrap client connector

* Support both query and body parameters on the same operation

Author: bjgill

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/RustServerCodegen.java

@@ -34,6 +34,7 @@ public class RustServerCodegen extends DefaultCodegen implements CodegenConfig {
     protected String packageName;
     protected String packageVersion;
     protected String externCrateName;
+    protected Map<String, Map<String, String>> pathSetMap = new HashMap<String, Map<String, String>>();
 
     public RustServerCodegen() {
         super();
@@ -155,8 +156,9 @@ public RustServerCodegen() {
         supportingFiles.add(new SupportingFile("gitignore", "", ".gitignore"));
         supportingFiles.add(new SupportingFile("lib.mustache", "src", "lib.rs"));
         supportingFiles.add(new SupportingFile("models.mustache", "src", "models.rs"));
-        supportingFiles.add(new SupportingFile("server.mustache", "src", "server.rs"));
-        supportingFiles.add(new SupportingFile("client.mustache", "src", "client.rs"));
+        supportingFiles.add(new SupportingFile("server-mod.mustache", "src/server", "mod.rs"));
+        supportingFiles.add(new SupportingFile("server-auth.mustache", "src/server", "auth.rs"));
+        supportingFiles.add(new SupportingFile("client-mod.mustache", "src/client", "mod.rs"));
         supportingFiles.add(new SupportingFile("mimetypes.mustache", "src", "mimetypes.rs"));
         supportingFiles.add(new SupportingFile("example-server.mustache", "examples", "server.rs"));
         supportingFiles.add(new SupportingFile("example-client.mustache", "examples", "client.rs"));
@@ -448,75 +450,58 @@ boolean isMimetypePlainText(String mimetype) {
         return mimetype.toLowerCase().startsWith("text/plain");
     }
 
+    boolean isMimetypeWwwFormUrlEncoded(String mimetype) {
+        return mimetype.toLowerCase().startsWith("application/x-www-form-urlencoded");
+    }
+
     @Override
     public CodegenOperation fromOperation(String path, String httpMethod, Operation operation, Map<String, Model> definitions, Swagger swagger) {
         CodegenOperation op = super.fromOperation(path, httpMethod, operation, definitions, swagger);
+
+        // The Rust code will need to contain a series of regular expressions.
+        // For performance, we'll construct these at start-of-day and re-use
+        // them.  That means we need labels for them.
+        //
+        // Construct a Rust constant (uppercase) token name, and ensure it's
+        // unique using a numeric tie-breaker if required.
+        String basePathId = sanitizeName(op.path.replace("/", "_").replace("{", "").replace("}", "").replaceAll("^_", "")).toUpperCase();
+        String pathId = basePathId;
+        int pathIdTiebreaker = 2;
+        boolean found = false;
+        while (pathSetMap.containsKey(pathId)) {
+            Map<String, String> pathSetEntry = pathSetMap.get(pathId);
+            if (pathSetEntry.get("path").equals(op.path)) {
+                found = true;
+                break;
+            }
+            pathId = basePathId + pathIdTiebreaker;
+            pathIdTiebreaker++;
+        }
+
+        // Save off the regular expression and path details in the
+        // "pathSetMap", which we'll add to the source document that will be
+        // processed by the templates.
+        if (!found) {
+            Map<String, String> pathSetEntry = new HashMap<String, String>();
+            pathSetEntry.put("path", op.path);
+            pathSetEntry.put("PATH_ID", pathId);
+            if (!op.pathParams.isEmpty()) {
+                pathSetEntry.put("hasPathParams", "true");
+            }
+            // Don't prefix with '^' so that the templates can put the
+            // basePath on the front.
+            pathSetEntry.put("pathRegEx", op.path.replace("{", "(?P<").replace("}", ">[^/?#]*)") + "$");
+            pathSetMap.put(pathId, pathSetEntry);
+        }
+
         op.vendorExtensions.put("operation_id", underscore(op.operationId));
         op.vendorExtensions.put("uppercase_operation_id", underscore(op.operationId).toUpperCase());
         op.vendorExtensions.put("path", op.path.replace("{", ":").replace("}", ""));
+        op.vendorExtensions.put("PATH_ID", pathId);
+        op.vendorExtensions.put("hasPathParams", !op.pathParams.isEmpty());
         op.vendorExtensions.put("HttpMethod", Character.toUpperCase(op.httpMethod.charAt(0)) + op.httpMethod.substring(1).toLowerCase());
-        op.vendorExtensions.put("httpmethod", op.httpMethod.toLowerCase());
         for (CodegenParameter param : op.allParams) {
-            String example = null;
-
-            if (param.isString) {
-                if (param.dataFormat != null && param.dataFormat.equals("byte")) {
-                    param.vendorExtensions.put("formatString", "\\\"{:?}\\\"");
-                    example = "swagger::ByteArray(\"" + ((param.example != null) ? param.example : "") + "\".to_string().into_bytes())";
-                } else {
-                    param.vendorExtensions.put("formatString", "\\\"{}\\\"");
-                    example = "\"" + ((param.example != null) ? param.example : "") + "\".to_string()";
-                }
-            } else if (param.isPrimitiveType) {
-                if ((param.isByteArray) ||
-                    (param.isBinary)) {
-                    // Binary primitive types don't implement `Display`.
-                    param.vendorExtensions.put("formatString", "{:?}");
-                    example = "swagger::ByteArray(Vec::from(\"" + ((param.example != null) ? param.example : "") + "\"))";
-                } else {
-                    param.vendorExtensions.put("formatString", "{}");
-                    example = (param.example != null) ? param.example : "";
-                }
-            } else if (param.isListContainer) {
-                param.vendorExtensions.put("formatString", "{:?}");
-                example = (param.example != null) ? param.example : "&Vec::new()";
-            } else if (param.isFile) {
-                param.vendorExtensions.put("formatString", "{:?}");
-                op.vendorExtensions.put("hasFile", true);
-                additionalProperties.put("apiHasFile", true);
-                example = "Box::new(stream::once(Ok(b\"hello\".to_vec()))) as Box<Stream<Item=_, Error=_> + Send>";
-            } else {
-                param.vendorExtensions.put("formatString", "{:?}");
-                if (param.example != null) {
-                    example = "serde_json::from_str::<" + param.dataType + ">(\"" + param.example + "\").expect(\"Failed to parse JSON example\")";
-                }
-            }
-
-            if (param.required) {
-                if (example != null) {
-                    param.vendorExtensions.put("example", example);
-                } else if (param.isListContainer) {
-                    // Use the empty list if we don't have an example
-                    param.vendorExtensions.put("example", "&Vec::new()");
-                }
-                else {
-                    // If we don't have an example that we can provide, we need to disable the client example, as it won't build.
-                    param.vendorExtensions.put("example", "???");
-                    op.vendorExtensions.put("noClientExample", Boolean.TRUE);
-                }
-            } else if ((param.dataFormat != null)&&((param.dataFormat.equals("date-time")) || (param.dataFormat.equals("date")))) {
-                param.vendorExtensions.put("formatString", "{:?}");
-                param.vendorExtensions.put("example", "None");
-            } else {
-                // Not required, so override the format string and example
-                param.vendorExtensions.put("formatString", "{:?}");
-                if (param.isFile) {
-                    // Optional file types are wrapped in a future
-                    param.vendorExtensions.put("example", (example != null) ? "Box::new(future::ok(Some(" + example + "))) as Box<Future<Item=_, Error=_> + Send>" : "None");
-                } else {
-                    param.vendorExtensions.put("example", (example != null) ? "Some(" + example + ")" : "None");
-                }
-            }
+            processParam(param, op);
         }
 
         List<String> consumes = new ArrayList<String>();
@@ -544,6 +529,8 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
                     consumesXml = true;
                 } else if (isMimetypePlainText(mimeType)) {
                     consumesPlainText = true;
+                } else if (isMimetypeWwwFormUrlEncoded(mimeType)) {
+                    additionalProperties.put("usesUrlEncodedForm", true);
                 }
 
                 mediaType.put("mediaType", mimeType);
@@ -587,7 +574,6 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
         }
 
         if (op.bodyParam != null) {
-
             if (paramHasXmlNamespace(op.bodyParam, definitions)){
                 op.bodyParam.vendorExtensions.put("has_namespace", "true");
             }
@@ -607,6 +593,7 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
 
         }
         for (CodegenParameter param : op.bodyParams) {
+            processParam(param, op);
 
             if (paramHasXmlNamespace(param, definitions)){
                 param.vendorExtensions.put("has_namespace", "true");
@@ -624,9 +611,18 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
             }
         }
         for (CodegenParameter param : op.headerParams) {
+            // If a header uses UUIDs, we need to import the UUID package.
+            if (param.dataType.equals("uuid::Uuid")) {
+                additionalProperties.put("apiUsesUuid", true);
+            }
+            processParam(param, op);
+
             // Give header params a name in camel case. CodegenParameters don't have a nameInCamelCase property.
             param.vendorExtensions.put("typeName", toModelName(param.baseName));
         }
+        for (CodegenParameter param : op.formParams) {
+            processParam(param, op);
+        }
         for (CodegenResponse rsp : op.responses) {
             String[] words = rsp.message.split("[^A-Za-z ]");
             String responseId;
@@ -673,10 +669,16 @@ public CodegenOperation fromOperation(String path, String httpMethod, Operation
                 }
             }
             for (CodegenProperty header : rsp.headers) {
+                if (header.datatype.equals("uuid::Uuid")) {
+                    additionalProperties.put("apiUsesUuid", true);
+                }
                 header.nameInCamelCase = toModelName(header.baseName);
             }
         }
         for (CodegenProperty header : op.responseHeaders) {
+            if (header.datatype.equals("uuid::Uuid")) {
+                    additionalProperties.put("apiUsesUuid", true);
+            }
             header.nameInCamelCase = toModelName(header.baseName);
         }
 
@@ -860,6 +862,27 @@ public Map<String, Object> postProcessSupportingFileData(Map<String, Object> obj
                 LOGGER.error(e.getMessage(), e);
             }
         }
+
+        // We previously built a mapping from path to path ID and regular
+        // expression - see fromOperation for details.  Sort it and add an
+        // index, and then add it to the objects that we're about to pass to
+        // the templates to process.
+        List<Map.Entry<String, Map<String, String>>> pathSetEntryList = new ArrayList(pathSetMap.entrySet());
+        Collections.sort(pathSetEntryList, new Comparator<Map.Entry<String, Map<String, String>>>() {
+            public int compare(Map.Entry<String, Map<String, String>> a, Map.Entry<String, Map<String, String>> b) {
+                return a.getValue().get("path").compareTo(b.getValue().get("path"));
+            }
+        });
+        List pathSet = new ArrayList<Map<String, String>>();
+        int index = 0;
+        for (Map.Entry<String, Map<String, String>> pathSetEntry : pathSetEntryList) {
+            Map<String, String> pathSetEntryValue = pathSetEntry.getValue();
+            pathSetEntryValue.put("index", Integer.toString(index));
+            index++;
+            pathSet.add(pathSetEntryValue);
+        }
+        objs.put("pathSet", pathSet);
+
         return super.postProcessSupportingFileData(objs);
     }
 
@@ -1029,4 +1052,67 @@ private boolean paramHasXmlNamespace(CodegenParameter param, Map<String, Model>
         }
         return false;
     }
+
+    private void processParam(CodegenParameter param, CodegenOperation op) {
+        String example = null;
+
+        if (param.isString) {
+            if (param.dataFormat != null && param.dataFormat.equals("byte")) {
+                param.vendorExtensions.put("formatString", "\\\"{:?}\\\"");
+                example = "swagger::ByteArray(\"" + ((param.example != null) ? param.example : "") + "\".to_string().into_bytes())";
+            } else {
+                param.vendorExtensions.put("formatString", "\\\"{}\\\"");
+                example = "\"" + ((param.example != null) ? param.example : "") + "\".to_string()";
+            }
+        } else if (param.isPrimitiveType) {
+            if ((param.isByteArray) ||
+                (param.isBinary)) {
+                // Binary primitive types don't implement `Display`.
+                param.vendorExtensions.put("formatString", "{:?}");
+                example = "swagger::ByteArray(Vec::from(\"" + ((param.example != null) ? param.example : "") + "\"))";
+            } else {
+                param.vendorExtensions.put("formatString", "{}");
+                example = (param.example != null) ? param.example : "";
+            }
+        } else if (param.isListContainer) {
+            param.vendorExtensions.put("formatString", "{:?}");
+            example = (param.example != null) ? param.example : "&Vec::new()";
+        } else if (param.isFile) {
+            param.vendorExtensions.put("formatString", "{:?}");
+            op.vendorExtensions.put("hasFile", true);
+            additionalProperties.put("apiHasFile", true);
+            example = "Box::new(stream::once(Ok(b\"hello\".to_vec()))) as Box<Stream<Item=_, Error=_> + Send>";
+        } else {
+            param.vendorExtensions.put("formatString", "{:?}");
+            if (param.example != null) {
+                example = "serde_json::from_str::<" + param.dataType + ">(\"" + param.example + "\").expect(\"Failed to parse JSON example\")";
+            }
+        }
+
+        if (param.required) {
+            if (example != null) {
+                param.vendorExtensions.put("example", example);
+            } else if (param.isListContainer) {
+                // Use the empty list if we don't have an example
+                param.vendorExtensions.put("example", "&Vec::new()");
+            }
+            else {
+                // If we don't have an example that we can provide, we need to disable the client example, as it won't build.
+                param.vendorExtensions.put("example", "???");
+                op.vendorExtensions.put("noClientExample", Boolean.TRUE);
+            }
+        } else if ((param.dataFormat != null)&&((param.dataFormat.equals("date-time")) || (param.dataFormat.equals("date")))) {
+            param.vendorExtensions.put("formatString", "{:?}");
+            param.vendorExtensions.put("example", "None");
+        } else {
+            // Not required, so override the format string and example
+            param.vendorExtensions.put("formatString", "{:?}");
+            if (param.isFile) {
+                // Optional file types are wrapped in a future
+                param.vendorExtensions.put("example", (example != null) ? "Box::new(future::ok(Some(" + example + "))) as Box<Future<Item=_, Error=_> + Send>" : "None");
+            } else {
+                param.vendorExtensions.put("example", (example != null) ? "Some(" + example + ")" : "None");
+            }
+        }
+    }
 }

modules/swagger-codegen/src/main/resources/rust-server/Cargo.mustache

@@ -9,32 +9,37 @@ license = "Unlicense"
 
 [features]
 default = ["client", "server"]
-client = ["serde_json", {{#usesXml}}"serde-xml-rs", {{/usesXml}}"serde_ignored", "hyper", "hyper-openssl", "uuid"{{#apiHasFile}}, "multipart"{{/apiHasFile}}]
-server = ["serde_json", {{#usesXml}}"serde-xml-rs", {{/usesXml}}"serde_ignored", "hyper", "iron", "router", "bodyparser", "urlencoded", "uuid"{{#apiHasFile}}, "multipart"{{/apiHasFile}}]
+client = ["serde_json", {{#usesUrlEncodedForm}}"serde_urlencoded", {{/usesUrlEncodedForm}} {{#usesXml}}"serde-xml-rs", {{/usesXml}}"serde_ignored", "hyper", "hyper-tls", "native-tls", "openssl", "tokio-core", "url", "uuid"{{#apiHasFile}}, "multipart"{{/apiHasFile}}]
+server = ["serde_json", {{#usesXml}}"serde-xml-rs", {{/usesXml}}"serde_ignored", "hyper", "hyper-tls", "native-tls", "openssl", "tokio-core", "tokio-proto", "tokio-tls", "regex", "percent-encoding", "url", "uuid"{{#apiHasFile}}, "multipart"{{/apiHasFile}}]
 
 [dependencies]
 # Required by example server.
 #
 chrono = { version = "0.4", features = ["serde"] }
 futures = "0.1"
-hyper = {version = "0.10", optional = true}
-hyper-openssl = {version = "0.2", optional = true }
-iron = {version = "0.5", optional = true}
-swagger = "0.7"
+hyper = {version = "0.11", optional = true}
+hyper-tls = {version = "0.1.2", optional = true}
+swagger = "0.9"
 
 # Not required by example server.
 #
-bodyparser = {version = "0.7", optional = true}
-url = "1.5"
 lazy_static = "0.2"
 log = "0.3.0"
-multipart = {version = "0.13", optional = true}
-router = {version = "0.5", optional = true}
+mime = "0.3.3"
+multipart = {version = "0.13.3", optional = true}
+native-tls = {version = "0.1.4", optional = true}
+openssl = {version = "0.9.14", optional = true}
+percent-encoding = {version = "1.0.0", optional = true}
+regex = {version = "0.2", optional = true}
 serde = "1.0"
 serde_derive = "1.0"
 serde_ignored = {version = "0.0.4", optional = true}
 serde_json = {version = "1.0", optional = true}
-urlencoded = {version = "0.5", optional = true}
+serde_urlencoded = {version = "0.5.1", optional = true}
+tokio-core = {version = "0.1.6", optional = true}
+tokio-proto = {version = "0.1.1", optional = true}
+tokio-tls = {version = "0.1.3", optional = true, features = ["tokio-proto"]}
+url = {version = "1.5", optional = true}
 uuid = {version = "0.5", optional = true, features = ["serde", "v4"]}
 # ToDo: this should be updated to point at the official crate once
 # https://github.com/RReverser/serde-xml-rs/pull/45 is accepted upstream