fix #14740: serve playback only to the main window
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -17,7 +17,7 @@ tauri-build = { version = "2.7.4", features = [] }
|
||||
serde_json = "1.0"
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
log = "0.4"
|
||||
tauri = { version = "2.12.5", features = ["tray-icon", "protocol-asset"] }
|
||||
tauri = { version = "2.12.5", features = ["tray-icon"] }
|
||||
tauri-plugin-log = "2"
|
||||
tauri-plugin-autostart = "2"
|
||||
tauri-plugin-single-instance = "2"
|
||||
@@ -30,3 +30,4 @@ tauri-plugin-updater = "2"
|
||||
tauri-plugin-opener = "2"
|
||||
tokio = { version = "1", features = ["sync"] }
|
||||
async-trait = "0.1"
|
||||
http-range = "0.1.6"
|
||||
|
||||
@@ -11,7 +11,6 @@ use std::time::Duration;
|
||||
use recorder_core::call_view::{CallDetail, CallListItem};
|
||||
use recorder_core::capture::Devices;
|
||||
use recorder_core::model::CallId;
|
||||
use recorder_core::playback::PlaybackInfo;
|
||||
use recorder_core::secrets::Service;
|
||||
use recorder_core::settings::Settings;
|
||||
use serde::Serialize;
|
||||
@@ -20,7 +19,8 @@ use tauri_plugin_autostart::ManagerExt;
|
||||
|
||||
use crate::processing;
|
||||
use crate::state::{
|
||||
AppState, CallBrief, DeviceLevels, DiscardError, Ended, PendingPrompt, RecordingState,
|
||||
AppState, CallBrief, DeviceLevels, DiscardError, Ended, PendingPrompt, PreparedPlayback,
|
||||
RecordingState,
|
||||
};
|
||||
|
||||
const LEVELS_INTERVAL: Duration = Duration::from_millis(100);
|
||||
@@ -210,12 +210,24 @@ pub fn rename_call(
|
||||
}
|
||||
|
||||
/// Mixes the call's two tracks into one file to play in the detail view
|
||||
/// (or reuses the cached mix); the UI plays it through the asset protocol.
|
||||
/// (or reuses the cached mix); the main window plays it from the
|
||||
/// `playback` scheme ([`crate::playback`]).
|
||||
#[tauri::command]
|
||||
pub async fn prepare_playback(app: AppHandle, id: CallId) -> CmdResult<PlaybackInfo> {
|
||||
pub async fn prepare_playback(app: AppHandle, id: CallId) -> CmdResult<PreparedPlayback> {
|
||||
blocking(app, move |app| app.state::<AppState>().prepare_playback(id)).await
|
||||
}
|
||||
|
||||
/// The player is done with the mix of `lease`: it is removed from disk
|
||||
/// unless a newer player of the same call holds it.
|
||||
#[tauri::command]
|
||||
pub async fn release_playback(app: AppHandle, id: CallId, lease: u64) -> CmdResult<()> {
|
||||
blocking(app, move |app| {
|
||||
app.state::<AppState>().release_playback(id, lease);
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
}
|
||||
|
||||
/// Deletes a finished call's audio and row. Closes the prompt if no call
|
||||
/// waits for it any more; otherwise the prompt reloads and shows the next.
|
||||
/// While its DeepScript jobs are still on record, nothing is deleted and a
|
||||
|
||||
+18
-2
@@ -1,6 +1,7 @@
|
||||
mod backend;
|
||||
mod commands;
|
||||
mod detection;
|
||||
mod playback;
|
||||
mod processing;
|
||||
mod state;
|
||||
mod tray;
|
||||
@@ -43,6 +44,21 @@ pub fn run() {
|
||||
.open_js_links_on_click(false)
|
||||
.build(),
|
||||
)
|
||||
// A call's mix for the player: only for the main window, whatever
|
||||
// other webviews (the remote backend login) ask for.
|
||||
.register_asynchronous_uri_scheme_protocol(playback::SCHEME, |ctx, request, responder| {
|
||||
let webview = ctx.webview_label().to_string();
|
||||
let dir = ctx
|
||||
.app_handle()
|
||||
.try_state::<AppState>()
|
||||
.map(|state| state.playback_dir().to_path_buf());
|
||||
tauri::async_runtime::spawn_blocking(move || {
|
||||
responder.respond(match dir {
|
||||
Some(dir) => playback::respond(&webview, &request, &dir),
|
||||
None => playback::unavailable(),
|
||||
})
|
||||
});
|
||||
})
|
||||
.setup(|app| {
|
||||
// Release builds log to a file in the app log directory (on
|
||||
// Windows %LOCALAPPDATA%\eu.euvino.callrecorder\logs), debug
|
||||
@@ -72,8 +88,7 @@ pub fn run() {
|
||||
|
||||
let data_dir = app.path().app_data_dir()?;
|
||||
let config_dir = app.path().app_config_dir()?;
|
||||
// The asset protocol may read this directory, and only this one
|
||||
// (`app.security.assetProtocol.scope` in tauri.conf.json).
|
||||
// Served to the main window only, by the `playback` scheme.
|
||||
let playback_dir = app.path().app_cache_dir()?.join("playback");
|
||||
std::fs::create_dir_all(&data_dir)?;
|
||||
let store = Store::open(&data_dir.join("calls.sqlite"))?;
|
||||
@@ -161,6 +176,7 @@ pub fn run() {
|
||||
commands::unmerge_speaker,
|
||||
commands::rename_call,
|
||||
commands::prepare_playback,
|
||||
commands::release_playback,
|
||||
backend::backend_server,
|
||||
backend::backend_status,
|
||||
backend::backend_login,
|
||||
|
||||
@@ -0,0 +1,293 @@
|
||||
//! The `playback` URI scheme: serves a call's cached mix
|
||||
//! ([`recorder_core::playback`]) to the main window, and to no other
|
||||
//! webview — the backend-login window shows a remote page, which must
|
||||
//! never read customer audio.
|
||||
//!
|
||||
//! The URL carries only the call id: `playback://localhost/<id>` on Linux
|
||||
//! and macOS, `http://playback.localhost/<id>` on Windows (what the UI's
|
||||
//! `convertFileSrc(id, 'playback')` builds). Range requests are answered
|
||||
//! so the player can seek without loading the whole file.
|
||||
|
||||
use std::fs::File;
|
||||
use std::io::{self, ErrorKind, Read, Seek, SeekFrom};
|
||||
use std::path::Path;
|
||||
|
||||
use http_range::HttpRange;
|
||||
use recorder_core::model::CallId;
|
||||
use recorder_core::playback::cache_path;
|
||||
use tauri::http::header::{
|
||||
ACCEPT_RANGES, ACCESS_CONTROL_ALLOW_ORIGIN, ACCESS_CONTROL_EXPOSE_HEADERS, CACHE_CONTROL,
|
||||
CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE,
|
||||
};
|
||||
use tauri::http::{response, Method, Request, Response, StatusCode};
|
||||
|
||||
/// The scheme's name (see the module docs for its URLs).
|
||||
pub const SCHEME: &str = "playback";
|
||||
/// The only webview the scheme answers.
|
||||
pub const PLAYER_WEBVIEW: &str = "main";
|
||||
/// The most bytes one range response carries (like Tauri's asset protocol).
|
||||
const MAX_RANGE_LEN: u64 = 1024 * 1024;
|
||||
|
||||
/// Answers `request` from webview `webview` with call `<id>`'s mix in the
|
||||
/// playback directory `dir`: 403 for any webview but the main window, 404
|
||||
/// for anything but a plain numeric id or a mix that is not there, 206 for
|
||||
/// a satisfiable range (at most [`MAX_RANGE_LEN`] bytes), 416 otherwise.
|
||||
pub fn respond(webview: &str, request: &Request<Vec<u8>>, dir: &Path) -> Response<Vec<u8>> {
|
||||
if webview != PLAYER_WEBVIEW {
|
||||
log::warn!("playback refused to webview {webview}");
|
||||
return empty(StatusCode::FORBIDDEN);
|
||||
}
|
||||
let method = request.method();
|
||||
if method != Method::GET && method != Method::HEAD {
|
||||
return empty(StatusCode::METHOD_NOT_ALLOWED);
|
||||
}
|
||||
let Some(id) = call_id(request.uri().path()) else {
|
||||
return empty(StatusCode::NOT_FOUND);
|
||||
};
|
||||
let range = request
|
||||
.headers()
|
||||
.get(RANGE)
|
||||
.map(|value| value.to_str().unwrap_or_default());
|
||||
match serve(&cache_path(dir, id), range, method == Method::HEAD) {
|
||||
Ok(response) => response,
|
||||
Err(e) if e.kind() == ErrorKind::NotFound => empty(StatusCode::NOT_FOUND),
|
||||
Err(e) => {
|
||||
log::error!("call {id}: could not serve the playback file: {e}");
|
||||
empty(StatusCode::INTERNAL_SERVER_ERROR)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The answer while the app state is not set up yet (no window can play
|
||||
/// before it is, so this is never expected).
|
||||
pub fn unavailable() -> Response<Vec<u8>> {
|
||||
empty(StatusCode::SERVICE_UNAVAILABLE)
|
||||
}
|
||||
|
||||
/// The call id of a request path: exactly `/<digits>`.
|
||||
fn call_id(path: &str) -> Option<CallId> {
|
||||
let digits = path.strip_prefix('/')?;
|
||||
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
|
||||
return None;
|
||||
}
|
||||
digits.parse().ok()
|
||||
}
|
||||
|
||||
fn serve(path: &Path, range: Option<&str>, head: bool) -> io::Result<Response<Vec<u8>>> {
|
||||
let mut file = File::open(path)?;
|
||||
let len = file.metadata()?.len();
|
||||
let builder = headers();
|
||||
let Some(range) = range else {
|
||||
let mut body = Vec::new();
|
||||
if !head {
|
||||
file.read_to_end(&mut body)?;
|
||||
}
|
||||
return Ok(build(builder.header(CONTENT_LENGTH, len), body));
|
||||
};
|
||||
// A media element asks for one range at a time; of several, the first.
|
||||
let Some(range) = HttpRange::parse(range, len)
|
||||
.ok()
|
||||
.and_then(|r| r.first().copied())
|
||||
else {
|
||||
return Ok(build(
|
||||
builder
|
||||
.status(StatusCode::RANGE_NOT_SATISFIABLE)
|
||||
.header(CONTENT_RANGE, format!("bytes */{len}")),
|
||||
Vec::new(),
|
||||
));
|
||||
};
|
||||
let start = range.start;
|
||||
let count = range.length.min(MAX_RANGE_LEN);
|
||||
let mut body = Vec::new();
|
||||
if !head {
|
||||
file.seek(SeekFrom::Start(start))?;
|
||||
file.take(count).read_to_end(&mut body)?;
|
||||
}
|
||||
Ok(build(
|
||||
builder
|
||||
.status(StatusCode::PARTIAL_CONTENT)
|
||||
.header(
|
||||
CONTENT_RANGE,
|
||||
format!("bytes {start}-{}/{len}", start + count - 1),
|
||||
)
|
||||
.header(CONTENT_LENGTH, count),
|
||||
body,
|
||||
))
|
||||
}
|
||||
|
||||
/// Headers of every answer that carries the mix. Any origin may read it:
|
||||
/// only the main window's own page can reach the scheme at all (the
|
||||
/// webview check above), and on Linux it fetches the mix cross-origin.
|
||||
fn headers() -> response::Builder {
|
||||
Response::builder()
|
||||
.header(CONTENT_TYPE, "audio/wav")
|
||||
.header(CACHE_CONTROL, "no-store")
|
||||
.header(ACCEPT_RANGES, "bytes")
|
||||
.header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
|
||||
.header(ACCESS_CONTROL_EXPOSE_HEADERS, "content-range")
|
||||
}
|
||||
|
||||
fn build(builder: response::Builder, body: Vec<u8>) -> Response<Vec<u8>> {
|
||||
builder
|
||||
.body(body)
|
||||
.unwrap_or_else(|_| empty(StatusCode::INTERNAL_SERVER_ERROR))
|
||||
}
|
||||
|
||||
fn empty(status: StatusCode) -> Response<Vec<u8>> {
|
||||
let mut response = Response::new(Vec::new());
|
||||
*response.status_mut() = status;
|
||||
response
|
||||
.headers_mut()
|
||||
.insert(CACHE_CONTROL, "no-store".parse().unwrap());
|
||||
response
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::fs;
|
||||
|
||||
use super::*;
|
||||
|
||||
/// A playback directory with a 10-byte "mix" for call 7.
|
||||
fn dir() -> tempfile::TempDir {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
fs::write(cache_path(dir.path(), 7), b"0123456789").unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
fn get(uri: &str, range: Option<&str>) -> Request<Vec<u8>> {
|
||||
let mut builder = Request::builder().uri(uri);
|
||||
if let Some(range) = range {
|
||||
builder = builder.header(RANGE, range);
|
||||
}
|
||||
builder.body(Vec::new()).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn only_the_main_window_gets_the_mix() {
|
||||
let dir = dir();
|
||||
let request = get("playback://localhost/7", None);
|
||||
for webview in ["backend-login", "prompt", "recorder", "", "Main"] {
|
||||
let response = respond(webview, &request, dir.path());
|
||||
assert_eq!(response.status(), StatusCode::FORBIDDEN, "{webview}");
|
||||
assert!(response.body().is_empty());
|
||||
}
|
||||
|
||||
let response = respond("main", &request, dir.path());
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
assert_eq!(response.body(), b"0123456789");
|
||||
assert_eq!(response.headers()[CONTENT_TYPE], "audio/wav");
|
||||
assert_eq!(response.headers()[CACHE_CONTROL], "no-store");
|
||||
assert_eq!(response.headers()[CONTENT_LENGTH], "10");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn both_platform_url_forms_name_the_call() {
|
||||
let dir = dir();
|
||||
for uri in ["playback://localhost/7", "http://playback.localhost/7"] {
|
||||
let response = respond("main", &get(uri, None), dir.path());
|
||||
assert_eq!(response.status(), StatusCode::OK, "{uri}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nothing_but_a_numeric_call_id_is_served() {
|
||||
let dir = dir();
|
||||
fs::write(dir.path().join("secret.wav"), b"x").unwrap();
|
||||
fs::write(dir.path().join("7.wav.part"), b"x").unwrap();
|
||||
for path in [
|
||||
"/",
|
||||
"/7.wav",
|
||||
"/secret",
|
||||
"/../7",
|
||||
"/%2e%2e%2f7",
|
||||
"/7/",
|
||||
"/7.wav.part",
|
||||
"/-7",
|
||||
"/+7",
|
||||
"/%EF%BC%97",
|
||||
"/99999999999999999999999",
|
||||
"/8",
|
||||
] {
|
||||
let request = get(&format!("playback://localhost{path}"), None);
|
||||
let response = respond("main", &request, dir.path());
|
||||
assert_eq!(response.status(), StatusCode::NOT_FOUND, "{path}");
|
||||
}
|
||||
assert_eq!(call_id("/7"), Some(7));
|
||||
assert_eq!(call_id("/0012"), Some(12));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_range_is_served_partially() {
|
||||
let dir = dir();
|
||||
let response = respond(
|
||||
"main",
|
||||
&get("playback://localhost/7", Some("bytes=2-5")),
|
||||
dir.path(),
|
||||
);
|
||||
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
|
||||
assert_eq!(response.body(), b"2345");
|
||||
assert_eq!(response.headers()[CONTENT_RANGE], "bytes 2-5/10");
|
||||
assert_eq!(response.headers()[CONTENT_LENGTH], "4");
|
||||
|
||||
let open_ended = respond(
|
||||
"main",
|
||||
&get("playback://localhost/7", Some("bytes=8-")),
|
||||
dir.path(),
|
||||
);
|
||||
assert_eq!(open_ended.body(), b"89");
|
||||
assert_eq!(open_ended.headers()[CONTENT_RANGE], "bytes 8-9/10");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_range_beyond_the_end_is_not_satisfiable() {
|
||||
let dir = dir();
|
||||
let response = respond(
|
||||
"main",
|
||||
&get("playback://localhost/7", Some("bytes=20-30")),
|
||||
dir.path(),
|
||||
);
|
||||
assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE);
|
||||
assert_eq!(response.headers()[CONTENT_RANGE], "bytes */10");
|
||||
assert!(response.body().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_long_range_is_cut_to_the_maximum() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let len = MAX_RANGE_LEN as usize * 2 + 3;
|
||||
fs::write(cache_path(dir.path(), 1), vec![1u8; len]).unwrap();
|
||||
let response = respond(
|
||||
"main",
|
||||
&get("playback://localhost/1", Some("bytes=1-")),
|
||||
dir.path(),
|
||||
);
|
||||
assert_eq!(response.body().len(), MAX_RANGE_LEN as usize);
|
||||
assert_eq!(
|
||||
response.headers()[CONTENT_RANGE],
|
||||
format!("bytes 1-{}/{len}", MAX_RANGE_LEN).as_str()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn head_has_no_body_and_other_methods_are_refused() {
|
||||
let dir = dir();
|
||||
let head = Request::builder()
|
||||
.method(Method::HEAD)
|
||||
.uri("playback://localhost/7")
|
||||
.body(Vec::new())
|
||||
.unwrap();
|
||||
let response = respond("main", &head, dir.path());
|
||||
assert_eq!(response.status(), StatusCode::OK);
|
||||
assert_eq!(response.headers()[CONTENT_LENGTH], "10");
|
||||
assert!(response.body().is_empty());
|
||||
|
||||
let post = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri("playback://localhost/7")
|
||||
.body(Vec::new())
|
||||
.unwrap();
|
||||
let response = respond("main", &post, dir.path());
|
||||
assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
|
||||
}
|
||||
}
|
||||
+103
-21
@@ -7,7 +7,7 @@
|
||||
//! independent of windows and events; the command layer turns results into
|
||||
//! UI updates.
|
||||
|
||||
use std::collections::{HashSet, VecDeque};
|
||||
use std::collections::{HashMap, HashSet, VecDeque};
|
||||
use std::fs;
|
||||
use std::io::ErrorKind;
|
||||
use std::path::{Path, PathBuf};
|
||||
@@ -24,7 +24,7 @@ use recorder_core::capture::{CaptureSource, OutputTarget};
|
||||
use recorder_core::detect::{CallDetector, DetectorEvent, MicSession};
|
||||
use recorder_core::http::{HttpTransport, ReqwestTransport};
|
||||
use recorder_core::model::{Call, CallId, CallStatus, Speaker};
|
||||
use recorder_core::playback::{self, PlaybackInfo};
|
||||
use recorder_core::playback;
|
||||
use recorder_core::recorder::Recorder;
|
||||
use recorder_core::secrets::{SecretStore, Service};
|
||||
use recorder_core::settings::Settings;
|
||||
@@ -149,12 +149,12 @@ pub struct AppState {
|
||||
settings: Mutex<Settings>,
|
||||
settings_path: PathBuf,
|
||||
recordings_dir: PathBuf,
|
||||
/// Where the mixes for playback are cached (`<app cache>/playback`,
|
||||
/// the only directory the webview's asset protocol may read).
|
||||
/// Where the mixes for playback are cached (`<app cache>/playback`),
|
||||
/// served to the main window by [`crate::playback`].
|
||||
playback_dir: PathBuf,
|
||||
/// Held while a mix is built or removed, so a call deleted meanwhile
|
||||
/// never leaves its mix behind.
|
||||
playback_lock: Mutex<()>,
|
||||
/// The leases on cached mixes. Held while a mix is built or removed,
|
||||
/// so a call deleted meanwhile never leaves its mix behind.
|
||||
playback: Mutex<PlaybackLeases>,
|
||||
current: Mutex<Option<CurrentRecording>>,
|
||||
detector: Mutex<CallDetector>,
|
||||
/// Stopped calls awaiting the end-of-call prompt's decision, oldest
|
||||
@@ -181,6 +181,23 @@ pub struct AppState {
|
||||
upload_confirmed_unsaved: Mutex<HashSet<CallId>>,
|
||||
}
|
||||
|
||||
/// A mix ready to play, from [`AppState::prepare_playback`].
|
||||
#[derive(Serialize, Clone, Copy, Debug, PartialEq)]
|
||||
pub struct PreparedPlayback {
|
||||
pub duration_secs: f64,
|
||||
/// Hand back to [`AppState::release_playback`] when the player is done.
|
||||
pub lease: u64,
|
||||
}
|
||||
|
||||
/// Which player holds each cached mix: the lease of the latest
|
||||
/// [`AppState::prepare_playback`] per call. A player that lets go of an
|
||||
/// older lease (it was replaced by a newer one meanwhile) removes nothing.
|
||||
#[derive(Default)]
|
||||
struct PlaybackLeases {
|
||||
next: u64,
|
||||
latest: HashMap<CallId, u64>,
|
||||
}
|
||||
|
||||
/// An upload reserved with [`AppState::claim_upload`]; released when
|
||||
/// dropped, also if the upload fails or panics.
|
||||
pub struct UploadClaim<'a> {
|
||||
@@ -221,7 +238,7 @@ impl AppState {
|
||||
settings_path,
|
||||
recordings_dir,
|
||||
playback_dir,
|
||||
playback_lock: Mutex::new(()),
|
||||
playback: Mutex::new(PlaybackLeases::default()),
|
||||
current: Mutex::new(None),
|
||||
detector: Mutex::new(detector),
|
||||
pending_prompts: Mutex::new(VecDeque::new()),
|
||||
@@ -672,29 +689,53 @@ impl AppState {
|
||||
}
|
||||
|
||||
/// Mixes call `id`'s tracks for playback (or reuses the cached mix,
|
||||
/// see [`playback::prepare`]). Refused while the call is recorded or
|
||||
/// processed, and once its audio is gone.
|
||||
pub fn prepare_playback(&self, id: CallId) -> Result<PlaybackInfo, String> {
|
||||
/// see [`playback::prepare`]) under a new lease. Refused while the call
|
||||
/// is recorded or processed, and once its audio is gone.
|
||||
pub fn prepare_playback(&self, id: CallId) -> Result<PreparedPlayback, String> {
|
||||
if lock(&self.current)
|
||||
.as_ref()
|
||||
.is_some_and(|cur| cur.call_id == id)
|
||||
{
|
||||
return Err(playback::RECORDING.to_string());
|
||||
}
|
||||
let _building = lock(&self.playback_lock);
|
||||
let mut leases = lock(&self.playback);
|
||||
// Read under the lock: a call deleted before it is not mixed, one
|
||||
// deleted meanwhile has its mix removed once the lock is free.
|
||||
let call = self.find_call(id)?;
|
||||
playback::prepare(&call, &self.playback_dir)
|
||||
let info = playback::prepare(&call, &self.playback_dir)?;
|
||||
leases.next += 1;
|
||||
let lease = leases.next;
|
||||
leases.latest.insert(id, lease);
|
||||
Ok(PreparedPlayback {
|
||||
duration_secs: info.duration_secs,
|
||||
lease,
|
||||
})
|
||||
}
|
||||
|
||||
/// Removes call `id`'s cached mix, once the call or its audio is
|
||||
/// deleted.
|
||||
/// The player of `lease` is done with call `id`'s mix: removes it,
|
||||
/// unless a newer lease (another player of the same call) holds it.
|
||||
pub fn release_playback(&self, id: CallId, lease: u64) {
|
||||
let mut leases = lock(&self.playback);
|
||||
if leases.latest.get(&id) == Some(&lease) {
|
||||
leases.latest.remove(&id);
|
||||
playback::remove_cached(&self.playback_dir, id);
|
||||
}
|
||||
}
|
||||
|
||||
/// Removes call `id`'s cached mix whoever holds it: with the call, and
|
||||
/// once its audio is deleted. The retention job, when it deletes a
|
||||
/// call's audio, calls this too.
|
||||
pub fn remove_playback(&self, id: CallId) {
|
||||
let _building = lock(&self.playback_lock);
|
||||
let mut leases = lock(&self.playback);
|
||||
leases.latest.remove(&id);
|
||||
playback::remove_cached(&self.playback_dir, id);
|
||||
}
|
||||
|
||||
/// Where the mixes are cached ([`crate::playback`] serves them).
|
||||
pub fn playback_dir(&self) -> &Path {
|
||||
&self.playback_dir
|
||||
}
|
||||
|
||||
/// Empties the playback cache (at startup), so mixed customer audio
|
||||
/// never lingers from an earlier run.
|
||||
pub fn clear_playback_cache(&self) {
|
||||
@@ -1968,10 +2009,49 @@ mod tests {
|
||||
let id = playable_call(&f, "a");
|
||||
assert!(f.state.call_detail(id).unwrap().audio_available);
|
||||
|
||||
let info = f.state.prepare_playback(id).unwrap();
|
||||
assert_eq!(info.path, playback_file(&f, id));
|
||||
assert!((info.duration_secs - 1.0).abs() < 1e-9);
|
||||
assert!(info.path.exists());
|
||||
let prepared = f.state.prepare_playback(id).unwrap();
|
||||
assert!((prepared.duration_secs - 1.0).abs() < 1e-9);
|
||||
assert!(playback_file(&f, id).exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_player_holding_the_latest_lease_removes_the_mix() {
|
||||
let f = fixture();
|
||||
let id = playable_call(&f, "a");
|
||||
let first = f.state.prepare_playback(id).unwrap().lease;
|
||||
// The call was shown again before the first player let go.
|
||||
let second = f.state.prepare_playback(id).unwrap().lease;
|
||||
assert_ne!(first, second);
|
||||
|
||||
f.state.release_playback(id, first);
|
||||
assert!(
|
||||
playback_file(&f, id).exists(),
|
||||
"the second player still plays"
|
||||
);
|
||||
f.state.release_playback(id, second);
|
||||
assert!(!playback_file(&f, id).exists());
|
||||
f.state.release_playback(id, second); // already gone: no error
|
||||
|
||||
// A lease of one call never removes another call's mix.
|
||||
let other = playable_call(&f, "b");
|
||||
let lease = f.state.prepare_playback(other).unwrap().lease;
|
||||
f.state.release_playback(id, lease);
|
||||
assert!(playback_file(&f, other).exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn missing_files_are_no_audio_but_not_deleted_audio() {
|
||||
let f = fixture();
|
||||
let (id, mic, out) = finished_call(&f, "a"); // a few junk bytes each
|
||||
let detail = f.state.call_detail(id).unwrap();
|
||||
assert!(!detail.audio_available);
|
||||
assert!(!detail.audio_deleted);
|
||||
fs::remove_file(mic).unwrap();
|
||||
fs::remove_file(out).unwrap();
|
||||
assert_eq!(
|
||||
f.state.prepare_playback(id),
|
||||
Err(playback::AUDIO_MISSING.to_string())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -2021,7 +2101,9 @@ mod tests {
|
||||
fs::remove_file(&call.out_path).unwrap();
|
||||
f.state.store.mark_audio_deleted(id).unwrap();
|
||||
|
||||
assert!(!f.state.call_detail(id).unwrap().audio_available);
|
||||
let detail = f.state.call_detail(id).unwrap();
|
||||
assert!(!detail.audio_available);
|
||||
assert!(detail.audio_deleted);
|
||||
assert_eq!(
|
||||
f.state.prepare_playback(id),
|
||||
Err(playback::AUDIO_GONE.to_string())
|
||||
|
||||
@@ -44,13 +44,7 @@
|
||||
}
|
||||
],
|
||||
"security": {
|
||||
"csp": null,
|
||||
"assetProtocol": {
|
||||
"enable": true,
|
||||
"scope": [
|
||||
"$APPCACHE/playback/**"
|
||||
]
|
||||
}
|
||||
"csp": null
|
||||
}
|
||||
},
|
||||
"bundle": {
|
||||
|
||||
Reference in New Issue
Block a user