Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
Linux cancelled or crashed Instant starts delete their empty video (#3350)
Richie McIlroy98fe6cb46d3f
diff --git a/.github/workflows/instant-reliability.yml b/.github/workflows/instant-reliability.ymlindex f3213417d..a0655c46e 100644--- a/.github/workflows/instant-reliability.yml+++ b/.github/workflows/instant-reliability.yml@@ -6,8 +6,7 @@ name: Instant reliability (real app)# followed by Recover. Each case checks what reached the mock server and what# was left on disk, so a regression that loses a recording, deletes one with# media, or leaves an empty video behind fails here. The Linux job runs the-# cases whose expectations hold there on Xvfb: Linux keeps a cancelled or-# crashed start's files and video rather than deleting them.+# same cases on Xvfb, recording another app's window.on:pull_request:@@ -262,7 +261,8 @@ jobs:CAP_GPUI_AUTO_OVERLAY=window CAP_GPUI_AUTO_WINDOW=xmessage \dbus-run-session -- "$(cat "$RUNNER_TEMP/test-binary")" --ignored --test-threads=1 --nocapture \real_app_instant_recording_uploads_and_verifies real_app_recovered_recording_uploads \- real_app_start_cue_waits_for_a_slow_server_video+ real_app_start_cue_waits_for_a_slow_server_video real_app_cancelled_start_deletes_its_video \+ real_app_crashes_never_delete_a_recording_with_media- name: Upload sandboxesif: failure()diff --git a/apps/desktop-gpui/src/recording.rs b/apps/desktop-gpui/src/recording.rsindex 1cf1b8a6e..c9658a5c0 100644--- a/apps/desktop-gpui/src/recording.rs+++ b/apps/desktop-gpui/src/recording.rs@@ -118,6 +118,9 @@ pub(crate) struct InstantAttempt(Arc<InstantAttemptInner>);#[cfg(target_os = "linux")]struct InstantAttemptInner {lifecycle: Mutex<Option<instant_recording::InstantLifecycle>>,+ /// The server video and folder of a start still being built. A cancelled+ /// start drops the build before it can clean up, so the attempt does it.+ video: Mutex<Option<(String, PathBuf)>>,cancelled: tokio::sync::watch::Sender<bool>,startup: tokio::sync::watch::Sender<StartupState>,}@@ -136,6 +139,7 @@ impl InstantAttempt {pub fn new() -> Self {Self(Arc::new(InstantAttemptInner {lifecycle: Mutex::new(None),+ video: Mutex::new(None),cancelled: tokio::sync::watch::channel(false).0,startup: tokio::sync::watch::channel(StartupState::Unstarted).0,}))@@ -313,9 +317,14 @@ whereif result.is_err() {attempt.cancel();let lifecycle = attempt.0.lifecycle.lock().unwrap().clone();- if let Some(lifecycle) = lifecycle {- lifecycle.wait_for_quiescence().await;- }+ let joined = match lifecycle {+ Some(lifecycle) => {+ lifecycle.wait_for_quiescence().await+ == instant_recording::InstantQuiescence::Joined+ }+ None => true,+ };+ discard_unstarted_video(&attempt, joined).await;}if let Err(Ok(active)) = sender.send(result) {let _ = cleanup(active).await;@@ -1123,21 +1132,32 @@ impl ActiveRecording {/// delete and restart flows. Deleting a directory this app just created is/// app behavior, same as the Tauri delete button.pub async fn cancel_and_delete(self) -> anyhow::Result<()> {- self.cancel_and_delete_with_query(None).await+ self.cancel_and_delete_with_query(None, false).await}/// `cancel_and_delete` for a start that was superseded before it began,- /// telling the server why its Instant video is deleted.- #[cfg(not(target_os = "linux"))]+ /// telling the server why its Instant video is deleted. On Linux a start+ /// that wrote media by the time capture stopped keeps it, as after a crash.pub(crate) async fn discard_cancelled_start(self) -> anyhow::Result<()> {+ #[cfg(target_os = "linux")]+ if !matches!(self.handle, Handle::Instant(_)) {+ return self.cancel_preserving().await;+ }let query = crate::upload::instant_cleanup::delete_query(crate::upload::instant_cleanup::CleanupReason::StartCancelled,None,);- self.cancel_and_delete_with_query(query).await+ self.cancel_and_delete_with_query(query, cfg!(target_os = "linux"))+ .await}- async fn cancel_and_delete_with_query(self, query: Option<String>) -> anyhow::Result<()> {+ /// `keep_media`: once capture has stopped, a folder holding media is kept+ /// as a stopped recording with its server video instead of being deleted.+ async fn cancel_and_delete_with_query(+ self,+ query: Option<String>,+ keep_media: bool,+ ) -> anyhow::Result<()> {if let Some(gate) = &self.start_gate {gate.arm();}@@ -1167,9 +1187,15 @@ impl ActiveRecording {Handle::Instant(handle) => {#[cfg(target_os = "linux")]{- let (_, result) =+ let (joined, result) =joined_instant_result(handle.lifecycle(), handle.cancel()).await;- result+ if joined {+ result+ } else {+ Err(anyhow!(+ "Instant capture cleanup is unconfirmed; local files preserved"+ ))+ }}#[cfg(not(target_os = "linux"))]{@@ -1185,6 +1211,26 @@ impl ActiveRecording {}return Err(error);}+ #[cfg(target_os = "linux")]+ if keep_media && crate::upload::instant_cleanup::project_holds_media(&self.project_dir) {+ let mut upload = match self.instant_upload.as_ref() {+ Some(upload) => Some(upload.lock().await),+ None => None,+ };+ let upload = upload.as_deref_mut().and_then(Option::as_mut);+ if let Some(upload) = upload {+ upload.abort_segments().await;+ return persist_preserved_instant_stop(+ &self.project_dir,+ Some(upload.metadata_lock()),+ true,+ Ok(()),+ );+ }+ return persist_preserved_instant_stop(&self.project_dir, None, true, Ok(()));+ }+ #[cfg(not(target_os = "linux"))]+ let _ = keep_media;let mut upload = match self.instant_upload.as_ref() {Some(upload) => upload.lock().await.take(),None => None,@@ -2137,6 +2183,35 @@ pub async fn start(config: StartConfig) -> anyhow::Result<ActiveRecording> {.await}+/// The server video of a start whose build was dropped: deleted with its+/// folder when capture stopped without writing media, as a cancelled start is+/// on macOS and Windows. Otherwise the cleanup journal keeps it for the sweep,+/// which never deletes a recording that holds media.+#[cfg(target_os = "linux")]+async fn discard_unstarted_video(attempt: &InstantAttempt, joined: bool) {+ use crate::upload::instant_cleanup::{self, CleanupReason};+ let Some((video_id, project_dir)) = attempt.0.video.lock().unwrap().take() else {+ return;+ };+ if !joined || instant_cleanup::project_holds_media(&project_dir) {+ instant_cleanup::abandon(&video_id, CleanupReason::StartCancelled, None);+ return;+ }+ let query = instant_cleanup::delete_query(CleanupReason::StartCancelled, None);+ match crate::upload::delete_instant_video_with_query(&video_id, query.as_deref()).await {+ Ok(()) => {+ instant_cleanup::resolved(&video_id);+ if let Err(error) = tokio::fs::remove_dir_all(&project_dir).await {+ tracing::warn!(%error, path = %project_dir.display(), "Could not remove a cancelled start's folder");+ }+ }+ Err(error) => {+ tracing::warn!(%error, video_id, "Could not delete a cancelled start's video");+ instant_cleanup::abandon(&video_id, CleanupReason::StartCancelled, None);+ }+ }+}+#[cfg(target_os = "linux")]pub(crate) fn start_tracked(config: StartConfig,@@ -2145,7 +2220,7 @@ pub(crate) fn start_tracked(owned_instant_start(attempt.clone(),start_internal(config, Some(attempt)),- ActiveRecording::cancel_preserving,+ ActiveRecording::discard_cancelled_start,)}@@ -2188,6 +2263,10 @@ async fn start_internal(.await.map_err(anyhow::Error::msg)?;crate::upload::instant_cleanup::begin(&video.id, &project_dir);+ #[cfg(target_os = "linux")]+ if let Some(attempt) = &attempt {+ *attempt.0.video.lock().unwrap() = Some((video.id.clone(), project_dir.clone()));+ }Some(video)} else {None@@ -2226,10 +2305,18 @@ async fn start_internal(Err(error) => {instant_cleanup::abandon(&video.id, CleanupReason::StartFailed, Some(cause));tracing::error!(video_id = %video.id, "Failed to clean up instant recording: {error}");+ #[cfg(target_os = "linux")]+ if let Some(attempt) = &attempt {+ attempt.0.video.lock().unwrap().take();+ }return Err(anyhow!("Failed to clean up instant recording: {error}"));}}}+ #[cfg(target_os = "linux")]+ if let Some(attempt) = &attempt {+ attempt.0.video.lock().unwrap().take();+ }result}diff --git a/apps/desktop-gpui/src/session.rs b/apps/desktop-gpui/src/session.rsindex c30faff40..20ef9f7ec 100644--- a/apps/desktop-gpui/src/session.rs+++ b/apps/desktop-gpui/src/session.rs@@ -990,9 +990,6 @@ impl RecordingSession {if let Some(previous) = previous {let _ = previous.await;}- #[cfg(target_os = "linux")]- let discarded = active.cancel_preserving().await;- #[cfg(not(target_os = "linux"))]let discarded = active.discard_cancelled_start().await;match discarded {Ok(()) => {diff --git a/apps/desktop-gpui/src/upload/instant_cleanup.rs b/apps/desktop-gpui/src/upload/instant_cleanup.rsindex 1e1fcd71e..fc58e1f0c 100644--- a/apps/desktop-gpui/src/upload/instant_cleanup.rs+++ b/apps/desktop-gpui/src/upload/instant_cleanup.rs@@ -353,11 +353,8 @@ fn abandon_at(/// Records a pre-created Instant video before capture starts, so a crash,/// panic or aborted discard during startup still gets its server copy-/// deleted on the next sweep. Linux keeps its own startup cleanup contract.+/// deleted on the next sweep.pub(crate) fn begin(video_id: &str, project_dir: &Path) {- if cfg!(target_os = "linux") {- return;- }let Some(owner_id) = current_owner_id() else {return;};@@ -372,16 +369,10 @@ pub(crate) fn begin(video_id: &str, project_dir: &Path) {}pub(crate) fn started(video_id: &str) {- if cfg!(target_os = "linux") {- return;- }remove_at(&journal_path(), video_id);}pub(crate) fn resolved(video_id: &str) {- if cfg!(target_os = "linux") {- return;- }remove_at(&journal_path(), video_id);}@@ -390,16 +381,10 @@ pub(crate) fn resolved(video_id: &str) {/// removed and delete the uploaded video. False when the entry is still there,/// so the caller keeps the local copy.pub(crate) fn forget_verified(video_id: &str) -> bool {- if cfg!(target_os = "linux") {- return true;- }forget_at(&journal_path(), video_id)}pub(crate) fn abandon(video_id: &str, reason: CleanupReason, cause: Option<StartFailureCause>) {- if cfg!(target_os = "linux") {- return;- }let identity = current_owner_id().map(|owner| (auth::server_url(), owner));abandon_at(&journal_path(), video_id, reason, cause, identity, now());}@@ -433,6 +418,12 @@ fn meta_claims(meta: &RecordingMeta, video_id: &str) -> bool {|| upload_meta_video_id(meta) == Some(video_id)}+/// Whether a recording folder holds media a crash or a cancelled start must+/// not delete.+pub(crate) fn project_holds_media(project: &Path) -> bool {+ has_recorded_media(&project.join("content"), MEDIA_SCAN_DEPTH)+}+/// True when the folder holds recorded media, or when part of it cannot be/// read: media that cannot be checked counts as present. Only a missing folder/// counts as empty. A segment still named `.m4s.tmp` counts too, since a crash@@ -732,6 +723,18 @@ async fn sweep(path: &Path, session: &str, now: i64, backend: &impl SweepBackendsummary}+/// Whether the sweep keeps an entry's server video while its folder holds+/// media. A crashed start's folder may have recorded before the crash; on+/// Linux a cancelled start that wrote media keeps it too+/// (`ActiveRecording::discard_cancelled_start`), so its video must stay.+fn guards_media(reason: CleanupReason) -> bool {+ match reason {+ CleanupReason::Interrupted => true,+ CleanupReason::StartCancelled => cfg!(target_os = "linux"),+ CleanupReason::StartFailed => false,+ }+}+struct LiveSweep;impl SweepBackend for LiveSweep {@@ -741,13 +744,13 @@ impl SweepBackend for LiveSweep {async fn protected(&self, entry: &Entry) -> bool {let video_id = entry.video_id.clone();- let interrupted = entry.effective_reason() == CleanupReason::Interrupted;+ let guards_media = guards_media(entry.effective_reason());let start_project = entry.project_dir.clone();tokio::task::spawn_blocking(move || {locally_protected(&crate::library::known_recordings_dirs(),&video_id,- interrupted,+ guards_media,start_project.as_deref(),)})@@ -809,9 +812,6 @@ async fn run() {}pub(crate) fn init(cx: &mut gpui::App) {- if cfg!(target_os = "linux") {- return;- }session_id();launched_at();gpui_tokio::Tokio::spawn(cx, run()).detach();@@ -1355,6 +1355,29 @@ mod tests {assert!(!locally_protected(&[recordings], "video", false, None));}+ #[test]+ fn a_cancelled_start_guards_media_where_it_keeps_it() {+ assert!(guards_media(CleanupReason::Interrupted));+ assert!(!guards_media(CleanupReason::StartFailed));+ assert_eq!(+ guards_media(CleanupReason::StartCancelled),+ cfg!(target_os = "linux")+ );+ let fixture = Fixture::new();+ let recordings = fixture.recordings();+ let project = write_project(&recordings, "cancelled.cap", "video", in_progress());+ std::fs::write(project.join("content/display/segment_001.m4s"), b"media").unwrap();+ assert_eq!(+ locally_protected(+ &[recordings],+ "video",+ guards_media(CleanupReason::StartCancelled),+ Some(&project),+ ),+ cfg!(target_os = "linux")+ );+ }+#[cfg(unix)]#[test]fn media_that_cannot_be_read_protects_an_interrupted_start() {