Server Test Python

[package]

name = "json_rpc11"

version = "0.0.1"

authors = ["protocoltest@example.com"]

description = "test"

edition = "2021"

[package.metadata.smithy]

codegen-version = "ci"

protocol = "aws.protocols#awsJson1_1"

[dependencies.aws-smithy-http-server-python]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server-python"

[dependencies.aws-smithy-json]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"

[dependencies.aws-smithy-runtime-api]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"

[dependencies.aws-smithy-types]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"

[dependencies.futures-util]

version = "0.3"

[dependencies.http]

version = "0.2.9"

[dependencies.hyper]

version = "0.14.26"

[dependencies.mime]

version = "0.3"

[dependencies.parking_lot]

version = "0.12"

[dependencies.pin-project-lite]

version = "0.2"

[dependencies.pyo3]

version = "0.20"

[dependencies.pyo3-asyncio]

version = "0.20"

features = ["attributes", "tokio-runtime"]

[dependencies.tower]

version = "0.4"

[dependencies.tracing]

version = "0.1"

[dev-dependencies.tokio]

version = "1.23.1"

[features]

rt-tokio = ["aws-smithy-types/rt-tokio"]

extension-module = ["pyo3/extension-module"]

default = ["rt-tokio", "request-id", "extension-module"]

[lib]

name = "json_rpc11"

crate-type = ["cdylib"]

import typing

