1pub(crate) mod artwork;
2mod playback;
3mod recording;
4mod status;
5use playback::PlaybackController;
6use recording::RecordingController;
7pub use status::{PlaybackState, RecordingState};
8
9use crate::error::{DomainError, ErrorCode};
10use crate::{
11 config::Config,
12 directory::Directory,
13 model::{Filter, Station},
14 player::{Event, Player},
15 process::{Background, MediaLock},
16 recorder::{self, Recorder},
17 store::Store,
18};
19use anyhow::{Context, Result, bail};
20use std::{
21 collections::VecDeque,
22 sync::{Arc, atomic::AtomicBool},
23 time::{Duration, Instant},
24};
25
26#[derive(Debug, Clone, PartialEq, Eq)]
27pub struct Status {
28 pub station: Option<Station>,
29 pub title: String,
30 pub message: String,
31 pub playback_state: PlaybackState,
32 pub volume: u8,
33 pub muted: bool,
34 pub recording_state: RecordingState,
35 pub recording_ms: u64,
36 pub recording_path: String,
37 pub source_url: String,
38}
39
40impl Status {
41 pub(crate) fn control_eq(&self, other: &Self) -> bool {
42 self.station == other.station
43 && self.title == other.title
44 && self.message == other.message
45 && self.playback_state == other.playback_state
46 && self.recording_state == other.recording_state
47 && self.volume == other.volume
48 && self.muted == other.muted
49 && self.recording_path == other.recording_path
50 && self.source_url == other.source_url
51 }
52 pub(crate) fn ui_eq(&self, other: &Self) -> bool {
53 self.control_eq(other) && self.recording_ms / 1000 == other.recording_ms / 1000
54 }
55 pub fn playing(&self) -> bool {
56 matches!(
57 self.playback_state,
58 PlaybackState::Playing | PlaybackState::Paused
59 )
60 }
61 pub fn paused(&self) -> bool {
62 self.playback_state == PlaybackState::Paused
63 }
64 pub fn recording(&self) -> bool {
65 matches!(
66 self.recording_state,
67 RecordingState::Probing | RecordingState::Recording
68 )
69 }
70}
71
72pub struct Engine {
73 session: Session,
74 playback: PlaybackController,
75 recording: RecordingController,
76}
77
78pub struct Session {
80 pub subtitles: crate::speech::Controller,
81 pub(crate) artwork: artwork::Controller,
82 pub config: Config,
83 pub store: Store,
84 pub directory: Directory,
85 pub status: Status,
86 pub stop: Arc<AtomicBool>,
87 pub(crate) _lock: Arc<MediaLock>,
88 pub(crate) background_media: bool,
89 pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
90 pub(crate) library_task: Option<Background<String>>,
91 pub playback_failed: bool,
92}
93
94impl std::ops::Deref for Engine {
95 type Target = Session;
96 fn deref(&self) -> &Session {
97 &self.session
98 }
99}
100impl std::ops::DerefMut for Engine {
101 fn deref_mut(&mut self) -> &mut Session {
102 &mut self.session
103 }
104}
105
106impl Engine {
107 pub fn bootstrap(&mut self) -> Result<usize> {
108 self.session.directory.bootstrap(&mut self.session.store)
109 }
110 pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
111 let lock = MediaLock::acquire(&config.runtime_dir)?;
112 let store = Store::open(&config.data_dir.join("radio.db"))?;
113 if let Some(volume) = store
114 .meta("pref_volume")?
115 .and_then(|v| v.parse::<u8>().ok())
116 .filter(|v| *v <= 100)
117 {
118 config.settings.volume = volume;
119 }
120 let recovery_warnings = recorder::recover(&store)?;
121 let directory = Directory::new(&config, stop.clone())?;
122 let status = Status {
123 station: None,
124 title: String::new(),
125 message: if recovery_warnings.is_empty() {
126 crate::t!("status_ready").into()
127 } else {
128 recovery_warnings.join("\n")
129 },
130 playback_state: PlaybackState::Idle,
131 volume: config.settings.volume,
132 muted: false,
133 recording_state: RecordingState::Idle,
134 recording_ms: 0,
135 recording_path: String::new(),
136 source_url: String::new(),
137 };
138 Ok(Self {
139 session: Session {
140 subtitles: crate::speech::Controller::default(),
141 artwork: artwork::Controller::default(),
142 config,
143 store,
144 directory,
145 status,
146 stop,
147 _lock: Arc::new(lock),
148 background_media: false,
149 diagnostics: None,
150 library_task: None,
151 playback_failed: false,
152 },
153 playback: PlaybackController {
154 generation: 0,
155 refresh_task: None,
156 click_task: None,
157 player: None,
158 player_start: None,
159 retiring: vec![],
160 url: String::new(),
161 candidates: VecDeque::new(),
162 tried: vec![],
163 refreshed: false,
164 confirmed: false,
165 session_started: false,
166 source_kind: playback::SourceKind::Catalog,
167 local_recording_id: None,
168 reconnect_attempts: 0,
169 reconnect_due: None,
170 reconnect_window: VecDeque::new(),
171 started: Instant::now(),
172 random_filter: None,
173 random_tried: vec![],
174 failure: None,
175 },
176 recording: RecordingController {
177 recording_probe: None,
178 retiring_probes: vec![],
179 finalizing: None,
180 recorder: None,
181 },
182 })
183 }
184
185 pub fn play(&mut self, uuid: &str) -> Result<()> {
186 let result = self
187 .playback
188 .play(&mut self.session, &mut self.recording, uuid);
189 if let Err(error) = &result
190 && !self.playback_active()
191 {
192 self.status.playback_state = PlaybackState::Failed {
193 reason: format!("{error:#}"),
194 };
195 }
196 result
197 }
198
199 pub fn resume_last_station(&mut self) -> Result<()> {
200 self.playback
201 .resume_last_station(&mut self.session, &mut self.recording)
202 }
203
204 pub fn play_recording(&mut self, id: &str) -> Result<()> {
205 let result = self
206 .playback
207 .play_recording(&mut self.session, &mut self.recording, id);
208 if let Err(error) = &result
209 && !self.playback_active()
210 {
211 self.status.playback_state = PlaybackState::Failed {
212 reason: format!("{error:#}"),
213 };
214 }
215 result
216 }
217
218 pub fn random(&mut self, filter: Filter) -> Result<()> {
219 let result = self
220 .playback
221 .random(&mut self.session, &mut self.recording, filter);
222 if let Err(error) = &result
223 && !self.playback_active()
224 {
225 self.status.playback_state = PlaybackState::Failed {
226 reason: format!("{error:#}"),
227 };
228 }
229 result
230 }
231
232 pub fn tick(&mut self) -> Result<()> {
233 self.poll_background()?;
234 self.playback.tick(&mut self.session, &mut self.recording)?;
235 self.recording
236 .recording_tick(&mut self.session, &mut self.playback)?;
237 self.subtitle_tick();
238 self.artwork_tick();
239 Ok(())
240 }
241
242 fn subtitle_tick(&mut self) {
243 if !self.background_media {
244 return;
245 }
246 if self.subtitles.snapshot.enabled && !self.artwork.quiescent() {
247 self.artwork.cancel();
248 return;
249 }
250 let playing = self.status.playback_state == PlaybackState::Playing;
251 let paused = self.status.paused();
252 let local = self.playback.source_kind == playback::SourceKind::Local;
253 let generation = self.playback.generation;
254 let session = &mut self.session;
255 let key = (generation, session.status.source_url.as_str());
256 session
257 .subtitles
258 .update(&session.config, key, playing, paused, local, &session.stop);
259 }
260
261 pub fn set_subtitles(&mut self, enabled: bool) {
262 self.subtitles.enabled(enabled);
263 }
264 pub fn retry_subtitles(&mut self) {
265 self.subtitles.retry();
266 }
267 pub fn clear_subtitles(&mut self) {
268 self.subtitles.clear();
269 }
270 pub fn set_subtitle_model(&mut self, id: String) -> Result<()> {
271 crate::speech::validate_model(&id)?;
272 let mut settings = self.config.settings.subtitles.clone();
273 settings.model = id;
274 settings.validate()?;
275 self.config.settings.subtitles = settings;
276 self.subtitles.retry();
277 self.subtitles.clear();
278 Ok(())
279 }
280
281 fn artwork_tick(&mut self) {
282 let request = (self.background_media
283 && !self.subtitles.snapshot.enabled
284 && self.subtitles.quiescent()
285 && self.config.settings.artwork == crate::config::ArtworkMode::Track
286 && self.status.playback_state == PlaybackState::Playing
287 && !matches!(
288 self.status.recording_state,
289 RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
290 )
291 && self.playback.source_kind != playback::SourceKind::Local
292 && self.playback.retiring.is_empty()
293 && self.recording.retiring_probes.is_empty()
294 && !self.status.title.is_empty())
295 .then(|| self.status.station.as_ref())
296 .flatten()
297 .filter(|station| {
298 station.hls == 0 && self.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
299 })
300 .filter(|_| crate::config::validate_url(&self.status.source_url).is_ok())
301 .map(|station| artwork::Request {
302 stationuuid: station.stationuuid.clone(),
303 source_url: self.status.source_url.clone(),
304 title: self.status.title.clone(),
305 });
306 let session = &mut self.session;
307 session.artwork.update(&session.config, request);
308 }
309
310 pub fn pause(&mut self) -> Result<()> {
311 self.playback.pause(&mut self.session, &mut self.recording)
312 }
313 pub fn mute(&mut self) -> Result<()> {
314 self.playback
315 .player
316 .as_mut()
317 .context(DomainError::new(ErrorCode::NotPlaying))?
318 .toggle_mute()
319 }
320
321 pub fn volume(&mut self, delta: i32) -> Result<()> {
322 self.playback
323 .volume(&mut self.session, &mut self.recording, delta)
324 }
325
326 pub fn stop_playback(&mut self) -> Result<()> {
327 self.playback
328 .stop_playback(&mut self.session, &mut self.recording)
329 }
330
331 pub fn toggle_recording(&mut self) -> Result<()> {
332 let result = self
333 .recording
334 .toggle_recording(&mut self.session, &mut self.playback);
335 if let Err(error) = &result
336 && self.recording.recorder.is_none()
337 && self.recording.recording_probe.is_none()
338 && self.recording.finalizing.is_none()
339 {
340 self.status.recording_state = RecordingState::Failed {
341 reason: format!("{error:#}"),
342 };
343 }
344 result
345 }
346
347 pub fn record_current(
348 &mut self,
349 duration: Option<Duration>,
350 dir: Option<&std::path::Path>,
351 ) -> Result<()> {
352 let result =
353 self.recording
354 .record_current(&mut self.session, &mut self.playback, duration, dir);
355 if let Err(error) = &result
356 && self.recording.recorder.is_none()
357 && self.recording.recording_probe.is_none()
358 && self.recording.finalizing.is_none()
359 {
360 self.status.recording_state = RecordingState::Failed {
361 reason: format!("{error:#}"),
362 };
363 }
364 result
365 }
366
367 pub fn standalone_record(
368 &mut self,
369 uuid: &str,
370 duration: Option<Duration>,
371 dir: Option<&std::path::Path>,
372 ) -> Result<()> {
373 let result = self.recording.standalone_record(
374 &mut self.session,
375 &mut self.playback,
376 uuid,
377 duration,
378 dir,
379 );
380 if let Err(error) = &result
381 && self.recording.recorder.is_none()
382 && self.recording.recording_probe.is_none()
383 && self.recording.finalizing.is_none()
384 {
385 self.status.recording_state = RecordingState::Failed {
386 reason: format!("{error:#}"),
387 };
388 }
389 result
390 }
391
392 pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
393 self.recording
394 .stop_recording(&mut self.session, &mut self.playback, reason)
395 }
396
397 pub(crate) fn enable_background_media(&mut self) {
398 self.background_media = true;
399 let enabled = self.config.settings.subtitles.enabled;
400 self.subtitles.enabled(enabled);
401 }
402
403 pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
404 if self.library_task.is_some() {
405 bail!(DomainError::new(ErrorCode::RecordingBusy));
406 }
407 if self.playback.local_recording_id.as_deref() == Some(&id) {
408 self.stop_playback()?;
409 }
410 let path = self.config.data_dir.join("radio.db");
411 let lock = self._lock.clone();
412 self.library_task = Some(Background::start(
413 "radio-recording-delete",
414 move |cancel| {
415 let _lock = lock;
416 if cancel.load(std::sync::atomic::Ordering::Relaxed) {
417 bail!(DomainError::new(ErrorCode::Cancelled));
418 }
419 crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
420 Ok(crate::t!("recording_deleted", "id" => id))
421 },
422 )?);
423 Ok(())
424 }
425
426 pub fn open_recordings(&mut self) -> Result<()> {
427 if self.library_task.is_some() {
428 bail!(DomainError::new(ErrorCode::RecordingBusy));
429 }
430 let dir = self.config.recording_dir.clone();
431 self.library_task = Some(Background::start("radio-open-recordings", move |cancel| {
432 crate::service::open_recordings(&dir, &cancel)?;
433 Ok(crate::t!("recordings_opened", "path" => dir.display()))
434 })?);
435 Ok(())
436 }
437
438 pub fn playback_active(&self) -> bool {
439 self.playback.player.is_some()
440 || self.playback.player_start.is_some()
441 || self.playback.refresh_task.is_some()
442 || self.playback.reconnect_due.is_some()
443 }
444
445 pub fn playback_error(&self) -> Option<&DomainError> {
446 self.playback.failure.as_ref()
447 }
448
449 pub fn shutdown(&mut self) -> Result<()> {
450 self.stop_playback()?;
451 self.subtitles.enabled(false);
452 self.playback.click_task = None;
453 self.diagnostics = None;
454 let deadline = Instant::now() + Duration::from_secs(6);
457 while (self.recording.finalizing.is_some()
458 || !self.playback.retiring.is_empty()
459 || !self.recording.retiring_probes.is_empty()
460 || !self.artwork.quiescent()
461 || !self.subtitles.quiescent())
462 && Instant::now() < deadline
463 {
464 self.poll_background()?;
465 std::thread::sleep(Duration::from_millis(10));
466 }
467 self.recording.finalizing = None;
468 Ok(())
469 }
470
471 fn poll_background(&mut self) -> Result<()> {
472 self.subtitles.poll_retiring();
473 if let Some(result) = self.library_task.as_ref().and_then(Background::poll) {
474 self.library_task = None;
475 self.status.message = match result {
476 Ok(message) => message,
477 Err(error) => {
478 crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
479 }
480 };
481 }
482 self.playback
483 .poll_background(&mut self.session, &mut self.recording)?;
484 self.recording
485 .record_poll_background(&mut self.session, &mut self.playback)
486 }
487}
488
489impl Drop for Engine {
490 fn drop(&mut self) {
491 let _ = self.shutdown();
492 }
493}
494
495#[cfg(test)]
496mod tests {
497 use super::*;
498
499 #[test]
500 fn invalid_subtitle_model_reports_id_without_changing_settings() {
501 let dir = tempfile::tempdir().unwrap();
502 let config = crate::test_support::config(dir.path());
503 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
504 let original = engine.config.settings.subtitles.model.clone();
505 for id in ["unknown", "silero-vad", "../../model"] {
506 let error = engine.set_subtitle_model(id.into()).unwrap_err();
507 let error = error.downcast_ref::<DomainError>().unwrap();
508 assert_eq!(error.code, ErrorCode::SubtitleModel);
509 assert_eq!(engine.config.settings.subtitles.model, original);
510 }
511 }
512
513 #[test]
514 fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
515 use crate::test_support::{Server, fake_mpv};
516 use std::sync::atomic::{AtomicUsize, Ordering};
517 let requests = Arc::new(AtomicUsize::new(0));
518 let counter = requests.clone();
519 let server = Server::new(move |_, _| {
520 counter.fetch_add(1, Ordering::Relaxed);
521 });
522 let dir = tempfile::tempdir().unwrap();
523 let mpv = fake_mpv(dir.path());
524 for background in [false, true] {
525 let data = dir.path().join(background.to_string());
526 let mut config = crate::test_support::config_with_api(&data, &server.url);
527 config.settings.mpv = mpv.to_string_lossy().into_owned();
528 config.settings.audio_device = Some("test/fail".into());
529 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
530 engine.session.background_media = background;
531 let station = Station {
532 stationuuid: uuid::Uuid::new_v4().to_string(),
533 name: "Catalog station".into(),
534 url: format!("{}/live", server.url),
535 active: true,
536 ..Station::default()
537 };
538 engine.store.upsert(&station).unwrap();
539 engine
540 .store
541 .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
542 .unwrap();
543 engine.play(&station.stationuuid).unwrap();
544 engine.playback.random_filter = Some(Filter::default());
545 engine.playback.session_started = true;
546 let deadline = Instant::now() + Duration::from_secs(3);
547 while !engine.playback_failed {
548 engine.tick().unwrap();
549 assert!(Instant::now() < deadline, "{}", engine.status.message);
550 std::thread::sleep(Duration::from_millis(10));
551 }
552 let error = engine.playback_error().unwrap();
553 assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
554 assert_eq!(error.params["device"], "test/fail");
555 assert_eq!(engine.playback.tried.len(), 1);
556 assert!(!engine.playback_active());
557 assert!(!engine.playback.refreshed);
558 assert!(engine.playback.reconnect_window.is_empty());
559 engine.shutdown().unwrap();
560 }
561 assert_eq!(requests.load(Ordering::Relaxed), 0);
562 let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
563 assert_eq!(
564 commands
565 .lines()
566 .filter(|s| s.contains("\"loadfile\""))
567 .count(),
568 2
569 );
570 }
571
572 #[test]
573 fn background_player_startup_preserves_dependency_failure() {
574 let dir = tempfile::tempdir().unwrap();
575 let mut config = crate::test_support::config(dir.path());
576 config.settings.mpv = dir
577 .path()
578 .join("missing-mpv")
579 .to_string_lossy()
580 .into_owned();
581 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
582 engine.enable_background_media();
583 engine.play("https://example.com/live").unwrap();
584 let deadline = Instant::now() + Duration::from_secs(3);
585 while !engine.playback_failed {
586 engine.tick().unwrap();
587 assert!(Instant::now() < deadline);
588 std::thread::sleep(Duration::from_millis(10));
589 }
590 assert_eq!(
591 engine.playback_error().unwrap().code,
592 ErrorCode::MissingDependency
593 );
594 assert!(!engine.playback_active());
595 }
596
597 #[test]
598 fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
599 use crate::test_support::{Server, config, fixture, response};
600 let bytes = fixture("libmp3lame", "mp3");
601 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
602 let dir = tempfile::tempdir().unwrap();
603 let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
604 let station = Station {
605 stationuuid: uuid::Uuid::new_v4().to_string(),
606 name: "Saved station".into(),
607 url: server.url.clone(),
608 active: true,
609 custom: true,
610 ..Station::default()
611 };
612 engine.store.upsert(&station).unwrap();
613 engine.status.station = Some(station.clone());
614 engine.status.playback_state = PlaybackState::Playing;
615 engine.playback.url = server.url.clone();
616 engine.record_current(None, None).unwrap();
617 let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
618 conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
619 assert!(engine.play("https://example.com/audition").is_err());
620 assert_eq!(
621 engine.status.station.as_ref().unwrap().stationuuid,
622 station.stationuuid
623 );
624 assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
625 }
626
627 #[test]
628 fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
629 use crate::test_support::{Server, config, fixture, response};
630 let bytes = fixture("libmp3lame", "mp3");
631 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
632 for background in [false, true] {
633 for title in [
634 "Björk / 中文\x1b\n".to_owned(),
635 String::new(),
636 "曲".repeat(100),
637 ] {
638 let dir = tempfile::tempdir().unwrap();
639 let mut engine =
640 Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
641 if background {
642 engine.enable_background_media();
643 }
644 let station = Station {
645 stationuuid: uuid::Uuid::new_v4().to_string(),
646 name: if title.starts_with('曲') {
647 "台".repeat(60)
648 } else {
649 "Station".into()
650 },
651 url: server.url.clone(),
652 custom: true,
653 active: true,
654 ..Station::default()
655 };
656 engine.store.upsert(&station).unwrap();
657 engine.status.station = Some(station);
658 engine.status.playback_state = PlaybackState::Playing;
659 engine.status.title = title.clone();
660 engine.playback.url = server.url.clone();
661 engine
662 .record_current(Some(Duration::from_secs(1)), None)
663 .unwrap();
664 engine.status.title = "Next track".into();
665 let deadline = Instant::now() + Duration::from_secs(8);
666 while engine.status.recording_path.is_empty() {
667 engine.tick().unwrap();
668 assert!(Instant::now() < deadline, "{}", engine.status.message);
669 std::thread::sleep(Duration::from_millis(10));
670 }
671 let record = engine.store.recordings(1).unwrap().remove(0);
672 let expected = crate::clean_text(&title).trim().to_owned();
673 assert_eq!(
674 record.track.as_deref(),
675 (!expected.is_empty()).then_some(expected.as_str())
676 );
677 let final_path = record.final_path.clone().unwrap();
678 let name = std::path::Path::new(&record.path)
679 .file_name()
680 .unwrap()
681 .to_str()
682 .unwrap();
683 assert!(name.len() + ".json.tmp".len() <= 255);
684 if title.starts_with("Björk") {
685 assert!(name.contains("-Station-Björk_中文-"));
686 }
687 if title.is_empty() {
688 assert!(name.contains("-Station-"));
689 }
690 while engine.status.recording()
691 || engine.status.recording_state == RecordingState::Finalizing
692 {
693 engine.tick().unwrap();
694 assert!(Instant::now() < deadline, "{}", engine.status.message);
695 std::thread::sleep(Duration::from_millis(10));
696 }
697 let saved = engine.store.recording(&record.id).unwrap();
698 assert_eq!(saved.status, "complete", "{:?}", saved.error);
699 assert_eq!(saved.path, final_path);
700 assert_eq!(saved.track, record.track);
701 let sidecar: crate::model::Recording =
702 serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
703 .unwrap();
704 assert_eq!(sidecar.track, saved.track);
705 let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
706 assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
707 }
708 }
709 }
710
711 #[test]
712 fn changing_station_clears_finished_recording_status() {
713 let dir = tempfile::tempdir().unwrap();
714 let config = crate::test_support::config(dir.path());
715 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
716 for state in [
717 RecordingState::Done,
718 RecordingState::Failed {
719 reason: "disk".into(),
720 },
721 ] {
722 engine.status.recording_state = state;
723 engine.status.recording_path = "old.mp3".into();
724 engine.status.recording_ms = 1000;
725 assert!(
727 engine
728 .playback
729 .play_source(
730 &mut engine.session,
731 &mut engine.recording,
732 Station::default(),
733 vec![],
734 playback::SourceKind::Catalog
735 )
736 .is_err()
737 );
738 assert_eq!(engine.status.recording_state, RecordingState::Idle);
739 assert!(engine.status.recording_path.is_empty());
740 assert_eq!(engine.status.recording_ms, 0);
741 }
742 }
743
744 #[test]
745 fn flapping_reconnects_have_a_sliding_window_limit() {
746 let dir = tempfile::tempdir().unwrap();
747 let config = crate::test_support::config(dir.path());
748 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
749 engine.status.station = Some(Station {
750 custom: true,
751 ..Station::default()
752 });
753 engine.playback.session_started = true;
754 engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
755 engine
756 .playback
757 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
758 .unwrap();
759 assert!(engine.playback_failed);
760 assert!(!engine.status.muted);
761 assert_eq!(engine.playback.reconnect_attempts, 0);
762 assert!(engine.playback.reconnect_window.is_empty());
763 assert!(engine.playback.reconnect_due.is_none());
764 let failed_state = engine.status.playback_state.clone();
765 for _ in 0..3 {
766 engine.tick().unwrap();
767 assert!(engine.playback_failed);
768 assert_eq!(engine.status.playback_state, failed_state);
769 assert!(!engine.playback_active());
770 }
771 engine.playback.reconnect_window =
772 std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
773 engine
774 .playback
775 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
776 .unwrap();
777 assert!(engine.playback.reconnect_due.is_some());
778 assert_eq!(engine.playback.reconnect_window.len(), 1);
779 }
780
781 #[test]
782 fn reconnect_budget_is_bounded_and_stop_cancels_it() {
783 let dir = tempfile::tempdir().unwrap();
784 let config = crate::test_support::config(dir.path());
785 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
786 engine.status.station = Some(Station {
787 custom: true,
788 name: "Test".into(),
789 ..Station::default()
790 });
791 engine.status.muted = true;
792 engine.playback.session_started = true;
793 for delay in [1, 3, 7] {
794 engine
795 .playback
796 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
797 .unwrap();
798 let remaining = engine
799 .playback
800 .reconnect_due
801 .unwrap()
802 .saturating_duration_since(Instant::now());
803 assert!(remaining <= Duration::from_secs(delay));
804 assert!(remaining > Duration::from_millis(delay * 1000 - 100));
805 assert!(!engine.playback_failed);
806 }
807 engine.playback.reconnect_due = None;
808 engine
809 .playback
810 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
811 .unwrap();
812 assert!(engine.playback_failed);
813 assert!(!engine.status.muted);
814 assert_eq!(engine.playback.reconnect_attempts, 0);
815 assert!(engine.playback.reconnect_window.is_empty());
816 assert!(engine.playback.reconnect_due.is_none());
817 engine.playback.reconnect_attempts = 0;
818 engine
819 .playback
820 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
821 .unwrap();
822 engine.status.muted = true;
823 engine.stop_playback().unwrap();
824 assert!(!engine.status.muted);
825 assert_eq!(engine.playback.reconnect_attempts, 0);
826 assert!(engine.playback.reconnect_window.is_empty());
827 assert!(engine.playback.reconnect_due.is_none());
828 let generation = engine.playback.generation;
829 engine.tick().unwrap();
830 assert_eq!(engine.playback.generation, generation);
831 assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
832 }
833}