1use 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}