use std::future::{Future, IntoFuture};
use std::marker::PhantomData;
use std::time::Duration;
use crate::BoxError;
use crate::OperationSubType;
use crate::RetryStrategy;
use crate::Serdes;
use crate::context::DurableContext;
use crate::context::StepContext;
use crate::engine::OperationId;
use crate::error::OperationError;
use crate::future::DurableFuture;
use crate::serdes::JsonSerdes;
pub use crate::future::Callback;
#[must_use = "builders do nothing unless awaited or spawned"]
#[non_exhaustive]
pub struct CreateCallbackBuilder<O, S = JsonSerdes> {
ctx: DurableContext,
op_id: OperationId,
name: Option<String>,
timeout: Option<Duration>,
heartbeat_timeout: Option<Duration>,
sub_type: Option<OperationSubType>,
serdes: S,
_marker: PhantomData<O>,
}
impl<O, S> std::fmt::Debug for CreateCallbackBuilder<O, S> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CreateCallbackBuilder")
.field("name", &self.name)
.finish_non_exhaustive()
}
}
impl<O: Send + 'static> CreateCallbackBuilder<O> {
pub(crate) fn new_internal(ctx: DurableContext, op_id: OperationId) -> Self {
Self {
ctx,
op_id,
name: None,
timeout: None,
heartbeat_timeout: None,
sub_type: None,
serdes: JsonSerdes,
_marker: PhantomData,
}
}
}
impl<O: Send + 'static, S> CreateCallbackBuilder<O, S> {
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn heartbeat_timeout(mut self, timeout: Duration) -> Self {
self.heartbeat_timeout = Some(timeout);
self
}
pub fn sub_type(mut self, sub_type: OperationSubType) -> Self {
self.sub_type = Some(sub_type);
self
}
pub fn serdes<S2>(self, serdes: S2) -> CreateCallbackBuilder<O, S2>
where
S2: Serdes<O>,
{
CreateCallbackBuilder {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
timeout: self.timeout,
heartbeat_timeout: self.heartbeat_timeout,
sub_type: self.sub_type,
serdes,
_marker: PhantomData,
}
}
pub fn future(self) -> DurableFuture<Callback<O>>
where
S: Serdes<O>,
{
self.into_future()
}
pub fn spawn(self) -> DurableFuture<Callback<O>>
where
S: Serdes<O>,
{
spawn_terminal!(self, started)
}
fn started_future(self) -> DurableFuture<Callback<O>>
where
S: Serdes<O>,
{
match self.execution() {
Ok(execution) => DurableFuture::for_started_operation(
&execution.ctx.clone(),
execution.execute_started(),
),
Err(future) => *future,
}
}
fn execution(
self,
) -> Result<crate::callback::CreateCallbackExecution<O, S>, Box<DurableFuture<Callback<O>>>>
{
if let Err(err) = self.ctx.preflight_replay_identity(
&self.op_id,
"Callback",
Some(
self.sub_type
.as_ref()
.map_or(crate::callback::CALLBACK_SUB_TYPE, OperationSubType::as_str),
),
self.name.as_deref(),
) {
return Err(Box::new(DurableFuture::from_async(async move { Err(err) })));
}
Ok(crate::callback::CreateCallbackExecution {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
timeout: self.timeout,
heartbeat: self.heartbeat_timeout,
sub_type: self.sub_type.unwrap_or(OperationSubType::CALLBACK),
plugin_name: None,
serdes: self.serdes,
_marker: PhantomData,
})
}
}
impl<O, S> IntoFuture for CreateCallbackBuilder<O, S>
where
O: Send + 'static,
S: Serdes<O>,
{
type Output = Result<Callback<O>, OperationError>;
type IntoFuture = DurableFuture<Callback<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,
}
}
}
pub trait Submitter:
FnOnce(StepContext, String) -> <Self as Submitter>::Fut + Clone + Send + 'static
{
type Fut: Future<Output = Result<(), BoxError>> + Send + 'static;
}
impl<F, Fut> Submitter for F
where
F: FnOnce(StepContext, String) -> Fut + Clone + Send + 'static,
Fut: Future<Output = Result<(), BoxError>> + Send + 'static,
{
type Fut = Fut;
}
#[must_use = "builders do nothing unless awaited or spawned"]
#[non_exhaustive]
pub struct WaitForCallbackBuilder<O, F, S = JsonSerdes> {
ctx: DurableContext,
op_id: OperationId,
name: Option<String>,
timeout: Option<Duration>,
heartbeat_timeout: Option<Duration>,
submitter: F,
submitter_retry: Option<RetryStrategy>,
serdes: S,
_marker: PhantomData<fn() -> O>,
}
impl<O, F, S> std::fmt::Debug for WaitForCallbackBuilder<O, F, S> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("WaitForCallbackBuilder")
.field("name", &self.name)
.finish_non_exhaustive()
}
}
impl<O, F> WaitForCallbackBuilder<O, F>
where
O: Send + 'static,
F: Submitter,
{
pub(crate) fn new_internal(ctx: DurableContext, op_id: OperationId, submitter: F) -> Self {
Self {
ctx,
op_id,
name: None,
timeout: None,
heartbeat_timeout: None,
submitter,
submitter_retry: None,
serdes: JsonSerdes,
_marker: PhantomData,
}
}
}
impl<O, F, S> WaitForCallbackBuilder<O, F, S>
where
O: Send + 'static,
F: Submitter,
{
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
self
}
pub fn submitter_retry<R>(mut self, strategy: R) -> Self
where
R: Fn(&crate::StepError, u32) -> crate::RetryDecision + Send + Sync + 'static,
{
self.submitter_retry = Some(Box::new(strategy));
self
}
pub fn submitter_retry_config(mut self, config: crate::builders::RetryStrategyConfig) -> Self {
self.submitter_retry = Some(config.into_retry_strategy());
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn heartbeat_timeout(mut self, timeout: Duration) -> Self {
self.heartbeat_timeout = Some(timeout);
self
}
pub fn serdes<S2>(self, serdes: S2) -> WaitForCallbackBuilder<O, F, S2>
where
S2: Serdes<O>,
{
WaitForCallbackBuilder {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
timeout: self.timeout,
heartbeat_timeout: self.heartbeat_timeout,
submitter: self.submitter,
submitter_retry: self.submitter_retry,
serdes,
_marker: PhantomData,
}
}
}
impl<O, F, S> WaitForCallbackBuilder<O, F, S>
where
O: Send + 'static,
F: Submitter,
S: Serdes<O>,
{
pub fn future(self) -> DurableFuture<O> {
self.into_future()
}
pub fn spawn(self) -> DurableFuture<O> {
spawn_terminal!(self, started)
}
fn started_future(self) -> DurableFuture<O> {
match self.execution() {
Ok(execution) => DurableFuture::for_started_operation(
&execution.ctx.clone(),
execution.execute_started(),
),
Err(future) => *future,
}
}
fn execution(
self,
) -> Result<crate::callback::WaitForCallbackExecution<O, F, S>, Box<DurableFuture<O>>> {
if let Err(err) = self.ctx.preflight_replay_identity(
&self.op_id,
"Context",
Some(crate::callback::WFCB_SUB_TYPE),
self.name.as_deref(),
) {
return Err(Box::new(DurableFuture::from_async(async move { Err(err) })));
}
Ok(crate::callback::WaitForCallbackExecution {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
timeout: self.timeout,
heartbeat: self.heartbeat_timeout,
submitter: self.submitter,
submitter_retry: self.submitter_retry,
serdes: self.serdes,
_marker: PhantomData,
})
}
}
impl<O, F, S> IntoFuture for WaitForCallbackBuilder<O, F, S>
where
O: Send + 'static,
F: Submitter,
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 super::*;
#[test]
fn sub_type_setter_replaces_and_survives_serdes() {
let ctx = DurableContext::test_context();
let builder = ctx
.create_callback::<String>()
.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 heartbeat_timeout_setter_replaces_and_survives_serdes() {
let ctx = DurableContext::test_context();
let create = ctx
.create_callback::<String>()
.heartbeat_timeout(Duration::from_secs(30))
.heartbeat_timeout(Duration::from_secs(90))
.serdes(crate::PassthroughSerdes);
assert_eq!(create.heartbeat_timeout, Some(Duration::from_secs(90)));
let wait = ctx
.wait_for_callback::<String>(|_step_ctx, _cb_id| async { Ok(()) })
.heartbeat_timeout(Duration::from_secs(30))
.heartbeat_timeout(Duration::from_secs(90))
.serdes(crate::PassthroughSerdes);
assert_eq!(wait.heartbeat_timeout, Some(Duration::from_secs(90)));
}
#[test]
fn submitter_retry_setter_accepts_bare_closure() {
let ctx = DurableContext::test_context();
let builder = ctx
.wait_for_callback::<String>(|_step_ctx, _cb_id| async { Ok(()) })
.submitter_retry(|_err, _attempt| crate::RetryDecision::Stop);
let strategy = builder
.submitter_retry
.as_ref()
.expect("submitter_retry must install a strategy");
let err = crate::StepError::new(crate::StepErrorKind::ExecutionFailed, Some("boom".into()));
assert_eq!(strategy(&err, 1), crate::RetryDecision::Stop);
}
}