61 lines
1.7 KiB
Rust
61 lines
1.7 KiB
Rust
mod client;
|
|
mod error;
|
|
mod model;
|
|
|
|
use async_trait::async_trait;
|
|
use crank_core::{
|
|
AdapterResponse, ExecutionMode, PreparedRequest, Protocol, ProtocolAdapter,
|
|
ProtocolAdapterError, RestTarget, RuntimeRequestContext, Target,
|
|
};
|
|
|
|
pub use client::{OutboundHttpPolicy, RestAdapter};
|
|
pub use error::RestAdapterError;
|
|
pub use model::{RestRequest, RestResponse};
|
|
|
|
#[async_trait]
|
|
impl ProtocolAdapter for RestAdapter {
|
|
fn protocol(&self) -> Protocol {
|
|
Protocol::Rest
|
|
}
|
|
|
|
fn supports_mode(&self, mode: ExecutionMode) -> bool {
|
|
matches!(mode, ExecutionMode::Unary)
|
|
}
|
|
|
|
async fn invoke_unary(
|
|
&self,
|
|
target: &Target,
|
|
prepared: &PreparedRequest,
|
|
context: &RuntimeRequestContext,
|
|
) -> Result<AdapterResponse, ProtocolAdapterError> {
|
|
let target = rest_target(target)?;
|
|
let request = RestRequest {
|
|
path_params: prepared.path_params.clone(),
|
|
query_params: prepared.query_params.clone(),
|
|
headers: prepared.headers.clone(),
|
|
body: prepared.body.clone(),
|
|
timeout_ms: prepared.timeout_ms,
|
|
};
|
|
let response = self.execute_with_context(target, &request, context).await?;
|
|
|
|
Ok(AdapterResponse {
|
|
status_code: response.status_code,
|
|
headers: response.headers,
|
|
data: response.body.clone(),
|
|
body: response.body,
|
|
})
|
|
}
|
|
}
|
|
|
|
fn rest_target(target: &Target) -> Result<&RestTarget, ProtocolAdapterError> {
|
|
match target {
|
|
Target::Rest(target) => Ok(target),
|
|
}
|
|
}
|
|
|
|
impl From<RestAdapterError> for ProtocolAdapterError {
|
|
fn from(value: RestAdapterError) -> Self {
|
|
ProtocolAdapterError::Message(value.to_string())
|
|
}
|
|
}
|