Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(desktop-gpui): keep a recovered recording locally when its sealed tracks leave media out

Richie McIlroyae45c34602a5
diff --git a/apps/desktop-gpui/src/recording.rs b/apps/desktop-gpui/src/recording.rs
index 9e48d4201..1cf1b8a6e 100644
--- a/apps/desktop-gpui/src/recording.rs
+++ b/apps/desktop-gpui/src/recording.rs
@@ -1467,8 +1467,15 @@ pub fn recover_instant_recording(project_path: &std::path::Path) -> anyhow::Resu
/// upload resume only accepts finished ones. Recovery stands if sealing fails;
/// the recording is saved locally either way, and its upload then fails as it
/// did before sealing existed.
+///
+/// Recovery can rescue a final fragment the manifest never listed, so the
+/// recovered `output.mp4` may hold more than the sealed tracks. Whenever
+/// sealing sets any media aside, or fails, the local recording is kept after
+/// its upload verifies, so it is never the only complete copy that gets
+/// deleted.
pub(crate) fn seal_recovered_instant_tracks(project_path: &std::path::Path) {
use cap_enc_ffmpeg::segmented_stream::SegmentMediaType;
+ let mut omitted = false;
for (track, media_type) in [
("display", SegmentMediaType::Video),
("audio", SegmentMediaType::Audio),
@@ -1480,9 +1487,18 @@ pub(crate) fn seal_recovered_instant_tracks(project_path: &std::path::Path) {
match cap_recording::upload_resume::seal_interrupted_track(&directory, media_type) {
Ok(segments) => tracing::info!(track, segments, "Sealed a recovered Instant track"),
Err(error) => {
+ omitted = true;
tracing::warn!(track, %error, "Could not seal a recovered Instant track")
}
}
+ omitted |= std::fs::read_dir(&directory).map_or(true, |entries| {
+ entries
+ .flatten()
+ .any(|entry| entry.file_name().to_string_lossy().ends_with(".unsealed"))
+ });
+ }
+ if omitted && let Err(error) = crate::upload::queue::record_preserve_local(project_path) {
+ tracing::warn!(%error, "Could not keep a recovered recording after its upload");
}
}
diff --git a/apps/desktop-gpui/src/upload/queue.rs b/apps/desktop-gpui/src/upload/queue.rs
index 9cf7bf0f3..ca9581112 100644
--- a/apps/desktop-gpui/src/upload/queue.rs
+++ b/apps/desktop-gpui/src/upload/queue.rs
@@ -284,6 +284,16 @@ pub(super) fn record_cancelled(project: &Path) -> Result<(), String> {
Ok(())
}
+/// Keeps the local recording after its upload verifies, whatever the
+/// delete-after-upload setting says.
+pub(crate) fn record_preserve_local(project: &Path) -> Result<(), String> {
+ if let Some(mut state) = read_state(project)? {
+ state.preserve_local = true;
+ write_state(project, &state)?;
+ }
+ Ok(())
+}
+
pub(crate) fn record_failure(project: &Path, error: &str) -> Result<(), String> {
if let Some(mut state) = read_state(project)? {
state.fail(error.to_string(), now());
diff --git a/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs b/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs
index ee4b1034d..2030bf8d9 100644
--- a/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs
+++ b/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs
@@ -227,7 +227,9 @@ fn recover(project: &Path) {
/// The app crashes mid-recording and the user recovers the recording on the
/// next launch. The queue then uploads every segment the crash saved under
-/// the same video id and verifies it; the unfinished tail is kept on disk.
+/// the same video id and verifies it. The unfinished tail is kept on disk, and
+/// so is the whole recording, even with delete-after-upload on, because the
+/// upload leaves that tail out.
#[test]
fn recovered_instant_recording_uploads_what_the_crash_saved() {
let case = "queue_recovered_instant_upload";
@@ -236,10 +238,21 @@ fn recovered_instant_recording_uploads_what_the_crash_saved() {
virtual_time(async {
let mock = MockCap::start(Vec::new()).await;
scratch.sign_in(&mock.url);
+ let store = scratch.0.join("store");
+ let mut settings: serde_json::Value =
+ serde_json::from_slice(&std::fs::read(&store).unwrap()).unwrap();
+ settings["general_settings"]["deleteInstantRecordingsAfterUpload"] =
+ serde_json::json!(true);
+ std::fs::write(&store, serde_json::to_vec(&settings).unwrap()).unwrap();
let (project, video, audio) = saved_instant_project(&scratch.0, &mock.url);
let partials = crash_mid_recording(&project);
recover(&project);
+ assert!(
+ read_state(&project).unwrap().unwrap().preserve_local,
+ "a recording whose sealed tracks leave media out must stay local"
+ );
+
let manager = Arc::new(Manager::new(LiveBackend, CONFIRMATION_TIMEOUT));
launch(&manager, &project).await;
settle(&manager).await;