use std::future::{Future, IntoFuture};
use std::marker::PhantomData;
use crate::BoxError;
use crate::OperationSubType;
use crate::Serdes;
use crate::context::DurableContext;
use crate::engine::OperationId;
use crate::error::OperationError;
use crate::future::DurableFuture;
use crate::serdes::JsonSerdes;
#[must_use = "builders do nothing unless awaited or spawned"]
#[non_exhaustive]
pub struct ChildBuilder<O, F, Fut, S = JsonSerdes> {
ctx: DurableContext,
op_id: OperationId,
name: Option<String>,
sub_type: Option<OperationSubType>,
serdes: S,
closure: F,
user_function: crate::child::UserFunctionPolicy,
summary: Option<crate::child::ChildSummary<O>>,
is_virtual: bool,
_marker: PhantomData<fn() -> (O, Fut)>,
}
impl<O, F, Fut, S> std::fmt::Debug for ChildBuilder<O, F, Fut, S> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChildBuilder")
.field("name", &self.name)
.finish_non_exhaustive()
}
}
impl<O, F, Fut> ChildBuilder<O, F, Fut>
where
O: Send + 'static,
F: FnOnce(DurableContext) -> Fut + 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,
sub_type: None,
serdes: JsonSerdes,
closure,
user_function: crate::child::UserFunctionPolicy::Hooks,
summary: None,
is_virtual: false,
_marker: PhantomData,
}
}
}
impl<O, F, Fut, S> ChildBuilder<O, F, Fut, S>
where
O: Send + 'static,
F: FnOnce(DurableContext) -> Fut + Send + 'static,
Fut: Future<Output = Result<O, BoxError>> + Send + 'static,
{
pub(crate) fn without_user_function(mut self) -> Self {
self.user_function = crate::child::UserFunctionPolicy::None;
self
}
pub fn name(mut self, name: impl Into<String>) -> Self {
self.name = Some(name.into());
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) -> ChildBuilder<O, F, Fut, S2>
where
S2: Serdes<O>,
{
ChildBuilder {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
sub_type: self.sub_type,
serdes,
closure: self.closure,
user_function: self.user_function,
summary: self.summary,
is_virtual: self.is_virtual,
_marker: PhantomData,
}
}
pub fn summary(mut self, summary: impl Fn(&O) -> String + Send + Sync + 'static) -> Self {
self.summary = Some(Box::new(summary));
self
}
pub fn virtual_context(mut self) -> Self {
self.is_virtual = true;
self
}
pub fn future(self) -> DurableFuture<O>
where
S: Serdes<O>,
{
<Self as IntoFuture>::into_future(self)
}
pub fn spawn(self) -> DurableFuture<O>
where
S: Serdes<O>,
{
spawn_terminal!(self, started)
}
}
impl<O, F, Fut, S> ChildBuilder<O, F, Fut, S>
where
O: Send + 'static,
F: FnOnce(DurableContext) -> Fut + Send + 'static,
Fut: Future<Output = Result<O, BoxError>> + Send + 'static,
S: Serdes<O>,
{
fn build(self, started: bool) -> DurableFuture<O> {
use crate::child::ChildExecution;
if self.is_virtual {
return self.build_virtual();
}
preflight_identity!(
self,
"Context",
self.sub_type
.as_ref()
.map_or(crate::child::CHILD_SUB_TYPE, OperationSubType::as_str)
);
let execution = ChildExecution {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
sub_type: self
.sub_type
.unwrap_or(OperationSubType::RUN_IN_CHILD_CONTEXT),
serdes: self.serdes,
closure: self.closure,
user_function: self.user_function,
summary: self.summary,
_marker: PhantomData,
};
if started {
DurableFuture::for_started_operation(
&execution.ctx.clone(),
execution.execute_started(),
)
} else {
DurableFuture::for_start_step(&execution.ctx.clone(), move || {
execution.execute_started()
})
}
}
fn build_virtual(self) -> DurableFuture<O> {
use crate::child::ChildExecution;
let sub_type = self
.sub_type
.unwrap_or(OperationSubType::RUN_IN_CHILD_CONTEXT);
if let Err(err) = self.ctx.reject_record_at_virtual_child(
&self.op_id,
sub_type.as_str(),
self.name.as_deref(),
) {
return DurableFuture::from_async(async move { Err(err) });
}
let execution = ChildExecution {
ctx: self.ctx,
op_id: self.op_id,
name: self.name,
sub_type,
serdes: self.serdes,
closure: self.closure,
user_function: self.user_function,
summary: None,
_marker: PhantomData,
};
DurableFuture::for_operation(&execution.ctx.clone(), execution.execute_virtual())
}
fn started_future(self) -> DurableFuture<O> {
self.build(true)
}
}
impl<O, F, Fut, S> IntoFuture for ChildBuilder<O, F, Fut, S>
where
O: Send + 'static,
F: FnOnce(DurableContext) -> Fut + 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 {
self.build(false)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sub_type_setter_replaces_and_survives_serdes() {
let ctx = DurableContext::test_context();
let builder = ctx
.run_in_child_context(|_child| async { Ok(1_u32) })
.sub_type(OperationSubType::new("First").unwrap())
.sub_type(OperationSubType::new("Second").unwrap())
.serdes(std::sync::Arc::new(JsonSerdes));
assert_eq!(
builder.sub_type.as_ref().map(OperationSubType::as_str),
Some("Second")
);
}
#[test]
fn virtual_context_setter_survives_serdes() {
let ctx = DurableContext::test_context();
let plain = ctx.run_in_child_context(|_child| async { Ok(1_u32) });
assert!(!plain.is_virtual);
let builder = ctx
.run_in_child_context(|_child| async { Ok(1_u32) })
.virtual_context()
.serdes(std::sync::Arc::new(JsonSerdes));
assert!(builder.is_virtual);
}
#[test]
fn summary_setter_replaces_and_survives_serdes() {
let ctx = DurableContext::test_context();
let builder = ctx
.run_in_child_context(|_child| async { Ok(1_u32) })
.summary(|v: &u32| format!("first {v}"))
.summary(|v: &u32| format!("second {v}"))
.serdes(std::sync::Arc::new(JsonSerdes));
let summary = builder.summary.as_ref().expect("the summary is kept");
assert_eq!(summary(&7), "second 7");
}
}