Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
rust-server.server-callbacks.mustache Maven / Gradle / Ivy
{{>client-imports}}
use crate::CallbackApi;
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{#callbacks}}
{{#urls}}
{{#requests}}
use crate::{{{operationId}}}Response;
{{/requests}}
{{/urls}}
{{/callbacks}}
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
/// A client that implements the API by making HTTP calls out to a server.
pub struct Client where
S: Service<
(Request, C),
Response=Response,
Error=hyper::Error> + Clone + Send + Sync,
S::Future: Send + 'static,
C: Clone + Send + Sync + 'static
{
/// Inner service
client_service: S,
/// Marker
marker: PhantomData,
}
impl fmt::Debug for Client where
S: Service<
(Request, C),
Response=Response,
Error=hyper::Error> + Clone + Send + Sync,
S::Future: Send + 'static,
C: Clone + Send + Sync + 'static
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Client")
}
}
impl Clone for Client where
S: Service<
(Request, C),
Response=Response,
Error=hyper::Error> + Clone + Send + Sync,
S::Future: Send + 'static,
C: Clone + Send + Sync + 'static
{
fn clone(&self) -> Self {
Self {
client_service: self.client_service.clone(),
marker: PhantomData,
}
}
}
impl Client, C>, C> where
Connector: hyper::client::connect::Connect + Clone + Send + Sync + 'static,
C: Clone + Send + Sync + 'static
{
/// 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::Connector::builder()`.
///
/// For ordinary tcp connections, prefer the use of `new_http`, `new_https`
/// and `new_https_mutual`, to avoid introducing a dependency on the underlying transport layer.
///
/// # Arguments
///
/// * `connector` - Implementation of `hyper::client::Connect` to use for the client
pub fn new_with_connector(connector: Connector) -> Self
{
let client_service = hyper::client::Client::builder().build(connector);
let client_service = DropContextService::new(client_service);
Self {
client_service,
marker: PhantomData,
}
}
}
impl Client, C>, C> where
C: Clone + Send + Sync + 'static
{
/// Create an HTTP client.
pub fn new_http() -> Self {
let http_connector = Connector::builder().build();
Self::new_with_connector(http_connector)
}
}
#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
type HttpConnector = hyper_tls::HttpsConnector;
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
type HttpsConnector = hyper_openssl::HttpsConnector;
impl Client, C>, C> where
C: Clone + Send + Sync + 'static
{
/// Create a client with a TLS connection to the server.
#[cfg(any(target_os = "macos", target_os = "windows", target_os = "ios"))]
pub fn new_https() -> Result
{
let https_connector = Connector::builder().https().build()?;
Ok(Self::new_with_connector(https_connector))
}
/// Create a client with a TLS connection to the server.
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
pub fn new_https() -> Result
{
let https_connector = Connector::builder().https().build()?;
Ok(Self::new_with_connector(https_connector))
}
/// Create a client with a TLS connection to the server, pinning the certificate
///
/// # Arguments
/// * `ca_certificate` - Path to CA certificate used to authenticate the server
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
pub fn new_https_pinned(
ca_certificate: CA,
) -> Result where
CA: AsRef,
{
let https_connector = Connector::builder()
.https()
.pin_server_certificate(ca_certificate)
.build()?;
Ok(Self::new_with_connector(https_connector))
}
/// Create a client with a mutually authenticated TLS connection to the server.
///
/// # Arguments
/// * `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
#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "ios")))]
pub fn new_https_mutual(
ca_certificate: CA,
client_key: K,
client_certificate: D,
) -> Result
where
CA: AsRef,
K: AsRef,
D: AsRef,
{
let https_connector = Connector::builder()
.https()
.pin_server_certificate(ca_certificate)
.client_authentication(client_key, client_certificate)
.build()?;
Ok(Self::new_with_connector(https_connector))
}
}
impl Client where
S: Service<
(Request, C),
Response=Response,
Error=hyper::Error> + Clone + Send + Sync,
S::Future: Send + 'static,
C: Clone + Send + Sync + 'static
{
/// Constructor for creating a `Client` by passing in a pre-made `swagger::Service`
///
/// This allows adding custom wrappers around the underlying transport, for example for logging.
pub fn new_with_client_service(
client_service: S,
) -> Self {
Client {
client_service,
marker: PhantomData,
}
}
}
#[async_trait]
impl CallbackApi for Client where
S: Service<
(Request, C),
Response=Response,
Error=hyper::Error> + Clone + Send + Sync,
S::Future: Send + 'static,
S::Error: Into + fmt::Display,
C: Has {{#hasAuthMethods}}+ Has>{{/hasAuthMethods}} + Clone + Send + Sync,
{
fn poll_ready(&self, cx: &mut Context) -> Poll> {
match self.client_service.clone().poll_ready(cx) {
Poll::Ready(Err(e)) => Poll::Ready(Err(Box::new(e))),
Poll::Ready(Ok(o)) => Poll::Ready(Ok(o)),
Poll::Pending => Poll::Pending,
}
}
{{#apiInfo}}
{{#apis}}
{{#operations}}
{{#operation}}
{{#callbacks}}
{{#urls}}
{{#requests}}
{{>client-operation}}
{{/requests}}
{{/urls}}
{{/callbacks}}
{{/operation}}
{{/operations}}
{{/apis}}
{{/apiInfo}}
}
