Skip to main content

radio_cli/
engine.rs

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