Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(desktop-gpui): serialize recording deletes with the background Studio thumbnail write

Richie McIlroy39f167cc78e8
diff --git a/apps/desktop-gpui/src/library.rs b/apps/desktop-gpui/src/library.rs
index dc57098a7..fe2a79286 100644
--- a/apps/desktop-gpui/src/library.rs
+++ b/apps/desktop-gpui/src/library.rs
@@ -570,6 +570,7 @@ pub fn delete_recording_directory_in(dirs: &[PathBuf], path: &Path) -> Result<()
};
if let Some(canonical_path) = canonical_path {
+ let _thumbnails = crate::recording::hold_studio_thumbnail_writes();
std::fs::remove_dir_all(canonical_path)
.map_err(|error| format!("Failed to delete recording: {error}"))?;
}
diff --git a/apps/desktop-gpui/src/recording.rs b/apps/desktop-gpui/src/recording.rs
index e5da9a597..e3f38cdf8 100644
--- a/apps/desktop-gpui/src/recording.rs
+++ b/apps/desktop-gpui/src/recording.rs
@@ -477,6 +477,9 @@ async fn finalize_studio(
let pending = PendingStudioThumbnail::new();
tokio::task::spawn_blocking(move || {
let _pending = pending;
+ let _writing = STUDIO_THUMBNAIL_WRITES
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
let thumbnail_started = std::time::Instant::now();
if let Some(display_path) = studio_display_path(&project_path) {
write_bundle_thumbnail(&project_path, &display_path);
@@ -1452,6 +1455,25 @@ fn studio_display_path(project_path: &std::path::Path) -> Option<PathBuf> {
path.is_file().then_some(path)
}
+static STUDIO_THUMBNAIL_WRITES: Mutex<()> = Mutex::new(());
+
+/// Deleting a recording waits for a Studio stop thumbnail being written, which
+/// checks its bundle still exists under the same lock, so the two can neither
+/// race nor leave a deleted bundle half recreated.
+pub(crate) fn hold_studio_thumbnail_writes() -> Option<std::sync::MutexGuard<'static, ()>> {
+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
+ loop {
+ match STUDIO_THUMBNAIL_WRITES.try_lock() {
+ Ok(guard) => return Some(guard),
+ Err(std::sync::TryLockError::Poisoned(poisoned)) => return Some(poisoned.into_inner()),
+ Err(std::sync::TryLockError::WouldBlock) if std::time::Instant::now() < deadline => {
+ std::thread::sleep(std::time::Duration::from_millis(5));
+ }
+ Err(std::sync::TryLockError::WouldBlock) => return None,
+ }
+ }
+}
+
static PENDING_STUDIO_THUMBNAILS: std::sync::atomic::AtomicUsize =
std::sync::atomic::AtomicUsize::new(0);
@@ -4001,13 +4023,14 @@ mod studio_finalization_tests {
assert!(finalization.wait().await.is_err());
}
- #[tokio::test(flavor = "multi_thread")]
- async fn studio_stop_writes_its_thumbnail_after_returning() {
+ static THUMBNAIL_TESTS: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
+
+ fn stopped_studio_project(tag: &str) -> studio_recording::CompletedRecording {
use cap_project::{RecordingMeta, RecordingMetaInner, StudioRecordingMeta};
let _ = ffmpeg::init();
let root = std::env::temp_dir().join(format!(
- "cap-gpui-stop-thumbnail-{}.cap",
+ "cap-gpui-stop-thumbnail-{tag}-{}.cap",
crate::store::new_uuid_v4()
));
std::fs::create_dir_all(root.join("content")).unwrap();
@@ -4030,24 +4053,35 @@ mod studio_finalization_tests {
}
.save_for_project()
.unwrap();
- let written = studio_thumbnail_events();
- while written.try_recv().is_ok() {}
-
- let completed = studio_recording::CompletedRecording {
- project_path: root.clone(),
+ studio_recording::CompletedRecording {
+ project_path: root,
meta,
cursor_data: Default::default(),
clean_stopped: None,
- };
- let project = finalize_studio(completed, ScreenCaptureTarget::CameraOnly, None, None)
- .await
- .unwrap();
- assert_eq!(project, root);
+ }
+ }
+ async fn next_thumbnail_event(written: &flume::Receiver<()>) {
tokio::time::timeout(std::time::Duration::from_secs(30), written.recv_async())
.await
.unwrap()
.unwrap();
+ }
+
+ #[tokio::test(flavor = "multi_thread")]
+ async fn studio_stop_writes_its_thumbnail_after_returning() {
+ let _serial = THUMBNAIL_TESTS.lock().await;
+ let completed = stopped_studio_project("written");
+ let root = completed.project_path.clone();
+ let written = studio_thumbnail_events();
+ while written.try_recv().is_ok() {}
+
+ let project = finalize_studio(completed, ScreenCaptureTarget::CameraOnly, None, None)
+ .await
+ .unwrap();
+ assert_eq!(project, root);
+
+ next_thumbnail_event(&written).await;
assert!(!studio_thumbnails_pending());
let thumbnail = image::open(crate::library::bundle_thumbnail_path(&root))
.unwrap()
@@ -4056,6 +4090,52 @@ mod studio_finalization_tests {
std::fs::remove_dir_all(root).unwrap();
}
+ #[tokio::test(flavor = "multi_thread")]
+ async fn thumbnail_written_after_a_delete_does_not_recreate_the_bundle() {
+ let _serial = THUMBNAIL_TESTS.lock().await;
+ let completed = stopped_studio_project("deleted");
+ let root = completed.project_path.clone();
+ let written = studio_thumbnail_events();
+ while written.try_recv().is_ok() {}
+
+ let deleting = hold_studio_thumbnail_writes().unwrap();
+ finalize_studio(completed, ScreenCaptureTarget::CameraOnly, None, None)
+ .await
+ .unwrap();
+ assert!(studio_thumbnails_pending());
+ std::fs::remove_dir_all(&root).unwrap();
+ drop(deleting);
+
+ next_thumbnail_event(&written).await;
+ assert!(!root.exists());
+ }
+
+ #[tokio::test(flavor = "multi_thread")]
+ async fn deleting_a_recording_waits_for_its_thumbnail_write() {
+ let _serial = THUMBNAIL_TESTS.lock().await;
+ let library = std::env::temp_dir().join(format!(
+ "cap-gpui-stop-thumbnail-library-{}",
+ crate::store::new_uuid_v4()
+ ));
+ let bundle = library.join("Recording.cap");
+ std::fs::create_dir_all(bundle.join("screenshots")).unwrap();
+
+ let writing = hold_studio_thumbnail_writes().unwrap();
+ let delete = std::thread::spawn({
+ let library = library.clone();
+ let bundle = bundle.clone();
+ move || crate::library::delete_recording_directory_in(&[library], &bundle)
+ });
+ std::thread::sleep(std::time::Duration::from_millis(200));
+ assert!(!delete.is_finished());
+ assert!(bundle.exists());
+ drop(writing);
+
+ assert_eq!(delete.join().unwrap(), Ok(()));
+ assert!(!bundle.exists());
+ std::fs::remove_dir_all(library).unwrap();
+ }
+
#[test]
fn readiness_identity_does_not_confuse_retries_or_later_recordings() {
let (_, first) = channel();