use crate::policies::TransportPolicy;
use crate::policies::{CustomHeadersPolicy, Policy, TelemetryPolicy};
use crate::{ClientOptions, Context, Request, Response};
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct Pipeline {
pipeline: Vec<Arc<dyn Policy>>,
}
impl Pipeline {
pub fn new(
crate_name: Option<&'static str>,
crate_version: Option<&'static str>,
options: ClientOptions,
per_call_policies: Vec<Arc<dyn Policy>>,
per_retry_policies: Vec<Arc<dyn Policy>>,
) -> Self {
let mut pipeline: Vec<Arc<dyn Policy>> = Vec::with_capacity(
options.per_call_policies.len()
+ per_call_policies.len()
+ options.per_retry_policies.len()
+ per_retry_policies.len()
+ 3,
);
pipeline.extend_from_slice(&per_call_policies);
pipeline.extend_from_slice(&options.per_call_policies);
let telemetry_policy = TelemetryPolicy::new(crate_name, crate_version, &options.telemetry);
pipeline.push(Arc::new(telemetry_policy));
pipeline.push(Arc::new(CustomHeadersPolicy::default()));
let retry_policy = options.retry.to_policy();
pipeline.push(retry_policy);
pipeline.extend_from_slice(&per_retry_policies);
pipeline.extend_from_slice(&options.per_retry_policies);
let transport: Arc<dyn Policy> = Arc::new(TransportPolicy::new(options.transport.clone()));
pipeline.push(transport);
Self { pipeline }
}
pub fn replace_policy(&mut self, policy: Arc<dyn Policy>, position: usize) -> Arc<dyn Policy> {
std::mem::replace(&mut self.pipeline[position], policy)
}
pub fn policies(&self) -> &[Arc<dyn Policy>] {
&self.pipeline
}
pub async fn send(&self, ctx: &mut Context, request: &mut Request) -> crate::Result<Response> {
self.pipeline[0]
.send(ctx, request, &self.pipeline[1..])
.await
}
}