use super::{Held, Tasks, cancelled, said, signal};
use crate::channels::{Channel, MarkCreateError, MarkDelegateTimeout, MarkRequested, MarkSubmit};
use crate::client::SemiontClient;
use crate::errors::SemiontError;
use crate::event_bus::BusFrames;
use crate::namespaces::JobEvent;
use crate::state_unit::StateUnit;
use crate::timing::DELEGATE_SILENCE;
use crate::transport::Envelope;
use crate::types::{
AnnotationSelector, AnnotationTarget, CreateAnnotationRequest, JobProgress,
MarkDelegateTimeoutEvent, MarkJobParams, MarkSubmitEvent, Motivation, ResourceErrorEvent,
};
use crate::types::{JobId, ResourceId};
use serde::Serialize;
use std::sync::Arc;
use tokio::sync::watch;
use tokio::time::Instant;
#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PendingAnnotation {
pub selector: AnnotationSelector,
pub motivation: Motivation,
}
fn motivation_of(params: &MarkJobParams) -> Option<Motivation> {
let stated = serde_json::to_value(params).ok()?;
serde_json::from_value(stated.get("motivation")?.clone()).ok()
}
struct Shared {
client: Arc<SemiontClient>,
resource_id: ResourceId,
pending: Held<Option<PendingAnnotation>>,
delegating: Held<Option<Motivation>>,
progress: Held<Option<JobProgress>>,
progress_motivation: Held<Option<Motivation>>,
failure: Held<Option<SemiontError>>,
job_id: Held<Option<JobId>>,
tasks: Tasks,
}
impl Shared {
fn failed<C: Channel<Payload = ResourceErrorEvent>>(&self, error: &SemiontError) {
signal::<C>(
&self.client,
&ResourceErrorEvent {
resource_id: self.resource_id.clone(),
message: error.to_string(),
},
Envelope::default(),
);
}
}
pub struct MarkStateUnit {
shared: Arc<Shared>,
}
impl MarkStateUnit {
pub fn new(client: Arc<SemiontClient>, resource_id: &ResourceId) -> MarkStateUnit {
let heard = client
.bus()
.frames_among(&[MarkRequested::NAME, MarkSubmit::NAME]);
let shared = Arc::new(Shared {
client,
resource_id: resource_id.clone(),
pending: Held::new(None),
delegating: Held::new(None),
progress: Held::new(None),
progress_motivation: Held::new(None),
failure: Held::new(None),
job_id: Held::new(None),
tasks: Tasks::new(),
});
shared.tasks.spawn(listen(shared.clone(), heard));
MarkStateUnit { shared }
}
pub fn pending_annotation(&self) -> watch::Receiver<Option<PendingAnnotation>> {
self.shared.pending.read()
}
pub fn delegating_motivation(&self) -> watch::Receiver<Option<Motivation>> {
self.shared.delegating.read()
}
pub fn progress(&self) -> watch::Receiver<Option<JobProgress>> {
self.shared.progress.read()
}
pub fn progress_motivation(&self) -> watch::Receiver<Option<Motivation>> {
self.shared.progress_motivation.read()
}
pub fn failure(&self) -> watch::Receiver<Option<SemiontError>> {
self.shared.failure.read()
}
pub fn job_id(&self) -> watch::Receiver<Option<JobId>> {
self.shared.job_id.read()
}
pub fn request_delegate(&self, params: impl Into<MarkJobParams>) {
let params = params.into();
let Some(motivation) = motivation_of(¶ms) else {
return;
};
let shared = &self.shared;
shared.delegating.set(Some(motivation));
shared.progress.set(None);
shared.progress_motivation.set(Some(motivation));
shared.failure.set(None);
shared.job_id.set(None);
shared
.tasks
.spawn(delegate(shared.clone(), params, motivation));
}
pub fn cancel_pending(&self) {
self.shared.pending.set(None);
}
pub fn dismiss_progress(&self) {
self.shared.progress.set(None);
self.shared.progress_motivation.set(None);
self.shared.failure.set(None);
}
}
async fn listen(shared: Arc<Shared>, mut heard: BusFrames) {
while let Some(frame) = heard.next().await {
let Ok(Ok(frame)) = frame else { continue };
if let Some(request) = said::<MarkRequested>(&frame) {
if request.source == shared.resource_id {
shared.pending.set(Some(PendingAnnotation {
selector: request.selector,
motivation: request.motivation,
}));
}
} else if let Some(submission) = said::<MarkSubmit>(&frame)
&& submission.source == shared.resource_id
{
shared.tasks.spawn(create(shared.clone(), submission));
}
}
}
async fn create(shared: Arc<Shared>, submission: MarkSubmitEvent) {
let created = shared
.client
.mark
.annotation(CreateAnnotationRequest {
motivation: submission.motivation,
target: AnnotationTarget {
selector: Some(submission.selector),
..AnnotationTarget::new(shared.resource_id.clone())
},
body: submission.body,
})
.await;
match created {
Ok(_) => shared.pending.set(None),
Err(error) => shared.failed::<MarkCreateError>(&error),
}
}
async fn delegate(shared: Arc<Shared>, params: MarkJobParams, motivation: Motivation) {
let mut run = shared.client.mark.delegate(&shared.resource_id, params);
let mut created: Option<JobId> = None;
let forget = |created: &Option<JobId>| {
if let Some(job_id) = created {
shared.job_id.forget(job_id);
}
};
let mut quiet_at = Some(Instant::now() + DELEGATE_SILENCE);
loop {
let event = if let Some(deadline) = quiet_at {
match tokio::time::timeout_at(deadline, run.next()).await {
Ok(event) => event,
Err(_) => {
quiet_at = None;
gone_quiet(&shared, motivation);
continue;
}
}
} else {
run.next().await
};
if !matches!(event, Some(Ok(JobEvent::Refused { .. }))) {
quiet_at = Some(Instant::now() + DELEGATE_SILENCE);
}
match event {
Some(Ok(JobEvent::Created(job))) => {
shared.job_id.set(Some(job.job_id.clone()));
created = Some(job.job_id);
}
Some(Ok(JobEvent::Progress(progress))) => shared.progress.set(Some(progress)),
Some(Ok(JobEvent::Failed(_) | JobEvent::Refused { .. } | JobEvent::Complete(_))) => {}
Some(Err(error)) => {
let kept = cancelled(&error);
shared.failure.set(Some(error));
if !kept {
shared.progress.set(None);
shared.progress_motivation.set(None);
}
shared.delegating.set(None);
forget(&created);
return;
}
None => {
shared.delegating.set(None);
forget(&created);
return;
}
}
}
}
fn gone_quiet(shared: &Shared, motivation: Motivation) {
if shared.progress.now().is_none() {
shared.progress.set(Some(JobProgress {
percentage: 0.0,
message: None,
annotation_id: None,
current: None,
processed: None,
total: None,
entities_found: None,
entities_expected: None,
entities_emitted: None,
completed_items: None,
request_params: None,
}));
}
signal::<MarkDelegateTimeout>(
&shared.client,
&MarkDelegateTimeoutEvent {
resource_id: shared.resource_id.clone(),
motivation,
},
Envelope::default(),
);
}
impl StateUnit for MarkStateUnit {
fn dispose(&self) {
self.shared.tasks.stop();
self.shared.pending.end();
self.shared.delegating.end();
self.shared.progress.end();
self.shared.progress_motivation.end();
self.shared.failure.end();
self.shared.job_id.end();
}
}
impl Drop for MarkStateUnit {
fn drop(&mut self) {
self.dispose();
}
}