Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

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.rs
index 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::Resu
Ok(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.rs
index 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]