forked from loafle/openapi-generator-original
Merge branch 'master' into oas3_support2
This commit is contained in:
wing328
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,50 @@
|
||||
[package]
|
||||
name = "{{packageName}}"
|
||||
version = "{{appVersion}}"
|
||||
authors = [{{#infoEmail}}"{{infoEmail}}"{{/infoEmail}}]
|
||||
{{#appDescription}}
|
||||
description = "{{{appDescription}}}"
|
||||
{{/appDescription}}
|
||||
license = "Unlicense"
|
||||
|
||||
[features]
|
||||
default = ["client", "server"]
|
||||
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.11", optional = true}
|
||||
hyper-tls = {version = "0.1.2", optional = true}
|
||||
swagger = "0.9"
|
||||
|
||||
# Not required by example server.
|
||||
#
|
||||
lazy_static = "0.2"
|
||||
log = "0.3.0"
|
||||
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}
|
||||
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
|
||||
{{#usesXml}}serde-xml-rs = {git = "git://github.com/Metaswitch/serde-xml-rs.git" , branch = "master", optional = true}{{/usesXml}}
|
||||
|
||||
[dev-dependencies]
|
||||
clap = "2.25"
|
||||
error-chain = "0.11"
|
||||
@@ -0,0 +1,437 @@
|
||||
#![allow(unused_extern_crates)]
|
||||
extern crate tokio_core;
|
||||
extern crate native_tls;
|
||||
extern crate hyper_tls;
|
||||
extern crate openssl;
|
||||
extern crate mime;
|
||||
extern crate chrono;
|
||||
extern crate url;
|
||||
{{#apiHasFile}}extern crate multipart;{{/apiHasFile}}
|
||||
{{#usesUrlEncodedForm}}extern crate serde_urlencoded;{{/usesUrlEncodedForm}}
|
||||
|
||||
{{#apiUsesUuid}}use uuid;{{/apiUsesUuid}}
|
||||
{{#apiHasFile}}use self::multipart::client::lazy::Multipart;{{/apiHasFile}}
|
||||
use hyper;
|
||||
use hyper::header::{Headers, ContentType};
|
||||
use hyper::Uri;
|
||||
use self::url::percent_encoding::{utf8_percent_encode, PATH_SEGMENT_ENCODE_SET, QUERY_ENCODE_SET};
|
||||
use futures;
|
||||
use futures::{Future, Stream};
|
||||
use futures::{future, stream};
|
||||
use self::tokio_core::reactor::Handle;
|
||||
use std::borrow::Cow;
|
||||
use std::io::{Read, Error, ErrorKind};
|
||||
use std::error;
|
||||
use std::fmt;
|
||||
use std::path::Path;
|
||||
use std::sync::Arc;
|
||||
use std::str;
|
||||
use std::str::FromStr;
|
||||
|
||||
use mimetypes;
|
||||
|
||||
use serde_json;
|
||||
{{#usesXml}}use serde_xml_rs;{{/usesXml}}
|
||||
|
||||
#[allow(unused_imports)]
|
||||
use std::collections::{HashMap, BTreeMap};
|
||||
#[allow(unused_imports)]
|
||||
use swagger;
|
||||
|
||||
use swagger::{Context, ApiError, XSpanId};
|
||||
|
||||
use {Api{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}},
|
||||
{{operationId}}Response{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
};
|
||||
use models;
|
||||
|
||||
/// Convert input into a base path, e.g. "http://example:123". Also checks the scheme as it goes.
|
||||
fn into_base_path(input: &str, correct_scheme: Option<&'static str>) -> Result<String, ClientInitError> {
|
||||
// First convert to Uri, since a base path is a subset of Uri.
|
||||
let uri = Uri::from_str(input)?;
|
||||
|
||||
let scheme = uri.scheme().ok_or(ClientInitError::InvalidScheme)?;
|
||||
|
||||
// Check the scheme if necessary
|
||||
if let Some(correct_scheme) = correct_scheme {
|
||||
if scheme != correct_scheme {
|
||||
return Err(ClientInitError::InvalidScheme);
|
||||
}
|
||||
}
|
||||
|
||||
let host = uri.host().ok_or_else(|| ClientInitError::MissingHost)?;
|
||||
let port = uri.port().map(|x| format!(":{}", x)).unwrap_or_default();
|
||||
Ok(format!("{}://{}{}", scheme, host, port))
|
||||
}
|
||||
|
||||
/// A client that implements the API by making HTTP calls out to a server.
|
||||
#[derive(Clone)]
|
||||
pub struct Client {
|
||||
hyper_client: Arc<Fn(&Handle) -> Box<hyper::client::Service<Request=hyper::Request<hyper::Body>, Response=hyper::Response, Error=hyper::Error, Future=hyper::client::FutureResponse>> + Sync + Send>,
|
||||
handle: Arc<Handle>,
|
||||
base_path: String,
|
||||
}
|
||||
|
||||
impl fmt::Debug for Client {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
write!(f, "Client {{ base_path: {} }}", self.base_path)
|
||||
}
|
||||
}
|
||||
|
||||
impl Client {
|
||||
|
||||
/// Create an HTTP client.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `handle` - tokio reactor handle to use for execution
|
||||
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
|
||||
pub fn try_new_http(handle: Handle, base_path: &str) -> Result<Client, ClientInitError> {
|
||||
let http_connector = swagger::http_connector();
|
||||
Self::try_new_with_connector::<hyper::client::HttpConnector>(
|
||||
handle,
|
||||
base_path,
|
||||
Some("http"),
|
||||
http_connector,
|
||||
)
|
||||
}
|
||||
|
||||
/// Create a client with a TLS connection to the server.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `handle` - tokio reactor handle to use for execution
|
||||
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
|
||||
/// * `ca_certificate` - Path to CA certificate used to authenticate the server
|
||||
pub fn try_new_https<CA>(
|
||||
handle: Handle,
|
||||
base_path: &str,
|
||||
ca_certificate: CA,
|
||||
) -> Result<Client, ClientInitError>
|
||||
where
|
||||
CA: AsRef<Path>,
|
||||
{
|
||||
let https_connector = swagger::https_connector(ca_certificate);
|
||||
Self::try_new_with_connector::<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>(
|
||||
handle,
|
||||
base_path,
|
||||
Some("https"),
|
||||
https_connector,
|
||||
)
|
||||
}
|
||||
|
||||
/// Create a client with a mutually authenticated TLS connection to the server.
|
||||
///
|
||||
/// # Arguments
|
||||
/// * `handle` - tokio reactor handle to use for execution
|
||||
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
|
||||
/// * `ca_certificate` - Path to CA certificate used to authenticate the server
|
||||
/// * `client_key` - Path to the client private key
|
||||
/// * `client_certificate` - Path to the client's public certificate associated with the private key
|
||||
pub fn try_new_https_mutual<CA, K, C, T>(
|
||||
handle: Handle,
|
||||
base_path: &str,
|
||||
ca_certificate: CA,
|
||||
client_key: K,
|
||||
client_certificate: C,
|
||||
) -> Result<Client, ClientInitError>
|
||||
where
|
||||
CA: AsRef<Path>,
|
||||
K: AsRef<Path>,
|
||||
C: AsRef<Path>,
|
||||
{
|
||||
let https_connector =
|
||||
swagger::https_mutual_connector(ca_certificate, client_key, client_certificate);
|
||||
Self::try_new_with_connector::<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>(
|
||||
handle,
|
||||
base_path,
|
||||
Some("https"),
|
||||
https_connector,
|
||||
)
|
||||
}
|
||||
|
||||
/// Create a client with a custom implementation of hyper::client::Connect.
|
||||
///
|
||||
/// Intended for use with custom implementations of connect for e.g. protocol logging
|
||||
/// or similar functionality which requires wrapping the transport layer. When wrapping a TCP connection,
|
||||
/// this function should be used in conjunction with
|
||||
/// `swagger::{http_connector, https_connector, https_mutual_connector}`.
|
||||
///
|
||||
/// For ordinary tcp connections, prefer the use of `try_new_http`, `try_new_https`
|
||||
/// and `try_new_https_mutual`, to avoid introducing a dependency on the underlying transport layer.
|
||||
///
|
||||
/// # Arguments
|
||||
///
|
||||
/// * `handle` - tokio reactor handle to use for execution
|
||||
/// * `base_path` - base path of the client API, i.e. "www.my-api-implementation.com"
|
||||
/// * `protocol` - Which protocol to use when constructing the request url, e.g. `Some("http")`
|
||||
/// * `connector_fn` - Function which returns an implementation of `hyper::client::Connect`
|
||||
pub fn try_new_with_connector<C>(
|
||||
handle: Handle,
|
||||
base_path: &str,
|
||||
protocol: Option<&'static str>,
|
||||
connector_fn: Box<Fn(&Handle) -> C + Send + Sync>,
|
||||
) -> Result<Client, ClientInitError>
|
||||
where
|
||||
C: hyper::client::Connect + hyper::client::Service,
|
||||
{
|
||||
let hyper_client = {
|
||||
move |handle: &Handle| -> Box<
|
||||
hyper::client::Service<
|
||||
Request = hyper::Request<hyper::Body>,
|
||||
Response = hyper::Response,
|
||||
Error = hyper::Error,
|
||||
Future = hyper::client::FutureResponse,
|
||||
>,
|
||||
> {
|
||||
let connector = connector_fn(handle);
|
||||
Box::new(hyper::Client::configure().connector(connector).build(
|
||||
handle,
|
||||
))
|
||||
}
|
||||
};
|
||||
|
||||
Ok(Client {
|
||||
hyper_client: Arc::new(hyper_client),
|
||||
handle: Arc::new(handle),
|
||||
base_path: into_base_path(base_path, protocol)?,
|
||||
})
|
||||
}
|
||||
|
||||
/// Constructor for creating a `Client` by passing in a pre-made `hyper` client.
|
||||
///
|
||||
/// One should avoid relying on this function if possible, since it adds a dependency on the underlying transport
|
||||
/// implementation, which it would be better to abstract away. Therefore, using this function may lead to a loss of
|
||||
/// code generality, which may make it harder to move the application to a serverless environment, for example.
|
||||
///
|
||||
/// The reason for this function's existence is to support legacy test code, which did mocking at the hyper layer.
|
||||
/// This is not a recommended way to write new tests. If other reasons are found for using this function, they
|
||||
/// should be mentioned here.
|
||||
pub fn try_new_with_hyper_client(hyper_client: Arc<Fn(&Handle) -> Box<hyper::client::Service<Request=hyper::Request<hyper::Body>, Response=hyper::Response, Error=hyper::Error, Future=hyper::client::FutureResponse>> + Sync + Send>,
|
||||
handle: Handle,
|
||||
base_path: &str)
|
||||
-> Result<Client, ClientInitError>
|
||||
{
|
||||
Ok(Client {
|
||||
hyper_client: hyper_client,
|
||||
handle: Arc::new(handle),
|
||||
base_path: into_base_path(base_path, None)?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Api for Client {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
fn {{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}(&self{{#allParams}}, param_{{paramName}}: {{^required}}{{#isFile}}Box<Future<Item={{/isFile}}Option<{{/required}}{{#isListContainer}}&{{/isListContainer}}{{{dataType}}}{{^required}}>{{#isFile}}, Error=Error> + Send>{{/isFile}}{{/required}}{{/allParams}}, context: &Context) -> Box<Future<Item={{operationId}}Response, Error=ApiError>> {
|
||||
{{#queryParams}}{{#-first}}
|
||||
// Query parameters
|
||||
{{/-first}}{{#required}} let query_{{paramName}} = format!("{{baseName}}={{=<% %>=}}{<% paramName %>}<%={{ }}=%>&", {{paramName}}=param_{{paramName}}{{#isListContainer}}.join(","){{/isListContainer}}{{^isListContainer}}.to_string(){{/isListContainer}});
|
||||
{{/required}}{{^required}} let query_{{paramName}} = param_{{paramName}}.map_or_else(String::new, |query| format!("{{baseName}}={{=<% %>=}}{<% paramName %>}<%={{ }}=%>&", {{paramName}}=query{{#isListContainer}}.join(","){{/isListContainer}}{{^isListContainer}}.to_string(){{/isListContainer}}));
|
||||
{{/required}}{{/queryParams}}
|
||||
|
||||
let uri = format!(
|
||||
"{}{{basePathWithoutHost}}{{path}}{{#queryParams}}{{#-first}}?{{/-first}}{{=<% %>=}}{<% paramName %>}<%={{ }}=%>{{/queryParams}}",
|
||||
self.base_path{{#pathParams}}, {{baseName}}=utf8_percent_encode(¶m_{{paramName}}.to_string(), PATH_SEGMENT_ENCODE_SET){{/pathParams}}{{#queryParams}},
|
||||
{{paramName}}=utf8_percent_encode(&query_{{paramName}}, QUERY_ENCODE_SET){{/queryParams}}
|
||||
);
|
||||
|
||||
let uri = match Uri::from_str(&uri) {
|
||||
Ok(uri) => uri,
|
||||
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build URI: {}", err))))),
|
||||
};
|
||||
|
||||
let mut request = hyper::Request::new(hyper::Method::{{#vendorExtensions}}{{HttpMethod}}{{/vendorExtensions}}, uri);
|
||||
|
||||
{{#vendorExtensions}}{{#hasFile}} // Form data body
|
||||
let mut multipart = Multipart::new();
|
||||
|
||||
// Helper function to convert a Stream into a String. The String can then be used to build the HTTP body.
|
||||
fn convert_stream_to_string(stream: Box<Stream<Item=Vec<u8>, Error=Error> + Send>) -> Result<String, ApiError> {
|
||||
|
||||
stream.concat2()
|
||||
.wait()
|
||||
.map_err(|e| ApiError(format!("Unable to collect stream: {}", e)))
|
||||
.and_then(|body| String::from_utf8(body)
|
||||
.map_err(|e| ApiError(format!("Failed to convert utf8 stream to String: {}", e))))
|
||||
}{{/hasFile}}{{/vendorExtensions}}{{#formParams}}{{#isFile}}
|
||||
|
||||
{{^required}} if let Ok(Some(param_{{paramName}})) = param_{{paramName}}.wait() { {{/required}}
|
||||
{{^required}} {{/required}} match convert_stream_to_string(param_{{paramName}}) {
|
||||
{{^required}} {{/required}} Ok(param_{{paramName}}) => {
|
||||
// Add file to multipart form.
|
||||
multipart.add_text("{{paramName}}", param_{{paramName}});
|
||||
},
|
||||
{{^required}} {{/required}} Err(err) => return Box::new(futures::done(Err(err))),
|
||||
{{^required}} {{/required}} }
|
||||
{{^required}}}{{/required}}{{/isFile}}{{/formParams}}{{#vendorExtensions}}{{#hasFile}}
|
||||
|
||||
let mut fields = match multipart.prepare() {
|
||||
Ok(fields) => fields,
|
||||
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build request: {}", err))))),
|
||||
};
|
||||
|
||||
let mut body_string = String::new();
|
||||
let body = fields.to_body().read_to_string(&mut body_string);
|
||||
let boundary = fields.boundary();
|
||||
let multipart_header = match mime::Mime::from_str(&format!("multipart/form-data;boundary={}", boundary)) {
|
||||
Ok(multipart_header) => multipart_header,
|
||||
Err(err) => return Box::new(futures::done(Err(ApiError(format!("Unable to build multipart header: {:?}", err))))),
|
||||
};{{/hasFile}}{{^hasFile}}{{#formParams}}{{#-first}} let params = &[{{/-first}}
|
||||
("{{baseName}}", {{#vendorExtensions}}{{#required}}Some({{#isString}}param_{{paramName}}{{/isString}}{{^isString}}format!("{:?}", param_{{paramName}}){{/isString}}){{/required}}{{^required}}{{#isString}}param_{{paramName}}{{/isString}}{{^isString}}param_{{paramName}}.map(|param| format!("{:?}", param)){{/isString}}{{/required}}),{{/vendorExtensions}}{{#-last}}
|
||||
];
|
||||
let body = serde_urlencoded::to_string(params).expect("impossible to fail to serialize");
|
||||
|
||||
request.headers_mut().set(ContentType(mimetypes::requests::{{#vendorExtensions}}{{uppercase_operation_id}}{{/vendorExtensions}}.clone()));
|
||||
request.set_body(body.into_bytes());{{/-last}}{{/formParams}}{{/hasFile}}{{/vendorExtensions}}{{#bodyParam}}{{#-first}}
|
||||
// Body parameter
|
||||
{{/-first}}{{#vendorExtensions}}{{#required}}{{#consumesPlainText}} let body = param_{{paramName}};{{/consumesPlainText}}{{#consumesXml}}
|
||||
{{^has_namespace}} let body = serde_xml_rs::to_string(¶m_{{paramName}}).expect("impossible to fail to serialize");{{/has_namespace}}{{#has_namespace}}
|
||||
let mut namespaces = BTreeMap::new();
|
||||
// An empty string is used to indicate a global namespace in xmltree.
|
||||
namespaces.insert("".to_string(), models::namespaces::{{uppercase_data_type}}.clone());
|
||||
let body = serde_xml_rs::to_string_with_namespaces(¶m_{{paramName}}, namespaces).expect("impossible to fail to serialize");{{/has_namespace}}{{/consumesXml}}{{#consumesJson}}
|
||||
let body = serde_json::to_string(¶m_{{paramName}}).expect("impossible to fail to serialize");{{/consumesJson}}
|
||||
{{/required}}{{^required}}{{#consumesPlainText}} let body = param_{{paramName}};
|
||||
{{/consumesPlainText}}{{^consumesPlainText}} let body = param_{{paramName}}.map(|ref body| {
|
||||
{{#consumesXml}}
|
||||
{{^has_namespace}} serde_xml_rs::to_string(body).expect("impossible to fail to serialize"){{/has_namespace}}{{#has_namespace}}
|
||||
let mut namespaces = BTreeMap::new();
|
||||
// An empty string is used to indicate a global namespace in xmltree.
|
||||
namespaces.insert("".to_string(), models::namespaces::{{uppercase_data_type}}.clone());
|
||||
serde_xml_rs::to_string_with_namespaces(body, namespaces).expect("impossible to fail to serialize"){{/has_namespace}}{{/consumesXml}}{{#consumesJson}}
|
||||
serde_json::to_string(body).expect("impossible to fail to serialize"){{/consumesJson}}
|
||||
});{{/consumesPlainText}}{{/required}}{{/vendorExtensions}}{{/bodyParam}}
|
||||
|
||||
{{#bodyParam}}{{^required}}if let Some(body) = body {
|
||||
{{/required}} request.set_body(body.into_bytes());
|
||||
{{^required}} }{{/required}}
|
||||
|
||||
request.headers_mut().set(ContentType(mimetypes::requests::{{#vendorExtensions}}{{uppercase_operation_id}}{{/vendorExtensions}}.clone()));
|
||||
{{/bodyParam}}
|
||||
context.x_span_id.as_ref().map(|header| request.headers_mut().set(XSpanId(header.clone())));
|
||||
{{#authMethods}}{{#isBasic}} context.auth_data.as_ref().map(|auth_data| {
|
||||
if let &swagger::AuthData::Basic(ref basic_header) = auth_data {
|
||||
request.headers_mut().set(hyper::header::Authorization(
|
||||
basic_header.clone(),
|
||||
))
|
||||
}
|
||||
});{{/isBasic}}{{/authMethods}}{{#headerParams}}{{#-first}}
|
||||
// Header parameters
|
||||
{{/-first}}{{^isMapContainer}} header! { (Request{{vendorExtensions.typeName}}, "{{baseName}}") => {{#isListContainer}}({{{baseType}}})*{{/isListContainer}}{{^isListContainer}}[{{{dataType}}}]{{/isListContainer}} }
|
||||
{{#required}} request.headers_mut().set(Request{{vendorExtensions.typeName}}(param_{{paramName}}{{#isListContainer}}.clone(){{/isListContainer}}));
|
||||
{{/required}}{{^required}} param_{{paramName}}.map(|header| request.headers_mut().set(Request{{vendorExtensions.typeName}}(header{{#isListContainer}}.clone(){{/isListContainer}})));
|
||||
{{/required}}{{/isMapContainer}}{{#isMapContainer}} let param_{{paramName}}: Option<{{{dataType}}}> = None;
|
||||
{{/isMapContainer}}{{/headerParams}}
|
||||
|
||||
{{#vendorExtensions}}{{#hasFile}}
|
||||
request.headers_mut().set(ContentType(multipart_header));
|
||||
request.set_body(body_string.into_bytes());
|
||||
{{/hasFile}}{{/vendorExtensions}}
|
||||
|
||||
let hyper_client = (self.hyper_client)(&*self.handle);
|
||||
Box::new(hyper_client.call(request)
|
||||
.map_err(|e| ApiError(format!("No response received: {}", e)))
|
||||
.and_then(|mut response| {
|
||||
match response.status().as_u16() {
|
||||
{{#responses}}
|
||||
{{code}} => {
|
||||
{{#headers}} header! { (Response{{nameInCamelCase}}, "{{baseName}}") => [{{{datatype}}}] }
|
||||
let response_{{name}} = match response.headers().get::<Response{{nameInCamelCase}}>() {
|
||||
Some(response_{{name}}) => response_{{name}}.0.clone(),
|
||||
None => return Box::new(future::err(ApiError(String::from("Required response header {{baseName}} for response {{code}} was not found.")))) as Box<Future<Item=_, Error=_>>,
|
||||
};
|
||||
{{/headers}}
|
||||
{{^isFile}}let body = response.body();{{/isFile}}{{#isFile}}let body = Box::new(response.body()
|
||||
.map(|chunk| chunk.to_vec())
|
||||
.map_err(|_|
|
||||
Error::new(ErrorKind::Other, "Received error reading response.")
|
||||
));{{/isFile}}
|
||||
Box::new(
|
||||
{{#dataType}}{{^isFile}}
|
||||
body
|
||||
.concat2()
|
||||
.map_err(|e| ApiError(format!("Failed to read response: {}", e)))
|
||||
.and_then(|body| str::from_utf8(&body)
|
||||
.map_err(|e| ApiError(format!("Response was not valid UTF8: {}", e)))
|
||||
.and_then(|body|
|
||||
{{#vendorExtensions}}{{#producesXml}}
|
||||
// ToDo: this will move to swagger-rs and become a standard From conversion trait
|
||||
// once https://github.com/RReverser/serde-xml-rs/pull/45 is accepted upstream
|
||||
serde_xml_rs::from_str::<{{{dataType}}}>(body)
|
||||
.map_err(|e| ApiError(format!("Response body did not match the schema: {}", e)))
|
||||
{{/producesXml}}{{#producesJson}}
|
||||
serde_json::from_str::<{{{dataType}}}>(body)
|
||||
.map_err(|e| e.into())
|
||||
{{/producesJson}}{{#producesPlainText}}
|
||||
Ok(body.to_string())
|
||||
{{/producesPlainText}}{{/vendorExtensions}}
|
||||
))
|
||||
.map(move |body|
|
||||
{{/isFile}}{{#isFile}}
|
||||
future::ok(
|
||||
{{/isFile}}
|
||||
{{operationId}}Response::{{#vendorExtensions}}{{x-responseId}}{{/vendorExtensions}}{{^headers}}(body){{/headers}}{{#headers}}{{#-first}}{ body: body, {{/-first}}{{name}}: response_{{name}}{{^-last}}, {{/-last}}{{#-last}} }{{/-last}}{{/headers}}
|
||||
)
|
||||
{{/dataType}}{{^dataType}}
|
||||
future::ok(
|
||||
{{operationId}}Response::{{#vendorExtensions}}{{x-responseId}}{{/vendorExtensions}}{{#headers}}{{#-first}}{ {{/-first}}{{^-first}}, {{/-first}}{{name}}: response_{{name}}{{#-last}} }{{/-last}}{{/headers}}
|
||||
)
|
||||
{{/dataType}}
|
||||
) as Box<Future<Item=_, Error=_>>
|
||||
},
|
||||
{{/responses}}
|
||||
code => {
|
||||
let headers = response.headers().clone();
|
||||
Box::new(response.body()
|
||||
.take(100)
|
||||
.concat2()
|
||||
.then(move |body|
|
||||
future::err(ApiError(format!("Unexpected response code {}:\n{:?}\n\n{}",
|
||||
code,
|
||||
headers,
|
||||
match body {
|
||||
Ok(ref body) => match str::from_utf8(body) {
|
||||
Ok(body) => Cow::from(body),
|
||||
Err(e) => Cow::from(format!("<Body was not UTF8: {:?}>", e)),
|
||||
},
|
||||
Err(e) => Cow::from(format!("<Failed to read body: {}>", e)),
|
||||
})))
|
||||
)
|
||||
) as Box<Future<Item=_, Error=_>>
|
||||
}
|
||||
}
|
||||
}))
|
||||
|
||||
}
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum ClientInitError {
|
||||
InvalidScheme,
|
||||
InvalidUri(hyper::error::UriError),
|
||||
MissingHost,
|
||||
SslError(openssl::error::ErrorStack)
|
||||
}
|
||||
|
||||
impl From<hyper::error::UriError> for ClientInitError {
|
||||
fn from(err: hyper::error::UriError) -> ClientInitError {
|
||||
ClientInitError::InvalidUri(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<openssl::error::ErrorStack> for ClientInitError {
|
||||
fn from(err: openssl::error::ErrorStack) -> ClientInitError {
|
||||
ClientInitError::SslError(err)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for ClientInitError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
(self as &fmt::Debug).fmt(f)
|
||||
}
|
||||
}
|
||||
|
||||
impl error::Error for ClientInitError {
|
||||
fn description(&self) -> &str {
|
||||
"Failed to produce a hyper client."
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
#![allow(missing_docs, unused_variables, trivial_casts)]
|
||||
|
||||
extern crate {{externCrateName}};
|
||||
#[allow(unused_extern_crates)]
|
||||
extern crate futures;
|
||||
#[allow(unused_extern_crates)]
|
||||
extern crate swagger;
|
||||
#[allow(unused_extern_crates)]
|
||||
extern crate uuid;
|
||||
extern crate clap;
|
||||
extern crate tokio_core;
|
||||
|
||||
#[allow(unused_imports)]
|
||||
use futures::{Future, future, Stream, stream};
|
||||
use tokio_core::reactor;
|
||||
#[allow(unused_imports)]
|
||||
use {{externCrateName}}::{ApiNoContext, ContextWrapperExt,
|
||||
ApiError{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}},
|
||||
{{operationId}}Response{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
};
|
||||
use clap::{App, Arg};
|
||||
|
||||
fn main() {
|
||||
let matches = App::new("client")
|
||||
.arg(Arg::with_name("operation")
|
||||
.help("Sets the operation to run")
|
||||
.possible_values(&[
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}{{#vendorExtensions}}{{^noClientExample}} "{{operationId}}",
|
||||
{{/noClientExample}}{{/vendorExtensions}}{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}])
|
||||
.required(true)
|
||||
.index(1))
|
||||
.arg(Arg::with_name("https")
|
||||
.long("https")
|
||||
.help("Whether to use HTTPS or not"))
|
||||
.arg(Arg::with_name("host")
|
||||
.long("host")
|
||||
.takes_value(true)
|
||||
.default_value("{{serverHost}}")
|
||||
.help("Hostname to contact"))
|
||||
.arg(Arg::with_name("port")
|
||||
.long("port")
|
||||
.takes_value(true)
|
||||
.default_value("{{serverPort}}")
|
||||
.help("Port to contact"))
|
||||
.get_matches();
|
||||
|
||||
let mut core = reactor::Core::new().unwrap();
|
||||
let is_https = matches.is_present("https");
|
||||
let base_url = format!("{}://{}:{}",
|
||||
if is_https { "https" } else { "http" },
|
||||
matches.value_of("host").unwrap(),
|
||||
matches.value_of("port").unwrap());
|
||||
let client = if matches.is_present("https") {
|
||||
// Using Simple HTTPS
|
||||
{{externCrateName}}::Client::try_new_https(core.handle(), &base_url, "examples/ca.pem")
|
||||
.expect("Failed to create HTTPS client")
|
||||
} else {
|
||||
// Using HTTP
|
||||
{{externCrateName}}::Client::try_new_http(core.handle(), &base_url)
|
||||
.expect("Failed to create HTTP client")
|
||||
};
|
||||
|
||||
// Using a non-default `Context` is not required; this is just an example!
|
||||
let client = client.with_context({{externCrateName}}::Context::new_with_span_id(self::uuid::Uuid::new_v4().to_string()));
|
||||
|
||||
match matches.value_of("operation") {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
{{#vendorExtensions}}{{#noClientExample}}// Disabled because there's no example.
|
||||
// {{/noClientExample}}Some("{{operationId}}") => {
|
||||
{{#noClientExample}}// {{/noClientExample}} let result = core.run(client.{{operation_id}}{{/vendorExtensions}}({{#allParams}}{{^-first}}, {{/-first}}{{#vendorExtensions}}{{{example}}}{{/vendorExtensions}}{{/allParams}}));
|
||||
{{#vendorExtensions}}{{#noClientExample}}// {{/noClientExample}}{{/vendorExtensions}} println!("{:?} (X-Span-ID: {:?})", result, client.context().x_span_id.clone().unwrap_or(String::from("<none>")));
|
||||
{{#vendorExtensions}}{{#noClientExample}}// {{/noClientExample}}{{/vendorExtensions}} },
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
_ => {
|
||||
panic!("Invalid operation provided")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
//! Main binary entry point for {{externCrateName}} implementation.
|
||||
|
||||
#![allow(missing_docs)]
|
||||
|
||||
// Imports required by this file.
|
||||
// extern crate <name of this crate>;
|
||||
extern crate {{externCrateName}};
|
||||
extern crate swagger;
|
||||
extern crate hyper;
|
||||
extern crate openssl;
|
||||
extern crate native_tls;
|
||||
extern crate tokio_proto;
|
||||
extern crate tokio_tls;
|
||||
extern crate clap;
|
||||
|
||||
// Imports required by server library.
|
||||
// extern crate {{externCrateName}};
|
||||
// extern crate swagger;
|
||||
extern crate futures;
|
||||
extern crate chrono;
|
||||
#[macro_use]
|
||||
extern crate error_chain;
|
||||
{{#apiUsesUuid}}extern crate uuid;{{/apiUsesUuid}}
|
||||
|
||||
use openssl::x509::X509_FILETYPE_PEM;
|
||||
use openssl::ssl::{SslAcceptorBuilder, SslMethod};
|
||||
use openssl::error::ErrorStack;
|
||||
use hyper::server::Http;
|
||||
use tokio_proto::TcpServer;
|
||||
use clap::{App, Arg};
|
||||
use swagger::auth::AllowAllAuthenticator;
|
||||
|
||||
mod server_lib;
|
||||
|
||||
// Builds an SSL implementation for Simple HTTPS from some hard-coded file names
|
||||
fn ssl() -> Result<SslAcceptorBuilder, ErrorStack> {
|
||||
let mut ssl = SslAcceptorBuilder::mozilla_intermediate_raw(SslMethod::tls())?;
|
||||
|
||||
// Server authentication
|
||||
ssl.set_private_key_file("examples/server-key.pem", X509_FILETYPE_PEM)?;
|
||||
ssl.set_certificate_chain_file("examples/server-chain.pem")?;
|
||||
ssl.check_private_key()?;
|
||||
|
||||
Ok(ssl)
|
||||
}
|
||||
|
||||
/// Create custom server, wire it to the autogenerated router,
|
||||
/// and pass it to the web server.
|
||||
fn main() {
|
||||
let matches = App::new("server")
|
||||
.arg(Arg::with_name("https")
|
||||
.long("https")
|
||||
.help("Whether to use HTTPS or not"))
|
||||
.get_matches();
|
||||
|
||||
let service_fn =
|
||||
{{externCrateName}}::server::auth::NewService::new(
|
||||
AllowAllAuthenticator::new(
|
||||
server_lib::NewService,
|
||||
"cosmo"
|
||||
)
|
||||
);
|
||||
|
||||
let addr = "127.0.0.1:{{serverPort}}".parse().expect("Failed to parse bind address");
|
||||
if matches.is_present("https") {
|
||||
let ssl = ssl().expect("Failed to load SSL keys");
|
||||
let builder: native_tls::TlsAcceptorBuilder = native_tls::backend::openssl::TlsAcceptorBuilderExt::from_openssl(ssl);
|
||||
let tls_acceptor = builder.build().expect("Failed to build TLS acceptor");
|
||||
TcpServer::new(tokio_tls::proto::Server::new(Http::new(), tls_acceptor), addr).serve(service_fn);
|
||||
} else {
|
||||
// Using HTTP
|
||||
TcpServer::new(Http::new(), addr).serve(service_fn);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
//! Main library entry point for {{externCrateName}} implementation.
|
||||
|
||||
mod server;
|
||||
|
||||
mod errors {
|
||||
error_chain!{}
|
||||
}
|
||||
|
||||
pub use self::errors::*;
|
||||
use std::io;
|
||||
use hyper;
|
||||
use {{externCrateName}};
|
||||
|
||||
pub struct NewService;
|
||||
|
||||
impl hyper::server::NewService for NewService {
|
||||
type Request = (hyper::Request, {{externCrateName}}::Context);
|
||||
type Response = hyper::Response;
|
||||
type Error = hyper::Error;
|
||||
type Instance = {{externCrateName}}::server::Service<server::Server>;
|
||||
|
||||
/// Instantiate a new server.
|
||||
fn new_service(&self) -> io::Result<Self::Instance> {
|
||||
Ok({{externCrateName}}::server::Service::new(server::Server))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
//! Server implementation of {{externCrateName}}.
|
||||
|
||||
#![allow(unused_imports)]
|
||||
|
||||
use futures::{self, Future};
|
||||
use chrono;
|
||||
{{#apiHasFile}}use futures::Stream;{{/apiHasFile}}
|
||||
use std::collections::HashMap;
|
||||
{{#apiHasFile}}use std::io::Error;{{/apiHasFile}}
|
||||
{{#apiUsesUuid}}use uuid;{{/apiUsesUuid}}
|
||||
use swagger;
|
||||
|
||||
use {{externCrateName}}::{Api, ApiError, Context{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}},
|
||||
{{operationId}}Response{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
};
|
||||
use {{externCrateName}}::models;
|
||||
|
||||
#[derive(Copy, Clone)]
|
||||
pub struct Server;
|
||||
|
||||
impl Api for Server {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
{{#summary}} /// {{{summary}}}{{/summary}}
|
||||
fn {{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}(&self{{#allParams}}, {{paramName}}: {{^required}}{{#isFile}}Box<Future<Item={{/isFile}}Option<{{/required}}{{#isListContainer}}&{{/isListContainer}}{{{dataType}}}{{^required}}>{{#isFile}}, Error=Error> + Send>{{/isFile}}{{/required}}{{/allParams}}, context: &Context) -> Box<Future<Item={{operationId}}Response, Error=ApiError>> {
|
||||
let context = context.clone();
|
||||
println!("{{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}({{#allParams}}{{^isFile}}{{#vendorExtensions}}{{{formatString}}}{{/vendorExtensions}}{{#hasMore}}, {{/hasMore}}{{/isFile}}{{/allParams}}) - X-Span-ID: {:?}"{{#allParams}}{{^isFile}}, {{paramName}}{{/isFile}}{{/allParams}}, context.x_span_id.unwrap_or(String::from("<none>")).clone());{{#allParams}}{{#isFile}}
|
||||
let _ = {{paramName}}; //Suppresses unused param warning{{/isFile}}{{/allParams}}
|
||||
Box::new(futures::failed("Generic failure".into()))
|
||||
}
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
#![allow(missing_docs, trivial_casts, unused_variables, unused_mut, unused_imports, unused_extern_crates, non_camel_case_types)]
|
||||
extern crate serde;
|
||||
#[macro_use]
|
||||
extern crate serde_derive;
|
||||
extern crate serde_json;
|
||||
{{#apiUsesUuid}}extern crate uuid;{{/apiUsesUuid}}
|
||||
{{#usesXml}}extern crate serde_xml_rs;{{/usesXml}}
|
||||
extern crate futures;
|
||||
extern crate chrono;
|
||||
#[macro_use]
|
||||
extern crate lazy_static;
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
|
||||
// Logically this should be in the client and server modules, but rust doesn't allow `macro_use` from a module.
|
||||
#[cfg(any(feature = "client", feature = "server"))]
|
||||
#[macro_use]
|
||||
extern crate hyper;
|
||||
|
||||
extern crate swagger;
|
||||
|
||||
use futures::Stream;
|
||||
use std::io::Error;
|
||||
|
||||
#[allow(unused_imports)]
|
||||
use std::collections::HashMap;
|
||||
|
||||
pub use futures::Future;
|
||||
|
||||
#[cfg(any(feature = "client", feature = "server"))]
|
||||
mod mimetypes;
|
||||
|
||||
pub use swagger::{ApiError, Context, ContextWrapper};
|
||||
|
||||
pub const BASE_PATH: &'static str = "{{basePathWithoutHost}}";
|
||||
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
{{^isResponseFile}}
|
||||
#[derive(Debug, PartialEq)]
|
||||
{{/isResponseFile}}
|
||||
pub enum {{operationId}}Response {
|
||||
{{#responses}}
|
||||
{{#message}} /// {{message}}{{/message}}
|
||||
{{#vendorExtensions}}{{x-responseId}}{{/vendorExtensions}} {{#dataType}}{{^headers}}( {{{dataType}}} ) {{/headers}}{{#headers}}{{#-first}}{ body: {{{dataType}}}{{/-first}}{{/headers}}{{/dataType}}{{#headers}}{{#-first}}{{^dataType}} { {{/dataType}}{{#dataType}}, {{/dataType}}{{/-first}}{{^-first}}, {{/-first}}{{name}}: {{{datatype}}}{{#-last}} } {{/-last}}{{/headers}},
|
||||
{{/responses}}
|
||||
}
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
|
||||
/// API
|
||||
pub trait Api {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
{{#summary}} /// {{{summary}}}{{/summary}}
|
||||
fn {{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}(&self{{#allParams}}, {{paramName}}: {{^required}}{{#isFile}}Box<Future<Item={{/isFile}}Option<{{/required}}{{#isListContainer}}&{{/isListContainer}}{{{dataType}}}{{^required}}>{{#isFile}}, Error=Error> + Send>{{/isFile}}{{/required}}{{/allParams}}, context: &Context) -> Box<Future<Item={{operationId}}Response, Error=ApiError>>;
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
|
||||
/// API without a `Context`
|
||||
pub trait ApiNoContext {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
{{#summary}} /// {{{summary}}}{{/summary}}
|
||||
fn {{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}(&self{{#allParams}}, {{paramName}}: {{^required}}{{#isFile}}Box<Future<Item={{/isFile}}Option<{{/required}}{{#isListContainer}}&{{/isListContainer}}{{{dataType}}}{{^required}}>{{#isFile}}, Error=Error> + Send>{{/isFile}}{{/required}}{{/allParams}}) -> Box<Future<Item={{operationId}}Response, Error=ApiError>>;
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
|
||||
/// Trait to extend an API to make it easy to bind it to a context.
|
||||
pub trait ContextWrapperExt<'a> where Self: Sized {
|
||||
/// Binds this API to a context.
|
||||
fn with_context(self: &'a Self, context: Context) -> ContextWrapper<'a, Self>;
|
||||
}
|
||||
|
||||
impl<'a, T: Api + Sized> ContextWrapperExt<'a> for T {
|
||||
fn with_context(self: &'a T, context: Context) -> ContextWrapper<'a, T> {
|
||||
ContextWrapper::<T>::new(self, context)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Api> ApiNoContext for ContextWrapper<'a, T> {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
{{#summary}} /// {{{summary}}}{{/summary}}
|
||||
fn {{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}(&self{{#allParams}}, {{paramName}}: {{^required}}{{#isFile}}Box<Future<Item={{/isFile}}Option<{{/required}}{{#isListContainer}}&{{/isListContainer}}{{{dataType}}}{{^required}}>{{#isFile}}, Error=Error> + Send>{{/isFile}}{{/required}}{{/allParams}}) -> Box<Future<Item={{operationId}}Response, Error=ApiError>> {
|
||||
self.api().{{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}({{#allParams}}{{paramName}}, {{/allParams}}&self.context())
|
||||
}
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
|
||||
#[cfg(feature = "client")]
|
||||
pub mod client;
|
||||
|
||||
// Re-export Client as a top-level name
|
||||
#[cfg(feature = "client")]
|
||||
pub use self::client::Client;
|
||||
|
||||
#[cfg(feature = "server")]
|
||||
pub mod server;
|
||||
|
||||
// Re-export router() as a top-level name
|
||||
#[cfg(feature = "server")]
|
||||
pub use self::server::Service;
|
||||
|
||||
pub mod models;
|
||||
@@ -0,0 +1,25 @@
|
||||
/// mime types for requests and responses
|
||||
|
||||
pub mod responses {
|
||||
use hyper::mime::*;
|
||||
|
||||
// The macro is called per-operation to beat the recursion limit
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}{{#responses}}{{#produces}}{{#-first}}{{#dataType}} /// Create Mime objects for the response content types for {{operationId}}
|
||||
lazy_static! {
|
||||
pub static ref {{#vendorExtensions}}{{uppercase_operation_id}}_{{x-uppercaseResponseId}}{{/vendorExtensions}}: Mime = "{{{mediaType}}}".parse().unwrap();
|
||||
}
|
||||
{{/dataType}}{{/-first}}{{/produces}}{{/responses}}{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
|
||||
pub mod requests {
|
||||
use hyper::mime::*;
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}{{#bodyParam}} /// Create Mime objects for the request content types for {{operationId}}
|
||||
lazy_static! {
|
||||
pub static ref {{#vendorExtensions}}{{uppercase_operation_id}}{{/vendorExtensions}}: Mime = "{{#consumes}}{{#-first}}{{{mediaType}}}{{/-first}}{{/consumes}}{{^consumes}}application/json{{/consumes}}".parse().unwrap();
|
||||
}
|
||||
{{/bodyParam}}{{^bodyParam}}{{#vendorExtensions}}{{#formParams}}{{#-first}}{{^hasFile}} /// Create Mime objects for the request content types for {{operationId}}
|
||||
lazy_static! {
|
||||
pub static ref {{#vendorExtensions}}{{uppercase_operation_id}}{{/vendorExtensions}}: Mime = "{{#consumes}}{{#-first}}{{{mediaType}}}{{/-first}}{{/consumes}}{{^consumes}}application/x-www-form-urlencoded{{/consumes}}".parse().unwrap();
|
||||
}
|
||||
{{/hasFile}}{{/-first}}{{/formParams}}{{/vendorExtensions}}{{/bodyParam}}{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
use std::io;
|
||||
use hyper;
|
||||
use hyper::{Request, Response, Error, StatusCode};
|
||||
use server::url::form_urlencoded;
|
||||
use swagger::auth::{Authorization, AuthData, Scopes};
|
||||
use Api;
|
||||
|
||||
pub struct NewService<T> where T: hyper::server::NewService<Request=(Request,Option<AuthData>), Response=Response, Error=Error> {
|
||||
inner: T,
|
||||
}
|
||||
|
||||
impl<T> NewService<T> where T: hyper::server::NewService<Request=(Request,Option<AuthData>), Response=Response, Error=Error> + 'static {
|
||||
pub fn new(inner: T) -> NewService<T> {
|
||||
NewService{inner}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> hyper::server::NewService for NewService<T> where T: hyper::server::NewService<Request=(Request,Option<AuthData>), Response=Response, Error=Error> + 'static {
|
||||
type Request = Request;
|
||||
type Response = Response;
|
||||
type Error = Error;
|
||||
type Instance = Service<T::Instance>;
|
||||
|
||||
fn new_service(&self) -> Result<Self::Instance, io::Error> {
|
||||
self.inner.new_service().map(|s| Service::new(s))
|
||||
}
|
||||
}
|
||||
|
||||
/// Middleware to extract authentication data from request
|
||||
pub struct Service<T> where T: hyper::server::Service<Request=(Request,Option<AuthData>), Response=Response, Error=Error> {
|
||||
inner: T,
|
||||
}
|
||||
|
||||
impl<T> Service<T> where T: hyper::server::Service<Request=(Request,Option<AuthData>), Response=Response, Error=Error> {
|
||||
pub fn new(inner: T) -> Service<T> {
|
||||
Service{inner}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> hyper::server::Service for Service<T> where T: hyper::server::Service<Request=(Request,Option<AuthData>), Response=Response, Error=Error> {
|
||||
type Request = Request;
|
||||
type Response = Response;
|
||||
type Error = Error;
|
||||
type Future = T::Future;
|
||||
|
||||
fn call(&self, req: Self::Request) -> Self::Future {
|
||||
{{#authMethods}}
|
||||
{{#isBasic}}
|
||||
{
|
||||
use hyper::header::{Authorization, Basic, Bearer};
|
||||
use std::ops::Deref;
|
||||
if let Some(basic) = req.headers().get::<Authorization<Basic>>().cloned() {
|
||||
let auth_data = AuthData::Basic(basic.deref().clone());
|
||||
return self.inner.call((req, Some(auth_data)));
|
||||
}
|
||||
}
|
||||
{{/isBasic}}
|
||||
{{#isOAuth}}
|
||||
{
|
||||
use hyper::header::{Authorization, Basic, Bearer};
|
||||
use std::ops::Deref;
|
||||
if let Some(bearer) = req.headers().get::<Authorization<Bearer>>().cloned() {
|
||||
let auth_data = AuthData::Bearer(bearer.deref().clone());
|
||||
return self.inner.call((req, Some(auth_data)));
|
||||
}
|
||||
}
|
||||
{{/isOAuth}}
|
||||
{{#isApiKey}}
|
||||
{{#isKeyInHeader}}
|
||||
{
|
||||
header! { (ApiKey{{-index}}, "{{keyParamName}}") => [String] }
|
||||
if let Some(header) = req.headers().get::<ApiKey{{-index}}>().cloned() {
|
||||
let auth_data = AuthData::ApiKey(header.0);
|
||||
return self.inner.call((req, Some(auth_data)));
|
||||
}
|
||||
}
|
||||
{{/isKeyInHeader}}
|
||||
{{#isKeyInQuery}}
|
||||
{
|
||||
let key = form_urlencoded::parse(req.query().unwrap_or_default().as_bytes())
|
||||
.filter(|e| e.0 == "api_key_query")
|
||||
.map(|e| e.1.clone().into_owned())
|
||||
.nth(0);
|
||||
if let Some(key) = key {
|
||||
let auth_data = AuthData::ApiKey(key);
|
||||
return self.inner.call((req, Some(auth_data)));
|
||||
}
|
||||
}
|
||||
{{/isKeyInQuery}}
|
||||
{{/isApiKey}}
|
||||
{{/authMethods}}
|
||||
|
||||
return self.inner.call((req, None));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,449 @@
|
||||
#![allow(unused_extern_crates)]
|
||||
extern crate serde_ignored;
|
||||
extern crate tokio_core;
|
||||
extern crate native_tls;
|
||||
extern crate hyper_tls;
|
||||
extern crate openssl;
|
||||
extern crate mime;
|
||||
{{^apiUsesUuid}}extern crate uuid;{{/apiUsesUuid}}
|
||||
extern crate chrono;
|
||||
{{#apiHasFile}}extern crate multipart;{{/apiHasFile}}
|
||||
extern crate percent_encoding;
|
||||
extern crate url;
|
||||
|
||||
{{#apiUsesUuid}}use uuid;{{/apiUsesUuid}}
|
||||
use std::sync::Arc;
|
||||
use futures::{Future, future, Stream, stream};
|
||||
use hyper;
|
||||
use hyper::{Request, Response, Error, StatusCode};
|
||||
use hyper::header::{Headers, ContentType};
|
||||
use self::url::form_urlencoded;
|
||||
use mimetypes;
|
||||
{{#apiHasFile}}use self::multipart::server::Multipart;
|
||||
use self::multipart::server::save::SaveResult;{{/apiHasFile}}
|
||||
|
||||
use serde_json;
|
||||
{{#usesXml}}use serde_xml_rs;{{/usesXml}}
|
||||
|
||||
#[allow(unused_imports)]
|
||||
use std::collections::{HashMap, BTreeMap};
|
||||
#[allow(unused_imports)]
|
||||
use swagger;
|
||||
use std::io;
|
||||
|
||||
#[allow(unused_imports)]
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
pub use swagger::auth::Authorization;
|
||||
use swagger::{ApiError, Context, XSpanId};
|
||||
use swagger::auth::Scopes;
|
||||
|
||||
use {Api{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}},
|
||||
{{operationId}}Response{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
};
|
||||
#[allow(unused_imports)]
|
||||
use models;
|
||||
|
||||
pub mod auth;
|
||||
|
||||
header! { (Warning, "Warning") => [String] }
|
||||
|
||||
mod paths {
|
||||
extern crate regex;
|
||||
|
||||
lazy_static! {
|
||||
pub static ref GLOBAL_REGEX_SET: regex::RegexSet = regex::RegexSet::new(&[
|
||||
{{#pathSet}}
|
||||
r"^{{basePathWithoutHost}}{{{pathRegEx}}}"{{^-last}},{{/-last}}
|
||||
{{/pathSet}}
|
||||
]).unwrap();
|
||||
}
|
||||
{{#pathSet}}
|
||||
pub static ID_{{PATH_ID}}: usize = {{index}};
|
||||
{{#hasPathParams}}
|
||||
lazy_static! {
|
||||
pub static ref REGEX_{{PATH_ID}}: regex::Regex = regex::Regex::new(r"^{{basePathWithoutHost}}{{{pathRegEx}}}").unwrap();
|
||||
}
|
||||
{{/hasPathParams}}
|
||||
{{/pathSet}}
|
||||
}
|
||||
|
||||
pub struct NewService<T> {
|
||||
api_impl: Arc<T>,
|
||||
}
|
||||
|
||||
impl<T> NewService<T> where T: Api + Clone + 'static {
|
||||
pub fn new<U: Into<Arc<T>>>(api_impl: U) -> NewService<T> {
|
||||
NewService{api_impl: api_impl.into()}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> hyper::server::NewService for NewService<T> where T: Api + Clone + 'static {
|
||||
type Request = (Request, Context);
|
||||
type Response = Response;
|
||||
type Error = Error;
|
||||
type Instance = Service<T>;
|
||||
|
||||
fn new_service(&self) -> Result<Self::Instance, io::Error> {
|
||||
Ok(Service::new(self.api_impl.clone()))
|
||||
}
|
||||
}
|
||||
|
||||
pub struct Service<T> {
|
||||
api_impl: Arc<T>,
|
||||
}
|
||||
|
||||
impl<T> Service<T> where T: Api + Clone + 'static {
|
||||
pub fn new<U: Into<Arc<T>>>(api_impl: U) -> Service<T> {
|
||||
Service{api_impl: api_impl.into()}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> hyper::server::Service for Service<T> where T: Api + Clone + 'static {
|
||||
type Request = (Request, Context);
|
||||
type Response = Response;
|
||||
type Error = Error;
|
||||
type Future = Box<Future<Item=Response, Error=Error>>;
|
||||
|
||||
fn call(&self, (req, mut context): Self::Request) -> Self::Future {
|
||||
let api_impl = self.api_impl.clone();
|
||||
let (method, uri, _, headers, body) = req.deconstruct();
|
||||
let path = paths::GLOBAL_REGEX_SET.matches(uri.path());
|
||||
match &method {
|
||||
{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
|
||||
// {{operationId}} - {{httpMethod}} {{path}}
|
||||
&hyper::Method::{{vendorExtensions.HttpMethod}} if path.matched(paths::ID_{{vendorExtensions.PATH_ID}}) => {
|
||||
if context.x_span_id.is_none() {
|
||||
context.x_span_id = Some(headers.get::<XSpanId>().map(XSpanId::to_string).unwrap_or_else(|| self::uuid::Uuid::new_v4().to_string()));
|
||||
}
|
||||
{{#hasAuthMethods}}
|
||||
{
|
||||
let authorization = match context.authorization.as_ref() {
|
||||
Some(authorization) => authorization,
|
||||
None => return Box::new(future::ok(Response::new()
|
||||
.with_status(StatusCode::Forbidden)
|
||||
.with_body("Unauthenticated"))),
|
||||
};
|
||||
|
||||
{{#authMethods}}
|
||||
{{#isOAuth}}
|
||||
// Authorization
|
||||
if let Scopes::Some(ref scopes) = authorization.scopes {
|
||||
let required_scopes: BTreeSet<String> = vec![
|
||||
{{#scopes}}
|
||||
"{{scope}}".to_string(), // {{description}}
|
||||
{{/scopes}}
|
||||
].into_iter().collect();
|
||||
|
||||
if !required_scopes.is_subset(scopes) {
|
||||
let missing_scopes = required_scopes.difference(scopes);
|
||||
return Box::new(future::ok(Response::new()
|
||||
.with_status(StatusCode::Forbidden)
|
||||
.with_body(missing_scopes.fold(
|
||||
"Insufficient authorization, missing scopes".to_string(),
|
||||
|s, scope| format!("{} {}", s, scope)
|
||||
))
|
||||
));
|
||||
}
|
||||
}
|
||||
{{/isOAuth}}
|
||||
{{/authMethods}}
|
||||
}
|
||||
{{/hasAuthMethods}}
|
||||
|
||||
{{#vendorExtensions}}{{#hasPathParams}}
|
||||
// Path parameters
|
||||
let path = uri.path().to_string();
|
||||
let path_params =
|
||||
paths::REGEX_{{PATH_ID}}
|
||||
.captures(&path)
|
||||
.unwrap_or_else(||
|
||||
panic!("Path {} matched RE {{PATH_ID}} in set but failed match against \"{}\"", path, paths::REGEX_{{PATH_ID}}.as_str())
|
||||
);
|
||||
{{/hasPathParams}}{{/vendorExtensions}}
|
||||
{{#pathParams}}
|
||||
let param_{{paramName}} = match percent_encoding::percent_decode(path_params["{{baseName}}"].as_bytes()).decode_utf8() {
|
||||
Ok(param_{{paramName}}) => match param_{{paramName}}.parse::<{{{dataType}}}>() {
|
||||
Ok(param_{{paramName}}) => param_{{paramName}},
|
||||
Err(e) => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't parse path parameter {{baseName}}: {}", e)))),
|
||||
},
|
||||
Err(_) => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't percent-decode path parameter as UTF-8: {}", &path_params["{{baseName}}"]))))
|
||||
};
|
||||
{{/pathParams}}
|
||||
{{#headerParams}}{{#-first}}
|
||||
// Header parameters
|
||||
{{/-first}}
|
||||
header! { (Request{{vendorExtensions.typeName}}, "{{baseName}}") => {{#isListContainer}}({{{baseType}}})*{{/isListContainer}}{{^isListContainer}}[{{{dataType}}}]{{/isListContainer}} }
|
||||
{{#required}}
|
||||
let param_{{paramName}} = match headers.get::<Request{{vendorExtensions.typeName}}>() {
|
||||
Some(param_{{paramName}}) => param_{{paramName}}.0.clone(),
|
||||
None => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body("Missing or invalid required header {{baseName}}"))),
|
||||
};
|
||||
{{/required}}
|
||||
{{^required}}
|
||||
let param_{{paramName}} = headers.get::<Request{{vendorExtensions.typeName}}>().map(|header| header.0.clone());
|
||||
{{/required}}{{/headerParams}}
|
||||
|
||||
{{#queryParams}}{{#-first}}
|
||||
// Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
|
||||
let query_params = form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes()).collect::<Vec<_>>();
|
||||
{{/-first}}
|
||||
let param_{{paramName}} = query_params.iter().filter(|e| e.0 == "{{baseName}}").map(|e| e.1.to_owned())
|
||||
{{#isListContainer}}
|
||||
.filter_map(|param_{{paramName}}| param_{{paramName}}.parse::<{{{baseType}}}>().ok())
|
||||
.collect::<Vec<_>>();
|
||||
{{^required}}
|
||||
let param_{{paramName}} = if !param_{{paramName}}.is_empty() {
|
||||
Some(param_{{paramName}})
|
||||
} else {
|
||||
None
|
||||
};
|
||||
{{/required}}
|
||||
{{/isListContainer}}{{^isListContainer}}
|
||||
.nth(0);
|
||||
{{#required}}
|
||||
let param_{{paramName}} = match param_{{paramName}} {
|
||||
Some(param_{{paramName}}) => match param_{{paramName}}.parse::<{{{dataType}}}>() {
|
||||
Ok(param_{{paramName}}) => param_{{paramName}},
|
||||
Err(e) => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't parse query parameter {{baseName}} - doesn't match schema: {}", e)))),
|
||||
},
|
||||
None => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body("Missing required query parameter {{baseName}}"))),
|
||||
};
|
||||
{{/required}}{{^required}}
|
||||
let param_{{paramName}} = param_{{paramName}}.and_then(|param_{{paramName}}| param_{{paramName}}.parse::<{{{baseType}}}>().ok());
|
||||
{{/required}}
|
||||
{{/isListContainer}}
|
||||
{{/queryParams}}
|
||||
|
||||
{{#bodyParams}}{{#-first}}
|
||||
// Body parameters (note that non-required body parameters will ignore garbage
|
||||
// values, rather than causing a 400 response). Produce warning header and logs for
|
||||
// any unused fields.
|
||||
Box::new(body.concat2()
|
||||
.then(move |result| -> Box<Future<Item=Response, Error=Error>> {
|
||||
match result {
|
||||
Ok(body) => {
|
||||
{{#vendorExtensions}}{{^consumesPlainText}}
|
||||
let mut unused_elements = Vec::new();
|
||||
{{/consumesPlainText}}
|
||||
let param_{{paramName}}: Option<{{{dataType}}}> = if !body.is_empty() {
|
||||
{{#consumesXml}}
|
||||
let deserializer = &mut serde_xml_rs::de::Deserializer::new_from_reader(&*body);
|
||||
{{/consumesXml}}{{#consumesJson}}
|
||||
let deserializer = &mut serde_json::Deserializer::from_slice(&*body);
|
||||
{{/consumesJson}}{{^consumesPlainText}}
|
||||
match serde_ignored::deserialize(deserializer, |path| {
|
||||
warn!("Ignoring unknown field in body: {}", path);
|
||||
unused_elements.push(path.to_string());
|
||||
}) {
|
||||
Ok(param_{{paramName}}) => param_{{paramName}},
|
||||
{{#required}}
|
||||
Err(e) => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't parse body parameter {{baseName}} - doesn't match schema: {}", e)))),
|
||||
{{/required}}{{^required}}
|
||||
Err(_) => None,
|
||||
{{/required}}
|
||||
}
|
||||
{{/consumesPlainText}}{{#consumesPlainText}}
|
||||
match String::from_utf8(body.to_vec()) {
|
||||
Ok(param_{{paramName}}) => Some(param_{{paramName}}),
|
||||
Err(e) => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't parse body parameter {{baseName}} - not valid UTF-8: {}", e)))),
|
||||
}
|
||||
{{/consumesPlainText}}{{/vendorExtensions}}
|
||||
} else {
|
||||
None
|
||||
};
|
||||
{{#required}}
|
||||
let param_{{paramName}} = match param_{{paramName}} {
|
||||
Some(param_{{paramName}}) => param_{{paramName}},
|
||||
None => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body("Missing required body parameter {{baseName}}"))),
|
||||
};
|
||||
{{/required}}
|
||||
{{/-first}}{{/bodyParams}}
|
||||
{{^bodyParams}}{{#vendorExtensions}}{{#hasFile}}
|
||||
let boundary = match multipart_boundary(&headers) {
|
||||
Some(boundary) => boundary.to_string(),
|
||||
None => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body("Couldn't find valid multipart body"))),
|
||||
};
|
||||
|
||||
Box::new(body.concat2()
|
||||
.then(move |result| -> Box<Future<Item=Response, Error=Error>> {
|
||||
match result {
|
||||
Ok(body) => {
|
||||
let mut entries = match Multipart::with_body(&body.to_vec()[..], boundary).save().temp() {
|
||||
SaveResult::Full(entries) => {
|
||||
entries
|
||||
},
|
||||
_ => {
|
||||
return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Unable to process all message parts"))))
|
||||
},
|
||||
};
|
||||
{{#formParams}}{{#-first}}
|
||||
// Form parameters
|
||||
{{/-first}}
|
||||
let param_{{paramName}} = entries.fields.remove("{{paramName}}");
|
||||
let param_{{paramName}} = match param_{{paramName}} {
|
||||
Some(entry) =>
|
||||
{{#isFile}}
|
||||
{{^required}}Some({{/required}}Box::new(stream::once(Ok(entry.as_bytes().to_vec()))) as Box<Stream<Item=Vec<u8>, Error=io::Error> + Send>{{^required}}){{/required}},
|
||||
{{/isFile}}{{^isFile}}
|
||||
match entry.parse::<{{{dataType}}}>() {
|
||||
Ok(entry) => {{^required}}Some({{/required}}entry{{^required}}){{/required}},
|
||||
{{#required}}
|
||||
Err(e) => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't parse form parameter {{baseName}} - doesn't match schema: {}", e)))),
|
||||
{{/required}}{{^required}}
|
||||
Err(_) => None,
|
||||
{{/required}}
|
||||
},
|
||||
{{/isFile}}
|
||||
{{#required}}
|
||||
None => return Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Missing required form parameter {{paramName}}")))),
|
||||
{{/required}}{{^required}}
|
||||
None => None,
|
||||
{{/required}}
|
||||
};
|
||||
{{^required}}{{#isFile}} let param_{{paramName}} = Box::new(future::ok(param_{{paramName}}));{{/isFile}}{{/required}}
|
||||
{{/formParams}}
|
||||
{{/hasFile}}{{^hasFile}}
|
||||
Box::new(({
|
||||
{{
|
||||
{{#formParams}}{{#-first}}
|
||||
// Form parameters
|
||||
{{/-first}}
|
||||
let param_{{paramName}} = {{^isContainer}}{{#vendorExtensions}}{{{example}}};{{/vendorExtensions}}{{/isContainer}}{{#isListContainer}}{{#required}}Vec::new();{{/required}}{{^required}}None;{{/required}}{{/isListContainer}}{{#isMapContainer}}None;{{/isMapContainer}}
|
||||
{{/formParams}}
|
||||
{{/hasFile}}{{/vendorExtensions}}{{/bodyParams}}
|
||||
Box::new(api_impl.{{#vendorExtensions}}{{operation_id}}{{/vendorExtensions}}({{#allParams}}param_{{paramName}}{{#isListContainer}}.as_ref(){{/isListContainer}}, {{/allParams}}&context)
|
||||
.then(move |result| {
|
||||
let mut response = Response::new();
|
||||
context.x_span_id.as_ref().map(|header| response.headers_mut().set(XSpanId(header.clone())));
|
||||
{{#bodyParams}}{{#vendorExtensions}}{{^consumesPlainText}}
|
||||
if !unused_elements.is_empty() {
|
||||
response.headers_mut().set(Warning(format!("Ignoring unknown fields in body: {:?}", unused_elements)));
|
||||
}
|
||||
{{/consumesPlainText}}{{/vendorExtensions}}{{/bodyParams}}
|
||||
match result {
|
||||
Ok(rsp) => match rsp {
|
||||
{{#responses}}
|
||||
{{operationId}}Response::{{#vendorExtensions}}{{x-responseId}}{{/vendorExtensions}}
|
||||
{{#dataType}}{{^headers}}
|
||||
(body)
|
||||
{{/headers}}{{#headers}}
|
||||
{{#-first}}
|
||||
{
|
||||
body,
|
||||
{{/-first}}
|
||||
{{name}}{{^-last}}, {{/-last}}
|
||||
{{#-last}}
|
||||
}
|
||||
{{/-last}}
|
||||
{{/headers}}{{/dataType}}
|
||||
{{^dataType}}{{#headers}}{{#-first}}
|
||||
{
|
||||
{{/-first}}
|
||||
{{name}}{{^-last}}, {{/-last}}
|
||||
{{#-last}}
|
||||
}
|
||||
{{/-last}}
|
||||
{{/headers}}{{/dataType}}
|
||||
=> {
|
||||
{{^isFile}} response.set_status(StatusCode::try_from({{code}}).unwrap());
|
||||
{{#headers}}
|
||||
header! { (Response{{nameInCamelCase}}, "{{baseName}}") => [{{{datatype}}}] }
|
||||
response.headers_mut().set(Response{{nameInCamelCase}}({{name}}));
|
||||
{{/headers}}
|
||||
{{#produces}}{{#-first}}{{#dataType}}
|
||||
response.headers_mut().set(ContentType(mimetypes::responses::{{#vendorExtensions}}{{uppercase_operation_id}}_{{x-uppercaseResponseId}}{{/vendorExtensions}}.clone()));
|
||||
{{/dataType}}{{/-first}}{{/produces}}
|
||||
{{#dataType}}
|
||||
{{#vendorExtensions}}{{#producesXml}}{{^has_namespace}}
|
||||
let body = serde_xml_rs::to_string(&body).expect("impossible to fail to serialize");
|
||||
{{/has_namespace}}{{#has_namespace}}
|
||||
let mut namespaces = BTreeMap::new();
|
||||
// An empty string is used to indicate a global namespace in xmltree.
|
||||
namespaces.insert("".to_string(), models::namespaces::{{uppercase_data_type}}.clone());
|
||||
let body = serde_xml_rs::to_string_with_namespaces(&body, namespaces).expect("impossible to fail to serialize");
|
||||
{{/has_namespace}}{{/producesXml}}{{#producesJson}}
|
||||
let body = serde_json::to_string(&body).expect("impossible to fail to serialize");
|
||||
{{/producesJson}}{{/vendorExtensions}}
|
||||
response.set_body(body);
|
||||
{{/dataType}}{{/isFile}}{{#isFile}}
|
||||
let body = body.fold(Vec::new(), | mut body, chunk| {
|
||||
body.extend(chunk.iter());
|
||||
future::ok::<Vec<u8>, io::Error>(body)
|
||||
})
|
||||
// Block whilst waiting for the stream to complete
|
||||
.wait();
|
||||
|
||||
match body {
|
||||
// If no error occurred then create successful hyper response
|
||||
Ok(vec) => {
|
||||
response.set_status(StatusCode::try_from({{code}}).unwrap());
|
||||
|
||||
{{#headers}}
|
||||
header! { (Response{{nameInCamelCase}}, "{{baseName}}") => [{{{datatype}}}] }
|
||||
response.headers_mut().set(Response{{nameInCamelCase}}({{name}}));
|
||||
{{/headers}}{{#produces}}{{#-first}}{{#dataType}}
|
||||
response.headers_mut().set(ContentType(mimetypes::responses::{{#vendorExtensions}}{{uppercase_operation_id}}_{{x-uppercaseResponseId}}{{/vendorExtensions}}.clone()));
|
||||
{{/dataType}}{{/-first}}{{/produces}}
|
||||
response.set_body(vec);
|
||||
},
|
||||
// It's possible that errors were received in the stream, if this is the case then we can't return a success response to the client and instead must return an internal error.
|
||||
Err(e) => {
|
||||
response.set_status(StatusCode::InternalServerError);
|
||||
response.set_body("An internal error occurred");
|
||||
}
|
||||
}
|
||||
{{/isFile}}
|
||||
},
|
||||
{{/responses}}
|
||||
},
|
||||
Err(_) => {
|
||||
// Application code returned an error. This should not happen, as the implementation should
|
||||
// return a valid response.
|
||||
response.set_status(StatusCode::InternalServerError);
|
||||
response.set_body("An internal error occurred");
|
||||
},
|
||||
}
|
||||
|
||||
future::ok(response)
|
||||
}
|
||||
))
|
||||
{{^bodyParams}}{{#vendorExtensions}}{{^hasFile}}
|
||||
}}
|
||||
})) as Box<Future<Item=Response, Error=Error>>
|
||||
{{/hasFile}}{{#hasFile}}
|
||||
as Box<Future<Item=Response, Error=Error>>
|
||||
},
|
||||
Err(e) => Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't read multipart body")))),
|
||||
}
|
||||
})
|
||||
)
|
||||
{{/hasFile}}{{/vendorExtensions}}{{/bodyParams}}
|
||||
{{#bodyParams}}{{#-first}}
|
||||
},
|
||||
Err(e) => Box::new(future::ok(Response::new().with_status(StatusCode::BadRequest).with_body(format!("Couldn't read body parameter {{baseName}}: {}", e)))),
|
||||
}
|
||||
})
|
||||
) as Box<Future<Item=Response, Error=Error>>
|
||||
{{/-first}}{{/bodyParams}}
|
||||
},
|
||||
|
||||
{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
|
||||
_ => Box::new(future::ok(Response::new().with_status(StatusCode::NotFound))) as Box<Future<Item=Response, Error=Error>>,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
{{#apiHasFile}}
|
||||
/// Utility function to get the multipart boundary marker (if any) from the Headers.
|
||||
fn multipart_boundary<'a>(headers: &'a Headers) -> Option<&'a str> {
|
||||
headers.get::<ContentType>().and_then(|content_type| {
|
||||
let ContentType(ref mime) = *content_type;
|
||||
if mime.type_() == mime::MULTIPART && mime.subtype() == mime::FORM_DATA {
|
||||
mime.get_param(mime::BOUNDARY).map(|x| x.as_str())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
}
|
||||
{{/apiHasFile}}
|
||||
Reference in New Issue
Block a user