use std::future::{Future, IntoFuture};
use std::marker::PhantomData;
use crate::OperationSubType;
use crate::RetryStrategy;
use crate::Serdes;
use crate::context::DurableContext;
use crate::engine::OperationId;
use crate::error::OperationError;
use crate::future::DurableFuture;
use crate::serdes::JsonSerdes;
use crate::{BoxError, context::StepContext};
#[must_use = "builders do nothing unless awaited or spawned"]
#[non_exhaustive]
pub struct StepBuilder<O, F, Fut, S = JsonSerdes> {
ctx: DurableContext,
op_id: OperationId,
name: Option<String>,
retry_strategy: Option<RetryStrategy>,
serdes: S,
semantics: crate::step::StepSemantics,
sub_type: Option<OperationSubType>,
closure: F,
_marker: PhantomData<fn() -> (O, Fut)>,
}
impl<O, F, Fut, S> std::fmt::Debug for StepBuilder<O, F, Fut, S> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StepBuilder")
.field("name", &self.name)
.finish_non_exhaustive()
}
}
impl<O, F, Fut> StepBuilder<O, F, Fut>
where
O: Send + 'static,
F: FnOnce(StepContext) -> Fut + Clone + Send + 'static,
Fut: Future<Output = Result<O, BoxError>> + Send + 'static,
{
pub(crate) fn new_internal(ctx: DurableContext, op_id: OperationId, closure: F) -> Self {
Self {
ctx,
op_id,
name: None,
retry_strategy: None,
serdes: JsonSerdes,
semantics: crate::step::StepSemantics::default(),
sub_type: None,
closure,
_marker: PhantomData,
}
}
}
impl<O, F, Fut, S> StepBuilder<O, F, Fut, S>
where
O: Send + 'static,
F: FnOnce(StepContext) -> Fut + Clone + Send + 'static,
Fut: Future<Output = Result<O, BoxError>> + Send + 'static,
{
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
pub fn retry_strategy<R>(mut self, strategy: R) -> Self
where
R: Fn(&crate::StepError, u32) -> crate::RetryDecision + Send + Sync + 'static,
{
self.retry_strategy = Some(Box::new(strategy));
self
}
pub fn retry_strategy_config(mut self, config: crate::builders::RetryStrategyConfig) -> Self {
self.retry_strategy = Some(config.into_retry_strategy());
self
}
pub fn serdes<S2>(self, serdes: S2) -> StepBuilder<O, F, Fut, S2>
where
S2: Serdes<O>,
{
StepBuilder {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
retry_strategy: self.retry_strategy,
serdes,
semantics: self.semantics,
sub_type: self.sub_type,
closure: self.closure,
_marker: PhantomData,
}
}
pub fn semantics(mut self, semantics: crate::step::StepSemantics) -> Self {
self.semantics = semantics;
self
}
pub fn sub_type(mut self, sub_type: OperationSubType) -> Self {
self.sub_type = Some(sub_type);
self
}
}
impl<O, F, Fut, S> StepBuilder<O, F, Fut, S>
where
O: Send + 'static,
F: FnOnce(StepContext) -> Fut + Clone + Send + 'static,
Fut: Future<Output = Result<O, BoxError>> + Send + 'static,
S: Serdes<O>,
{
pub fn future(self) -> DurableFuture<O> {
<Self as IntoFuture>::into_future(self)
}
pub fn spawn(self) -> DurableFuture<O> {
spawn_terminal!(self, started)
}
fn started_future(self) -> DurableFuture<O> {
let execution = self.execution();
match execution {
Ok(execution) => DurableFuture::for_started_operation(
&execution.ctx.clone(),
execution.execute_started(),
),
Err(future) => *future,
}
}
fn execution(self) -> Result<crate::step::StepExecution<O, F, S>, Box<DurableFuture<O>>> {
if let Err(err) = self.ctx.preflight_replay_identity(
&self.op_id,
"Step",
Some(
self.sub_type
.as_ref()
.map_or(crate::step::STEP_SUB_TYPE, OperationSubType::as_str),
),
self.name.as_deref(),
) {
return Err(Box::new(DurableFuture::from_async(async move { Err(err) })));
}
Ok(crate::step::StepExecution {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
retry_strategy: self.retry_strategy,
serdes: self.serdes,
semantics: self.semantics,
sub_type: self.sub_type.unwrap_or(OperationSubType::STEP),
plugin_name: None,
closure: self.closure,
_marker: PhantomData,
})
}
}
impl<O, F, Fut, S> IntoFuture for StepBuilder<O, F, Fut, S>
where
O: Send + 'static,
F: FnOnce(StepContext) -> Fut + Clone + Send + 'static,
Fut: Future<Output = Result<O, BoxError>> + Send + 'static,
S: Serdes<O>,
{
type Output = Result<O, OperationError>;
type IntoFuture = DurableFuture<O>;
fn into_future(self) -> Self::IntoFuture {
match self.execution() {
Ok(execution) => DurableFuture::for_start_step(&execution.ctx.clone(), move || {
execution.execute_started()
}),
Err(future) => *future,
}
}
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use super::*;
#[test]
fn sub_type_setter_replaces_and_survives_serdes() {
let ctx = DurableContext::test_context();
let builder = ctx
.step(|_| async { Ok("a".to_owned()) })
.sub_type(OperationSubType::new("First").unwrap())
.sub_type(OperationSubType::new("Second").unwrap())
.serdes(crate::PassthroughSerdes);
assert_eq!(
builder.sub_type.as_ref().map(OperationSubType::as_str),
Some("Second")
);
}
#[test]
fn retry_strategy_setter_accepts_bare_closure() {
let ctx = DurableContext::test_context();
let builder = ctx
.step(|_| async { Ok(1_i32) })
.retry_strategy(|_err, attempt| {
if attempt >= 2 {
crate::RetryDecision::Stop
} else {
crate::RetryDecision::retry(Duration::from_secs(7))
}
});
let strategy = builder
.retry_strategy
.as_ref()
.expect("retry_strategy must install a strategy");
let err = crate::StepError::new(crate::StepErrorKind::ExecutionFailed, Some("boom".into()));
assert_eq!(
strategy(&err, 1),
crate::RetryDecision::retry(Duration::from_secs(7))
);
assert_eq!(strategy(&err, 2), crate::RetryDecision::Stop);
}
}