#[async_trait::async_trait]
impl<B, Fun, Fut>
crate::server_operation_handler_trait::Handler<B, (), crate::input::HealthcheckOperationInput>
for Fun
where
Fun: FnOnce(crate::input::HealthcheckOperationInput) -> Fut + Clone + Send + 'static,
Fut: std::future::Future<
Output = Result<
crate::output::HealthcheckOperationOutput,
crate::error::HealthcheckOperationError,
>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::HealthcheckOperationOperationInputWrapper::from_request(
&mut req,
)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner).await;
let output_wrapper: crate::operation::HealthcheckOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut>
crate::server_operation_handler_trait::Handler<B, (), crate::input::ListOperationInput> for Fun
where
Fun: FnOnce(crate::input::ListOperationInput) -> Fut + Clone + Send + 'static,
Fut: std::future::Future<Output = crate::output::ListOperationOutput> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::ListOperationOperationInputWrapper::from_request(&mut req).await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner).await;
let output_wrapper: crate::operation::ListOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut>
crate::server_operation_handler_trait::Handler<
B,
(),
crate::input::PrometheusTargetOperationInput,
> for Fun
where
Fun: FnOnce(crate::input::PrometheusTargetOperationInput) -> Fut + Clone + Send + 'static,
Fut: std::future::Future<
Output = Result<
crate::output::PrometheusTargetOperationOutput,
crate::error::PrometheusTargetOperationError,
>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::PrometheusTargetOperationOperationInputWrapper::from_request(
&mut req,
)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner).await;
let output_wrapper: crate::operation::PrometheusTargetOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut>
crate::server_operation_handler_trait::Handler<B, (), crate::input::RestartOperationInput>
for Fun
where
Fun: FnOnce(crate::input::RestartOperationInput) -> Fut + Clone + Send + 'static,
Fut: std::future::Future<
Output = Result<
crate::output::RestartOperationOutput,
crate::error::RestartOperationError,
>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::RestartOperationOperationInputWrapper::from_request(&mut req)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner).await;
let output_wrapper: crate::operation::RestartOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut>
crate::server_operation_handler_trait::Handler<B, (), crate::input::StartOperationInput> for Fun
where
Fun: FnOnce(crate::input::StartOperationInput) -> Fut + Clone + Send + 'static,
Fut: std::future::Future<
Output = Result<crate::output::StartOperationOutput, crate::error::StartOperationError>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::StartOperationOperationInputWrapper::from_request(&mut req)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner).await;
let output_wrapper: crate::operation::StartOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut>
crate::server_operation_handler_trait::Handler<B, (), crate::input::StopOperationInput> for Fun
where
Fun: FnOnce(crate::input::StopOperationInput) -> Fut + Clone + Send + 'static,
Fut: std::future::Future<
Output = Result<crate::output::StopOperationOutput, crate::error::StopOperationError>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::StopOperationOperationInputWrapper::from_request(&mut req).await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner).await;
let output_wrapper: crate::operation::StopOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut, S>
crate::server_operation_handler_trait::Handler<
B,
aws_smithy_http_server::Extension<S>,
crate::input::HealthcheckOperationInput,
> for Fun
where
S: Send + Clone + Sync + 'static,
Fun: FnOnce(crate::input::HealthcheckOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
+ Clone
+ Send
+ 'static,
Fut: std::future::Future<
Output = Result<
crate::output::HealthcheckOperationOutput,
crate::error::HealthcheckOperationError,
>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::HealthcheckOperationOperationInputWrapper::from_request(
&mut req,
)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner, state).await;
let output_wrapper: crate::operation::HealthcheckOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut, S>
crate::server_operation_handler_trait::Handler<
B,
aws_smithy_http_server::Extension<S>,
crate::input::ListOperationInput,
> for Fun
where
S: Send + Clone + Sync + 'static,
Fun: FnOnce(crate::input::ListOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
+ Clone
+ Send
+ 'static,
Fut: std::future::Future<Output = crate::output::ListOperationOutput> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::ListOperationOperationInputWrapper::from_request(&mut req).await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner, state).await;
let output_wrapper: crate::operation::ListOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut, S>
crate::server_operation_handler_trait::Handler<
B,
aws_smithy_http_server::Extension<S>,
crate::input::PrometheusTargetOperationInput,
> for Fun
where
S: Send + Clone + Sync + 'static,
Fun: FnOnce(
crate::input::PrometheusTargetOperationInput,
aws_smithy_http_server::Extension<S>,
) -> Fut
+ Clone
+ Send
+ 'static,
Fut: std::future::Future<
Output = Result<
crate::output::PrometheusTargetOperationOutput,
crate::error::PrometheusTargetOperationError,
>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::PrometheusTargetOperationOperationInputWrapper::from_request(
&mut req,
)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner, state).await;
let output_wrapper: crate::operation::PrometheusTargetOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut, S>
crate::server_operation_handler_trait::Handler<
B,
aws_smithy_http_server::Extension<S>,
crate::input::RestartOperationInput,
> for Fun
where
S: Send + Clone + Sync + 'static,
Fun: FnOnce(crate::input::RestartOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
+ Clone
+ Send
+ 'static,
Fut: std::future::Future<
Output = Result<
crate::output::RestartOperationOutput,
crate::error::RestartOperationError,
>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::RestartOperationOperationInputWrapper::from_request(&mut req)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner, state).await;
let output_wrapper: crate::operation::RestartOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut, S>
crate::server_operation_handler_trait::Handler<
B,
aws_smithy_http_server::Extension<S>,
crate::input::StartOperationInput,
> for Fun
where
S: Send + Clone + Sync + 'static,
Fun: FnOnce(crate::input::StartOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
+ Clone
+ Send
+ 'static,
Fut: std::future::Future<
Output = Result<crate::output::StartOperationOutput, crate::error::StartOperationError>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::StartOperationOperationInputWrapper::from_request(&mut req)
.await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner, state).await;
let output_wrapper: crate::operation::StartOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}
#[async_trait::async_trait]
impl<B, Fun, Fut, S>
crate::server_operation_handler_trait::Handler<
B,
aws_smithy_http_server::Extension<S>,
crate::input::StopOperationInput,
> for Fun
where
S: Send + Clone + Sync + 'static,
Fun: FnOnce(crate::input::StopOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
+ Clone
+ Send
+ 'static,
Fut: std::future::Future<
Output = Result<crate::output::StopOperationOutput, crate::error::StopOperationError>,
> + Send,
B: aws_smithy_http_server::HttpBody + Send + 'static,
B::Data: Send,
B::Error: Into<aws_smithy_http_server::BoxError>,
aws_smithy_http_server::rejection::SmithyRejection:
From<<B as aws_smithy_http_server::HttpBody>::Error>,
{
type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
let mut req = axum_core::extract::RequestParts::new(req);
use axum_core::extract::FromRequest;
use axum_core::response::IntoResponse;
let input_wrapper =
match crate::operation::StopOperationOperationInputWrapper::from_request(&mut req).await
{
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
Ok(v) => v,
Err(r) => {
let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
let mut response = r.into_response();
response.extensions_mut().insert(error);
return response.map(aws_smithy_http_server::boxed);
}
};
let input_inner = input_wrapper.into();
let output_inner = self(input_inner, state).await;
let output_wrapper: crate::operation::StopOperationOperationOutputWrapper =
output_inner.into();
output_wrapper
.into_response()
.map(aws_smithy_http_server::boxed)
}
}