Skip to main content

yaiko_core/
media_task.rs

1//! Media-processing task orchestration over the task-result store.
2
3use crate::media_output::{MediaOutputError, MediaOutputValidator};
4use crate::media_processing::FfmpegJobSpec;
5use crate::task_results::{TaskResultError, TaskResultStore, TaskState};
6use std::future::Future;
7use std::sync::Arc;
8
9#[derive(Debug, Clone, PartialEq, Eq)]
10pub enum MediaTaskError {
11    Task(TaskResultError),
12    Cancelled,
13    ProcessFailed(String),
14    OutputValidation(MediaOutputError),
15}
16
17#[derive(Clone)]
18pub struct MediaTask {
19    id: String,
20    spec: Arc<FfmpegJobSpec>,
21    results: TaskResultStore,
22}
23
24impl MediaTask {
25    pub fn create(results: TaskResultStore, spec: FfmpegJobSpec) -> Result<Self, MediaTaskError> {
26        let record = results.create().map_err(MediaTaskError::Task)?;
27        Ok(Self {
28            id: record.id,
29            spec: Arc::new(spec),
30            results,
31        })
32    }
33    pub fn id(&self) -> &str {
34        &self.id
35    }
36    pub fn spec(&self) -> &FfmpegJobSpec {
37        &self.spec
38    }
39    pub fn start(&self) -> Result<(), MediaTaskError> {
40        self.results.start(&self.id).map_err(MediaTaskError::Task)
41    }
42    pub fn progress(&self, percent: u8) -> Result<u8, MediaTaskError> {
43        self.results
44            .progress(&self.id, percent)
45            .map_err(MediaTaskError::Task)
46    }
47    pub fn request_cancel(&self) -> Result<(), MediaTaskError> {
48        self.results
49            .request_cancel(&self.id)
50            .map_err(MediaTaskError::Task)
51    }
52    pub fn cancellation_requested(&self) -> bool {
53        self.results
54            .get(&self.id)
55            .map(|task| {
56                task.state == TaskState::CancelRequested || task.state == TaskState::Cancelled
57            })
58            .unwrap_or(true)
59    }
60    pub fn result(&self) -> Option<crate::task_results::TaskResult> {
61        self.results.get(&self.id)
62    }
63    pub async fn execute_validated<F, Fut>(
64        &self,
65        validator: &MediaOutputValidator,
66        output_path: impl Into<std::path::PathBuf>,
67        runner: F,
68    ) -> Result<Vec<u8>, MediaTaskError>
69    where
70        F: FnOnce(Arc<FfmpegJobSpec>) -> Fut,
71        Fut: Future<Output = Result<Vec<u8>, String>> + Send,
72    {
73        self.start()?;
74        let output = runner(self.spec.clone()).await;
75        if self.cancellation_requested() {
76            let _ = self.results.cancel(&self.id);
77            return Err(MediaTaskError::Cancelled);
78        }
79        match output {
80            Ok(bytes) => {
81                let metadata = validator.validate(output_path).map_err(|error| {
82                    let _ = self
83                        .results
84                        .fail(&self.id, format!("output validation failed: {error:?}"));
85                    MediaTaskError::OutputValidation(error)
86                })?;
87                let manifest = format!(
88                    "{}|{}|{}",
89                    metadata.path.display(),
90                    metadata.size_bytes,
91                    metadata.checksum_sha256
92                )
93                .into_bytes();
94                self.results
95                    .succeed(&self.id, manifest)
96                    .map_err(MediaTaskError::Task)?;
97                Ok(bytes)
98            }
99            Err(error) => {
100                self.results
101                    .fail(&self.id, error.clone())
102                    .map_err(MediaTaskError::Task)?;
103                Err(MediaTaskError::ProcessFailed(error))
104            }
105        }
106    }
107
108    pub async fn execute<F, Fut>(&self, runner: F) -> Result<Vec<u8>, MediaTaskError>
109    where
110        F: FnOnce(Arc<FfmpegJobSpec>) -> Fut,
111        Fut: Future<Output = Result<Vec<u8>, String>> + Send,
112    {
113        if self.cancellation_requested() {
114            return Err(MediaTaskError::Cancelled);
115        }
116        self.start()?;
117        if self.cancellation_requested() {
118            let _ = self.results.cancel(&self.id);
119            return Err(MediaTaskError::Cancelled);
120        }
121        let output = runner(self.spec.clone()).await;
122        if self.cancellation_requested() {
123            let _ = self.results.cancel(&self.id);
124            return Err(MediaTaskError::Cancelled);
125        }
126        match output {
127            Ok(bytes) => {
128                self.results
129                    .succeed(&self.id, bytes.clone())
130                    .map_err(MediaTaskError::Task)?;
131                Ok(bytes)
132            }
133            Err(error) => {
134                self.results
135                    .fail(&self.id, error.clone())
136                    .map_err(MediaTaskError::Task)?;
137                Err(MediaTaskError::ProcessFailed(error))
138            }
139        }
140    }
141}
142
143#[cfg(test)]
144mod tests {
145    use super::*;
146    use crate::media_processing::FfmpegJobSpec;
147
148    fn task() -> MediaTask {
149        MediaTask::create(
150            TaskResultStore::new(4),
151            FfmpegJobSpec::new("input.mp4", "output.mp4").unwrap(),
152        )
153        .unwrap()
154    }
155    #[tokio::test]
156    async fn maps_success_and_progress_to_task_result() {
157        let task = task();
158        task.progress(0).unwrap_err();
159        let result = task
160            .execute(|_| async { Ok::<_, String>(b"rendered".to_vec()) })
161            .await
162            .unwrap();
163        assert_eq!(result, b"rendered");
164        let record = task.result().unwrap();
165        assert_eq!(record.state, TaskState::Succeeded);
166        assert_eq!(record.progress_percent, 100);
167    }
168    #[tokio::test]
169    async fn maps_process_failure() {
170        let task = task();
171        let error = task
172            .execute(|_| async { Err::<Vec<u8>, _>("ffmpeg exit 1".into()) })
173            .await
174            .unwrap_err();
175        assert_eq!(error, MediaTaskError::ProcessFailed("ffmpeg exit 1".into()));
176        assert_eq!(task.result().unwrap().state, TaskState::Failed);
177    }
178    #[tokio::test]
179    async fn honors_cancellation_before_execution() {
180        let task = task();
181        task.request_cancel().unwrap();
182        let error = task
183            .execute(|_| async { Ok::<_, String>(Vec::new()) })
184            .await
185            .unwrap_err();
186        assert_eq!(error, MediaTaskError::Cancelled);
187        assert_eq!(task.result().unwrap().state, TaskState::Cancelled);
188    }
189    #[tokio::test]
190    async fn reports_progress_during_running_work() {
191        let task = task();
192        task.start().unwrap();
193        assert_eq!(task.progress(45).unwrap(), 45);
194        assert_eq!(task.result().unwrap().progress_percent, 45);
195    }
196}