use crate::bus::StreamError;
use crate::channels::{
JobCancelRequested, JobComplete, JobCreate, JobFail, JobReportProgress, JobStatusRequested,
};
use crate::client::Links;
use crate::errors::{
BusRequestError, BusRequestErrorCode, JobError, JobErrorCode, SemiontError, TransportError,
TransportErrorCode,
};
use crate::running::{Reporter, Running};
use crate::transport::{BoxFuture, FrameRefusal, FrameRefusalReason};
use crate::types::{
FailureClass, JobCancelRequest, JobCompleteCommand, JobCreateCommand, JobCreatedResult,
JobCreatedResultResponse, JobFailCommand, JobId, JobProgress, JobReportProgressCommand,
JobStatusRequest, JobStatusResponse, JobStatusResponseStatus, JobStoredResult,
MarkJobCompleteCommand, ResourceId, YieldJobCompleteCommand,
};
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use std::future::Future;
use std::time::Duration;
use tokio::time::Instant;
#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
#[serde(tag = "kind", content = "data", rename_all = "lowercase")]
pub enum JobEvent<C> {
Created(JobCreatedResultResponse),
Progress(JobProgress),
Failed(JobFailCommand),
Refused {
channel: String,
member: String,
reason: FrameRefusalReason,
},
Complete(C),
}
impl<C> From<C> for JobEvent<C> {
fn from(completion: C) -> JobEvent<C> {
JobEvent::Complete(completion)
}
}
pub type Delegation<C> = Running<JobEvent<C>, C>;
pub(crate) trait Completion: Sized + Send + 'static {
fn of_frame(frame: JobCompleteCommand) -> Option<Self>;
fn of_status(status: JobStatusResponse, resource_id: ResourceId) -> Option<Self>;
}
fn stored_as<R: DeserializeOwned>(stored: Option<JobStoredResult>) -> Option<Option<R>> {
match stored {
Some(JobStoredResult::JobResult(result)) => {
let said = serde_json::to_value(result).ok()?;
serde_json::from_value(said).ok().map(Some)
}
Some(JobStoredResult::Empty(_)) | None => Some(None),
}
}
macro_rules! completion {
($member:ident) => {
impl Completion for $member {
fn of_frame(frame: JobCompleteCommand) -> Option<Self> {
match frame {
JobCompleteCommand::$member(done) => Some(done),
_ => None,
}
}
fn of_status(status: JobStatusResponse, resource_id: ResourceId) -> Option<Self> {
let done = $member::new(resource_id, status.job_id);
if done.job_type.as_str() != status.r#type.as_str() {
return None;
}
Some($member {
result: stored_as(status.result)?,
..done
})
}
}
};
}
completion!(MarkJobCompleteCommand);
completion!(YieldJobCompleteCommand);
pub(crate) struct Following {
pub create: JobCreateCommand,
pub resource_id: ResourceId,
pub stall: Option<Duration>,
}
pub(crate) fn follow<C: Completion>(links: Links, following: Following) -> Delegation<C> {
Running::new(move |reporter| followed(links, following, reporter))
}
fn completed_job(frame: &JobCompleteCommand) -> &JobId {
match frame {
JobCompleteCommand::MarkJobCompleteCommand(done) => &done.job_id,
JobCompleteCommand::YieldJobCompleteCommand(done) => &done.job_id,
}
}
enum Heard {
Progress(JobReportProgressCommand),
Complete(JobCompleteCommand),
Fail(JobFailCommand),
Refused(Box<FrameRefusal>),
}
impl Heard {
fn job_id(&self) -> Option<&JobId> {
match self {
Heard::Progress(frame) => Some(&frame.job_id),
Heard::Complete(frame) => Some(completed_job(frame)),
Heard::Fail(frame) => Some(&frame.job_id),
Heard::Refused(_) => None,
}
}
}
enum Step {
Created(Result<JobCreatedResult, SemiontError>),
Heard(Heard),
Missed,
Ended,
AskDue,
Status(Result<JobStatusResponse, SemiontError>),
Stalled,
}
async fn when<F: Future + Unpin>(future: &mut Option<F>) -> F::Output {
match future {
Some(future) => future.await,
None => std::future::pending().await,
}
}
async fn at(deadline: Option<Instant>) {
match deadline {
Some(deadline) => tokio::time::sleep_until(deadline).await,
None => std::future::pending().await,
}
}
fn heard<T>(item: Option<Result<T, StreamError>>, of: impl FnOnce(T) -> Heard) -> Step {
match item {
Some(Ok(frame)) => Step::Heard(of(frame)),
Some(Err(StreamError::Lagged(_))) => Step::Missed,
Some(Err(StreamError::Refused(refusal))) => Step::Heard(Heard::Refused(refusal)),
None => Step::Ended,
}
}
fn failed(job_id: &JobId, message: String, failure_class: Option<FailureClass>) -> SemiontError {
JobError {
code: JobErrorCode::Failed,
job_id: Some(job_id.clone()),
message,
failure_class,
}
.into()
}
fn not_the_verbs(job_id: &JobId, said_in: &str) -> SemiontError {
TransportError::without_response(
format!("{said_in} of job {job_id} is not a completion of the verb that was delegated"),
TransportErrorCode::Error,
)
.into()
}
async fn followed<C: Completion>(
links: Links,
following: Following,
reporter: Reporter<JobEvent<C>>,
) -> Result<C, SemiontError> {
let Following {
create,
resource_id,
stall,
} = following;
let mut progress = links.own.stream::<JobReportProgress>();
let mut complete = links.own.stream::<JobComplete>();
let mut fail = links.own.stream::<JobFail>();
let mut creating: Option<BoxFuture<'_, Result<JobCreatedResult, SemiontError>>> =
Some(Box::pin(links.request::<JobCreate>(&create)));
let mut job_id: Option<JobId> = None;
let mut held: Vec<Heard> = Vec::new();
let mut ask_at: Option<Instant> = None;
let mut asking: Option<BoxFuture<'static, Result<JobStatusResponse, SemiontError>>> = None;
let mut stall_at = stall.map(|within| Instant::now() + within);
loop {
let stalled = stall_at.is_some_and(|deadline| Instant::now() >= deadline);
let step = tokio::select! {
biased;
() = std::future::ready(()), if stalled => Step::Stalled,
created = when(&mut creating) => Step::Created(created),
item = progress.next() => heard(item.map(|i| i.map(|d| d.payload)), Heard::Progress),
item = fail.next() => heard(item.map(|i| i.map(|d| d.payload)), Heard::Fail),
item = complete.next() => heard(item.map(|i| i.map(|d| d.payload)), Heard::Complete),
status = when(&mut asking) => Step::Status(status),
() = at(ask_at) => Step::AskDue,
() = at(stall_at) => Step::Stalled,
};
let mut frames = Vec::new();
match step {
Step::Created(created) => {
creating = None;
let created = created?.response;
job_id = Some(created.job_id.clone());
reporter.report(JobEvent::Created(created));
ask_at = Some(Instant::now() + links.timing.job_silence);
frames = std::mem::take(&mut held);
}
Step::Heard(frame) if job_id.is_none() => held.push(frame),
Step::Heard(frame) => frames.push(frame),
Step::Ended => {
return Err(BusRequestError::new(
BusRequestErrorCode::Closed,
"The client closed while it was following a job",
)
.into());
}
Step::Missed => ask_at = job_id.as_ref().map(|_| Instant::now()),
Step::AskDue => {
ask_at = Some(Instant::now() + links.timing.job_status_poll);
if let (None, Some(job_id)) = (&asking, &job_id) {
let links = links.clone();
let request = JobStatusRequest {
job_id: job_id.clone(),
};
asking = Some(Box::pin(async move {
Ok(links
.request::<JobStatusRequested>(&request)
.await?
.response)
}));
}
}
Step::Status(status) => {
asking = None;
if let Ok(status) = status {
match status.status {
JobStatusResponseStatus::Complete => {
let job_id = status.job_id.clone();
return C::of_status(status, resource_id)
.ok_or_else(|| not_the_verbs(&job_id, "The status"));
}
JobStatusResponseStatus::Failed => {
return Err(failed(
&status.job_id,
status.error.unwrap_or_else(|| "Job failed".to_owned()),
status.failure_class,
));
}
JobStatusResponseStatus::Cancelled => {
return Err(JobError {
code: JobErrorCode::Cancelled,
job_id: Some(status.job_id),
message: "The job was cancelled".to_owned(),
failure_class: None,
}
.into());
}
JobStatusResponseStatus::Pending | JobStatusResponseStatus::Running => {}
}
}
}
Step::Stalled => {
let Some(within) = stall else { continue };
if let Some(stalled) = job_id.clone() {
let links = links.clone();
tokio::spawn(async move {
let _ = links
.request::<JobCancelRequested>(&JobCancelRequest { job_id: stalled })
.await;
});
}
return Err(JobError {
code: JobErrorCode::Stalled,
job_id,
message: format!(
"The job stalled: nothing was heard of it within {}ms",
within.as_millis()
),
failure_class: None,
}
.into());
}
}
let Some(following_id) = job_id.as_ref() else {
continue;
};
for frame in frames {
if frame.job_id().is_some_and(|job_id| job_id != following_id) {
continue;
}
match frame {
Heard::Refused(refusal) => {
let FrameRefusal {
channel,
member,
reason,
..
} = *refusal;
reporter.report(JobEvent::Refused {
channel,
member,
reason,
});
}
Heard::Progress(frame) => {
if let Some(progress) = frame.progress {
reporter.report(JobEvent::Progress(progress));
}
ask_at = Some(Instant::now() + links.timing.job_silence);
stall_at = stall.map(|within| Instant::now() + within);
}
Heard::Complete(frame) => {
return C::of_frame(frame)
.ok_or_else(|| not_the_verbs(following_id, "A job:complete"));
}
Heard::Fail(frame) if frame.will_retry == Some(true) => {
ask_at = None;
stall_at = stall.map(|within| Instant::now() + within);
reporter.report(JobEvent::Failed(frame));
}
Heard::Fail(frame) => {
return Err(failed(&frame.job_id, frame.error, frame.failure_class));
}
}
}
}
}