Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
fix(desktop-gpui): upload a recovered Instant recording by sealing its tracks
Richie McIlroy8c005bf5a4fe
diff --git a/apps/desktop-gpui/src/recording.rs b/apps/desktop-gpui/src/recording.rsindex 7c91d53e2..d17187bd5 100644--- a/apps/desktop-gpui/src/recording.rs+++ b/apps/desktop-gpui/src/recording.rs@@ -1411,7 +1411,7 @@ pub(crate) fn ensure_finalization_storage(project_path: &std::path::Path) -> any}pub fn recover_instant_recording(project_path: &std::path::Path) -> anyhow::Result<PathBuf> {- use cap_project::{InstantRecordingMeta, RecordingMeta, RecordingMetaInner};+ use cap_project::{InstantRecordingMeta, RecordingMeta, RecordingMetaInner, UploadMeta};let mut meta = RecordingMeta::load_for_project(project_path).map_err(|error| anyhow!("loading recording metadata: {error}"))?;@@ -1450,6 +1450,9 @@ pub fn recover_instant_recording(project_path: &std::path::Path) -> anyhow::Resu.map(|decoder| decoder.rate())}).transpose()?;+ if matches!(meta.upload, Some(UploadMeta::SegmentUpload { .. })) {+ seal_recovered_instant_tracks(project_path);+ }meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::Complete {fps: fps.round() as u32,sample_rate,@@ -1459,6 +1462,30 @@ pub fn recover_instant_recording(project_path: &std::path::Path) -> anyhow::ResuOk(project_path.to_path_buf())}+/// Seals the tracks of a recovered Instant recording so the upload queue can+/// send what the crash left: the crash leaves each manifest unfinished, and the+/// 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.+pub(crate) fn seal_recovered_instant_tracks(project_path: &std::path::Path) {+ use cap_enc_ffmpeg::segmented_stream::SegmentMediaType;+ for (track, media_type) in [+ ("display", SegmentMediaType::Video),+ ("audio", SegmentMediaType::Audio),+ ] {+ let directory = project_path.join("content").join(track);+ if !directory.join("manifest.json").exists() {+ continue;+ }+ match cap_recording::upload_resume::seal_interrupted_track(&directory, media_type) {+ Ok(segments) => tracing::info!(track, segments, "Sealed a recovered Instant track"),+ Err(error) => {+ tracing::warn!(track, %error, "Could not seal a recovered Instant track")+ }+ }+ }+}+/// The first segment's display track, which is what/// `handle_recording_finish` hands `create_screenshot`/// (`apps/desktop/src-tauri/src/recording.rs:3415-3429`).@@ -2810,6 +2837,110 @@ mod tests {#[cfg(target_os = "linux")]use std::time::Duration;+ fn copy_tree(from: &std::path::Path, to: &std::path::Path) {+ std::fs::create_dir_all(to).unwrap();+ for entry in std::fs::read_dir(from).unwrap() {+ let entry = entry.unwrap();+ let target = to.join(entry.file_name());+ if entry.file_type().unwrap().is_dir() {+ copy_tree(&entry.path(), &target);+ } else {+ std::fs::copy(entry.path(), target).unwrap();+ }+ }+ }++ /// A real Instant recording copied mid-capture, which is what a crash+ /// leaves, then recovered: Recover saves it locally and seals its track,+ /// so the upload resume accepts every segment the crash saved.+ #[test]+ fn recovering_a_crashed_instant_recording_seals_it_for_upload() {+ use cap_enc_ffmpeg::segmented_stream::{+ SegmentMediaType, SegmentedVideoEncoder, SegmentedVideoEncoderConfig,+ };+ use cap_project::{+ InstantRecordingMeta, RecordingMeta, RecordingMetaInner, S3UploadMeta, UploadMeta,+ VideoUploadInfo,+ };+ ffmpeg::init().unwrap();+ let live = tempfile::tempdir().unwrap();+ let display = live.path().join("display");+ let info = cap_media_info::VideoInfo {+ pixel_format: cap_media_info::Pixel::NV12,+ width: 64,+ height: 64,+ time_base: ffmpeg::Rational(1, 1_000_000),+ frame_rate: ffmpeg::Rational(30, 1),+ };+ let mut encoder = SegmentedVideoEncoder::init(+ display.clone(),+ info,+ SegmentedVideoEncoderConfig {+ segment_duration: std::time::Duration::from_secs(1),+ ..Default::default()+ },+ )+ .unwrap();+ for index in 0..110u64 {+ let mut frame = ffmpeg::frame::Video::new(ffmpeg::format::Pixel::NV12, 64, 64);+ for plane in 0..frame.planes() {+ frame.data_mut(plane).fill((index % 200) as u8);+ }+ encoder+ .queue_frame(+ frame,+ std::time::Duration::from_nanos(index * 1_000_000_000 / 30),+ )+ .unwrap();+ }+ let root = tempfile::tempdir().unwrap();+ let project = root.path().join("crashed.cap");+ copy_tree(&display, &project.join("content/display"));+ encoder.finish().unwrap();++ let manifest: Value = serde_json::from_slice(+ &std::fs::read(project.join("content/display/manifest.json")).unwrap(),+ )+ .unwrap();+ assert_eq!(manifest["is_complete"], Value::Bool(false));+ assert!(+ cap_recording::upload_resume::collect_segment_events(&project, false).is_err(),+ "a crashed recording must not be resumable before Recover"+ );+ let video = VideoUploadInfo {+ id: "crashedvideo01".into(),+ link: "https://cap.test/s/crashedvideo01".into(),+ config: S3UploadMeta {+ id: "crashedvideo01".into(),+ },+ };+ RecordingMeta {+ platform: None,+ project_path: project.clone(),+ pretty_name: "Crashed".into(),+ sharing: None,+ inner: RecordingMetaInner::Instant(InstantRecordingMeta::InProgress {+ recording: true,+ }),+ upload: Some(UploadMeta::SegmentUpload {+ video_id: video.id.clone(),+ pre_created_video: video,+ recording_dir: project.clone(),+ }),+ }+ .save_for_project()+ .unwrap();++ recover_instant_recording(&project).unwrap();+ assert!(project.join("content/output.mp4").is_file());+ let events = cap_recording::upload_resume::collect_segment_events(&project, false).unwrap();+ let segments = events+ .iter()+ .filter(|event| !event.is_init && event.media_type == SegmentMediaType::Video)+ .count();+ assert!(segments >= 2, "kept {segments} segments");+ }+#[cfg(target_os = "linux")]#[test]fn instant_screen_requested_camera_cannot_bypass_processing_preparation() {diff --git a/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs b/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rsindex 6b0739523..ee4b1034d 100644--- a/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs+++ b/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs@@ -175,6 +175,119 @@ fn saved_instant_upload_resumes_after_quit_mid_transfer() {});}+/// Leaves a saved project the way a crash mid-recording does: both manifests+/// unfinished with a partial next segment on disk, the metadata still in+/// progress, and the upload state still `Recording`.+fn crash_mid_recording(project: &Path) -> Vec<(PathBuf, Vec<u8>)> {+ let mut partials = Vec::new();+ for track in ["display", "audio"] {+ let directory = project.join("content").join(track);+ let path = directory.join("manifest.json");+ let mut manifest: serde_json::Value =+ serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();+ let next = manifest["segments"].as_array().unwrap().len() + 1;+ manifest["is_complete"] = serde_json::json!(false);+ manifest["segments"]+ .as_array_mut()+ .unwrap()+ .push(serde_json::json!({+ "path": format!("segment_{next:03}.m4s"),+ "index": next,+ "duration": 0.0,+ "is_complete": false,+ "file_size": null,+ }));+ std::fs::write(&path, serde_json::to_vec(&manifest).unwrap()).unwrap();+ let partial = directory.join(format!("segment_{next:03}.m4s.tmp"));+ let bytes = format!("partial {track}").into_bytes();+ std::fs::write(&partial, &bytes).unwrap();+ partials.push((partial, bytes));+ }+ let mut meta = RecordingMeta::load_for_project(project).unwrap();+ meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { recording: true });+ meta.sharing = None;+ meta.save_for_project().unwrap();+ let mut state = read_state(project).unwrap().unwrap();+ state.phase = UploadPhase::Recording;+ write_state(project, &state).unwrap();+ partials+}++/// What Recover leaves for the queue, without the local remux this mock+/// project cannot decode: sealed tracks and saved metadata.+fn recover(project: &Path) {+ crate::recording::seal_recovered_instant_tracks(project);+ let mut meta = RecordingMeta::load_for_project(project).unwrap();+ meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::Complete {+ fps: 30,+ sample_rate: Some(48_000),+ });+ meta.save_for_project().unwrap();+}++/// 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.+#[test]+fn recovered_instant_recording_uploads_what_the_crash_saved() {+ let case = "queue_recovered_instant_upload";+ let _shared_client = crate::auth::SHARED_API_CLIENT_TEST_LOCK.blocking_lock();+ let scratch = Scratch::new(case);+ virtual_time(async {+ let mock = MockCap::start(Vec::new()).await;+ scratch.sign_in(&mock.url);+ let (project, video, audio) = saved_instant_project(&scratch.0, &mock.url);+ let partials = crash_mid_recording(&project);+ recover(&project);++ let manager = Arc::new(Manager::new(LiveBackend, CONFIRMATION_TIMEOUT));+ launch(&manager, &project).await;+ settle(&manager).await;+ assert_verified(&mock, &project, &video, &audio);+ assert_eq!(mock.confirmations().len(), 1);+ assert_eq!(mock.deletes(), 0);+ for (partial, bytes) in partials {+ let aside = partial.with_file_name(format!(+ "{}.unsealed",+ partial.file_name().unwrap().to_string_lossy()+ ));+ assert_eq!(std::fs::read(aside).unwrap(), bytes);+ }+ });+}++/// Without sealing, the same recovered recording can never upload: the+/// resume refuses its unfinished manifests and the cloud copy stays empty.+#[test]+fn unsealed_recovered_instant_recording_never_uploads() {+ let case = "queue_unsealed_recovered_instant_upload";+ let _shared_client = crate::auth::SHARED_API_CLIENT_TEST_LOCK.blocking_lock();+ let scratch = Scratch::new(case);+ virtual_time(async {+ let mock = MockCap::start(Vec::new()).await;+ scratch.sign_in(&mock.url);+ let (project, _, _) = saved_instant_project(&scratch.0, &mock.url);+ crash_mid_recording(&project);+ let mut meta = RecordingMeta::load_for_project(&project).unwrap();+ meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::Complete {+ fps: 30,+ sample_rate: Some(48_000),+ });+ meta.save_for_project().unwrap();++ let manager = Arc::new(Manager::new(LiveBackend, CONFIRMATION_TIMEOUT));+ let ownership = UploadLock::acquire(&project).unwrap();+ let state = read_state(&project).unwrap().unwrap();+ let error = manager+ .resume(project.clone(), state, ownership)+ .await+ .unwrap_err();+ assert!(error.contains("not complete"), "{error}");+ assert!(mock.confirmations().is_empty());+ assert_eq!(mock.stats().media_bytes, 0);+ });+}+/// The app quits while the queue waits for cloud verification. The relaunch/// confirms the already uploaded recording without sending it again.#[test]