class MiddlewareException(Exception):

    """

    Exception that can be thrown from a Python middleware.

    It allows to specify a message and HTTP status code and implementing protocol specific capabilities

    """

    message: str

    status_code: int

    def __init__(self, message: str, status_code: typing.Optional[int] = ...) -> None:

        ...

                    message: format!(

                        "Value at '{}/label' failed to satisfy constraint: Member must not be null",

                        path

                    ),

                    path: path + "/label",

                },

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

            path: ::std::string::String,

        ) -> crate::model::ValidationExceptionField {

            match self {

                ConstraintViolation::Contents(inner) => {

                    inner.as_validation_exception_field(path + "/contents")

                }

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

            path: ::std::string::String,

        ) -> crate::model::ValidationExceptionField {

            match self {

                ConstraintViolation::IntEnumSet(inner) => {

                    inner.as_validation_exception_field(path + "/intEnumSet")

                }

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

                ConstraintViolation::FooEnumSet(inner) => {

                    inner.as_validation_exception_field(path + "/fooEnumSet")

                }

                ConstraintViolation::FooEnumMap(inner) => {

                    inner.as_validation_exception_field(path + "/fooEnumMap")

                }

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

//!

//! # let app = JsonProtocol::builder(

//! #     JsonProtocolConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let server = app.into_make_service();

//! let bind: SocketAddr = "127.0.0.1:6969".parse()

//!     .expect("unable to parse the server bind address and port");

//! ::hyper::Server::bind(&bind).serve(server).await.unwrap();

//! # }

//! ```

//!

//! ### Running on Lambda

//!

//! ```rust,ignore

//! use json_rpc11::server::routing::LambdaHandler;

//! use json_rpc11::JsonProtocol;

//!

//! # async fn dummy() {

//! # let app = JsonProtocol::builder(

//! #     JsonProtocolConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let handler = LambdaHandler::new(app);

//! lambda_http::run(handler).await.unwrap();

//! # }

//! ```

//!

//! # Building the JsonProtocol

//!

//! To construct [`JsonProtocol`] we use [`JsonProtocolBuilder`] returned by [`JsonProtocol::builder`].

//!

//! ## Plugins

//!

//! The [`JsonProtocol::builder`] method, returning [`JsonProtocolBuilder`],

//! accepts a config object on which plugins can be registered.

//! Plugins allow you to build middleware which is aware of the operation it is being applied to.

//!

//! ```rust,no_run

//! # use json_rpc11::server::plugin::IdentityPlugin as LoggingPlugin;

//! # use json_rpc11::server::plugin::IdentityPlugin as MetricsPlugin;

//! # use ::hyper::Body;

//! use json_rpc11::server::plugin::HttpPlugins;

//! use json_rpc11::{JsonProtocol, JsonProtocolConfig, JsonProtocolBuilder};

//!

//! let http_plugins = HttpPlugins::new()

//!         .push(LoggingPlugin)

//!         .push(MetricsPlugin);

//! let config = JsonProtocolConfig::builder().build();

//! ```

//!

//! Check out [`crate::server::plugin`] to learn more about plugins.

//!

//! ## Handlers

//!

//! [`JsonProtocolBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.

//! We call these async functions **handlers**. This is where your application business logic lives.

//!

//! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

//!     todo!()

//! }

//!

//! async fn sparse_nulls_operation(input: input::SparseNullsOperationInput) -> Result<output::SparseNullsOperationOutput, error::SparseNullsOperationError> {

//!     todo!()

//! }

//!

//! ```

//!

//! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve

//! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html

//! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html

//! [operations]: https://smithy.io/2.0/spec/service-types.html#operation

//! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html

pub use crate::service::{

    JsonProtocol, JsonProtocolBuilder, JsonProtocolConfig, JsonProtocolConfigBuilder,

    MissingOperationsError,

};

/// Contains the types that are re-exported from the `aws-smithy-http-server` crate.

pub mod server {

    // Re-export all types from the `aws-smithy-http-server` crate.

}

/// Crate version number.

pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

/// Constrained types for constrained shapes.

mod constrained;

/// All error types that operations can return. Documentation on these types is copied from the model.

pub mod error;

/// Input structures for operations. Documentation on these types is copied from the model.

pub mod input;

/// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.

pub mod model;

/// All operations that this crate can perform.

pub mod operation;

/// A collection of types representing each operation defined in the service closure.

///

/// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to

/// operation specific information to the [`Layer`](::tower::Layer) being applied.

pub mod operation_shape;

/// Output structures for operations. Documentation on these types is copied from the model.

pub mod output;

/// Export PyO3 symbols in the shared library

pub mod python_module_export;

/// Operation adapters that delegate to Python handlers.

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`ContentTypeParametersInput`](crate::input::ContentTypeParametersInput) using modelled bindings.

    pub struct ContentTypeParametersInputFuture {

    }

}

impl std::future::Future for ContentTypeParametersInputFuture {

    type Output = Result<

        crate::input::ContentTypeParametersInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::ContentTypeParametersInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = ContentTypeParametersInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_X_AMZ_JSON_1_1,

            ) {

            }

            crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

        ContentTypeParametersInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::ContentTypeParametersOutput

{

        match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::ContentTypeParametersError

{

        match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_error(&self) {

            Ok(mut response) => {

                response

            },

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`PutWithContentEncodingInput`](crate::input::PutWithContentEncodingInput) using modelled bindings.

    pub struct PutWithContentEncodingInputFuture {

    }

}

impl std::future::Future for PutWithContentEncodingInputFuture {

    type Output = Result<

        crate::input::PutWithContentEncodingInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::PutWithContentEncodingInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = PutWithContentEncodingInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_X_AMZ_JSON_1_1,

            ) {

            }

            crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

        PutWithContentEncodingInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::PutWithContentEncodingOutput

{

        match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::PutWithContentEncodingError

{

        match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_error(&self) {

            Ok(mut response) => {

                response

            },

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`FractionalSecondsInput`](crate::input::FractionalSecondsInput) using modelled bindings.

    pub struct FractionalSecondsInputFuture {

    }

}

impl std::future::Future for FractionalSecondsInputFuture {

    type Output = Result<

        crate::input::FractionalSecondsInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::FractionalSecondsInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = FractionalSecondsInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_X_AMZ_JSON_1_1,

            ) {

            }

            crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(

                request,

            )

            .await

        };

        use ::futures_util::future::TryFutureExt;

        FractionalSecondsInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::FractionalSecondsOutput

{

        match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(

            self,

        ) {

            Ok(response) => response,

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

impl

    > for crate::error::FractionalSecondsError

{

        match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_error(

            &self,

        ) {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`DatetimeOffsetsInput`](crate::input::DatetimeOffsetsInput) using modelled bindings.

    pub struct DatetimeOffsetsInputFuture {

    }

}

impl std::future::Future for DatetimeOffsetsInputFuture {

    type Output = Result<

        crate::input::DatetimeOffsetsInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::DatetimeOffsetsInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = DatetimeOffsetsInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_X_AMZ_JSON_1_1,

            ) {

            }

            crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)

                .await

        };

        use ::futures_util::future::TryFutureExt;

        DatetimeOffsetsInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::DatetimeOffsetsOutput

{

        match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(

            self,

        ) {

            Ok(response) => response,

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

impl

    > for crate::error::DatetimeOffsetsError

{

        match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_error(&self)

        {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`HostWithPathOperationInput`](crate::input::HostWithPathOperationInput) using modelled bindings.

    pub struct HostWithPathOperationInputFuture {

    }

}

impl std::future::Future for HostWithPathOperationInputFuture {

    type Output = Result<

        crate::input::HostWithPathOperationInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::HostWithPathOperationInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = HostWithPathOperationInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_X_AMZ_JSON_1_1,

            ) {

            }

            crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

        HostWithPathOperationInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::HostWithPathOperationOutput

{

        match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }