use super::{Held, Tasks, cancelled};
use crate::client::SemiontClient;
use crate::errors::SemiontError;
use crate::namespaces::JobEvent;
use crate::state_unit::StateUnit;
use crate::types::{GenerationJobParams, JobId, JobProgress, YieldJobDone, YieldJobResult};
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::watch;
struct Shared {
client: Arc<SemiontClient>,
locale: String,
generating: Held<bool>,
progress: Held<Option<JobProgress>>,
outcome: Held<Option<YieldJobDone>>,
failure: Held<Option<SemiontError>>,
job_id: Held<Option<JobId>>,
tasks: Tasks,
}
pub struct YieldStateUnit {
shared: Arc<Shared>,
}
impl YieldStateUnit {
pub fn new(client: Arc<SemiontClient>, locale: &str) -> YieldStateUnit {
YieldStateUnit {
shared: Arc::new(Shared {
client,
locale: locale.to_owned(),
generating: Held::new(false),
progress: Held::new(None),
outcome: Held::new(None),
failure: Held::new(None),
job_id: Held::new(None),
tasks: Tasks::new(),
}),
}
}
pub fn is_generating(&self) -> watch::Receiver<bool> {
self.shared.generating.read()
}
pub fn progress(&self) -> watch::Receiver<Option<JobProgress>> {
self.shared.progress.read()
}
pub fn outcome(&self) -> watch::Receiver<Option<YieldJobDone>> {
self.shared.outcome.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 generate(&self, mut params: GenerationJobParams, stall_deadline: Option<Duration>) {
self.shared.progress.set(None);
self.shared.outcome.set(None);
self.shared.failure.set(None);
self.shared.job_id.set(None);
if params.language.as_deref().is_none_or(str::is_empty) {
params.language = Some(self.shared.locale.clone());
}
let shared = self.shared.clone();
self.shared.tasks.spawn(async move {
let mut run = shared.client.yield_.delegate(params, stall_deadline);
let mut created: Option<JobId> = None;
while let Some(event) = run.next().await {
match event {
Ok(JobEvent::Created(job)) => {
shared.job_id.set(Some(job.job_id.clone()));
created = Some(job.job_id);
}
Ok(JobEvent::Progress(progress)) => {
shared.progress.set(Some(progress));
shared.generating.set(true);
}
Ok(JobEvent::Complete(complete)) => {
if let Some(YieldJobResult::YieldJobDone(result)) = complete.result {
shared.outcome.set(Some(result));
}
}
Ok(JobEvent::Failed(_) | JobEvent::Refused { .. }) => {}
Err(failure) => {
let kept = cancelled(&failure);
shared.failure.set(Some(failure));
if !kept {
shared.progress.set(None);
}
break;
}
}
}
shared.generating.set(false);
if let Some(job_id) = &created {
shared.job_id.forget(job_id);
}
});
}
pub fn dismiss_progress(&self) {
self.shared.progress.set(None);
self.shared.outcome.set(None);
self.shared.failure.set(None);
}
}
impl StateUnit for YieldStateUnit {
fn dispose(&self) {
self.shared.tasks.stop();
self.shared.generating.end();
self.shared.progress.end();
self.shared.outcome.end();
self.shared.failure.end();
self.shared.job_id.end();
}
}
impl Drop for YieldStateUnit {
fn drop(&mut self) {
self.dispose();
}
}