Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

perf(desktop-gpui): upload the Instant thumbnail alongside the final manifest

Richie McIlroy4055a3b4b198
diff --git a/apps/desktop-gpui/src/upload.rs b/apps/desktop-gpui/src/upload.rs
index 435e86049..fa872165a 100644
--- a/apps/desktop-gpui/src/upload.rs
+++ b/apps/desktop-gpui/src/upload.rs
@@ -497,21 +497,33 @@ impl InstantUpload {
Ok(())
}
- pub async fn finish_screenshot(&self, project_path: &Path) -> Result<(), String> {
+ fn screenshot_upload(
+ &self,
+ project_path: &Path,
+ ) -> impl Future<Output = Result<(), String>> + Send + use<> {
+ let video_id = self.video.id.clone();
+ let path = project_path.join("screenshots/display.jpg");
#[cfg(target_os = "linux")]
- let result = upload_screenshot_with_cancel(
- &self.video.id,
- &project_path.join("screenshots/display.jpg"),
- &self.cancel,
- )
- .await;
- #[cfg(not(target_os = "linux"))]
- let result = upload_screenshot(
- &self.video.id,
- &project_path.join("screenshots/display.jpg"),
- )
- .await;
- result.map_err(|error| format!("Instant recording thumbnail upload failed: {error}"))
+ let cancel = self.cancel.clone();
+ async move {
+ #[cfg(target_os = "linux")]
+ let result = upload_screenshot_with_cancel(&video_id, &path, &cancel).await;
+ #[cfg(not(target_os = "linux"))]
+ let result = upload_screenshot(&video_id, &path).await;
+ result.map_err(|error| format!("Instant recording thumbnail upload failed: {error}"))
+ }
+ }
+
+ async fn finish_with_screenshot(
+ &mut self,
+ project_path: &Path,
+ manifest: SegmentUploadManifest,
+ ) -> Result<(), String> {
+ let screenshot = self.screenshot_upload(project_path);
+ self.authorize_manifest(manifest)?;
+ let (screenshot, segments) = tokio::join!(screenshot, self.finish_segments());
+ screenshot?;
+ segments
}
pub async fn cancel(&mut self, query: Option<&str>) -> Result<(), String> {
@@ -2315,26 +2327,35 @@ async fn put_presigned_part(
}
}
+const SCREENSHOT_SUBPATH: &str = "screenshot/screen-capture.jpg";
+
async fn upload_screenshot_with_cancel(
video_id: &str,
path: &Path,
cancel: &AtomicBool,
) -> Result<(), AuthApiError> {
check_export_cancelled(cancel)?;
- let bytes = compress_image(path)?;
- presigned_put_bytes_inner(
- video_id,
- "screenshot/screen-capture.jpg",
- bytes,
- Some(cancel),
- )
- .await
+ let (bytes, target) = tokio::try_join!(
+ compress_screenshot(path),
+ presign_put_target(video_id, SCREENSHOT_SUBPATH, Some(cancel)),
+ )?;
+ upload_signed_bytes_inner(target, SCREENSHOT_SUBPATH, bytes, Some(cancel)).await
}
#[cfg(not(target_os = "linux"))]
async fn upload_screenshot(video_id: &str, path: &Path) -> Result<(), AuthApiError> {
- let bytes = compress_image(path)?;
- presigned_put_bytes(video_id, "screenshot/screen-capture.jpg", bytes).await
+ let (bytes, target) = tokio::try_join!(
+ compress_screenshot(path),
+ presign_put_target(video_id, SCREENSHOT_SUBPATH, None),
+ )?;
+ upload_signed_bytes_inner(target, SCREENSHOT_SUBPATH, bytes, None).await
+}
+
+async fn compress_screenshot(path: &Path) -> Result<Vec<u8>, AuthApiError> {
+ let path = path.to_path_buf();
+ tracked_upload_read(move || compress_image(&path))
+ .await
+ .map_err(|error| AuthApiError::Other(format!("Failed to compress image: {error}")))?
}
/// One presigned single-part PUT under a video's subpath -- `/api/upload/
@@ -3510,7 +3531,7 @@ mod tests {
control.deny();
assert!(
upload
- .finish_screenshot(Path::new("/not-a-recording/cancelled.cap"))
+ .screenshot_upload(Path::new("/not-a-recording/cancelled.cap"))
.await
.unwrap_err()
.contains("Export cancelled")
diff --git a/apps/desktop-gpui/src/upload/queue.rs b/apps/desktop-gpui/src/upload/queue.rs
index d59122d41..a5b023821 100644
--- a/apps/desktop-gpui/src/upload/queue.rs
+++ b/apps/desktop-gpui/src/upload/queue.rs
@@ -435,11 +435,7 @@ impl UploadBackend for LiveBackend {
let recorded_length = recorded_length_json(&manifest).map(|bytes| {
publish_recorded_length(upload.video.id.clone(), bytes, upload.cancel.clone())
});
- let finish = async {
- upload.finish_screenshot(project).await?;
- upload.authorize_manifest(manifest)?;
- upload.finish_segments().await
- };
+ let finish = upload.finish_with_screenshot(project, manifest);
match recorded_length {
Some(recorded_length) => alongside(finish, recorded_length).await?,
None => finish.await?,
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 2030bf8d9..0f57162a5 100644
--- a/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs
+++ b/apps/desktop-gpui/src/upload/queue/verify_resume_tests.rs
@@ -337,3 +337,81 @@ fn saved_instant_upload_quit_during_verification_confirms_without_reupload() {
);
});
}
+
+fn last_success(mock: &MockCap, method: &str, fragment: &str) -> Duration {
+ mock.responses(method, fragment)
+ .into_iter()
+ .filter(|(status, _)| *status == 200)
+ .map(|(_, at)| at)
+ .max()
+ .unwrap_or_else(|| panic!("no successful {method} {fragment}:\n{}", mock.timeline()))
+}
+
+/// A slow thumbnail no longer holds back the final manifest that makes the
+/// recording playable in full; the completion signal still waits for both.
+#[test]
+fn saved_instant_upload_publishes_its_manifest_while_the_thumbnail_uploads() {
+ let _shared_client = crate::auth::SHARED_API_CLIENT_TEST_LOCK.blocking_lock();
+ let scratch = Scratch::new("queue_thumbnail_alongside_manifest");
+ virtual_time(async {
+ let mock = MockCap::start(vec![rule(
+ Route::Object("screenshot/"),
+ Fault::Delay(Duration::from_secs(20)),
+ )])
+ .await;
+ scratch.sign_in(&mock.url);
+ let (project, video, audio) = saved_instant_project(&scratch.0, &mock.url);
+ 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);
+ let manifest = last_success(&mock, "PUT", "segments/manifest.json");
+ let thumbnail = last_success(&mock, "PUT", "screenshot/screen-capture.jpg");
+ let confirmed = last_success(&mock, "POST", "/api/upload/recording-complete");
+ assert!(
+ manifest + Duration::from_secs(10) < thumbnail,
+ "final manifest waited for the thumbnail:\n{}",
+ mock.timeline()
+ );
+ assert!(confirmed >= thumbnail, "{}", mock.timeline());
+ });
+}
+
+/// A thumbnail that fails still fails the attempt and sends no completion
+/// signal, as before; the next attempt uploads it and verifies the same video.
+#[test]
+fn failed_thumbnail_fails_the_attempt_and_the_retry_verifies() {
+ let _shared_client = crate::auth::SHARED_API_CLIENT_TEST_LOCK.blocking_lock();
+ let scratch = Scratch::new("queue_thumbnail_failure");
+ virtual_time(async {
+ let mock =
+ MockCap::start(vec![rule(Route::Object("screenshot/"), Fault::Status(403))]).await;
+ scratch.sign_in(&mock.url);
+ let (project, video, audio) = saved_instant_project(&scratch.0, &mock.url);
+ let first = Arc::new(Manager::new(LiveBackend, CONFIRMATION_TIMEOUT));
+ launch(&first, &project).await;
+ settle(&first).await;
+ let mut state = read_state(&project).unwrap().unwrap();
+ assert_eq!(state.phase, UploadPhase::Retrying, "{state:?}");
+ assert!(
+ state
+ .last_error
+ .as_deref()
+ .is_some_and(|error| error.contains("thumbnail")),
+ "{state:?}"
+ );
+ assert_eq!(state.video_id, VIDEO_ID);
+ assert!(mock.confirmations().is_empty());
+
+ state.next_retry_at = Some(0);
+ write_state(&project, &state).unwrap();
+ mock.new_session();
+ crate::auth::reset_shared_api_client();
+ let retried = Arc::new(Manager::new(LiveBackend, CONFIRMATION_TIMEOUT));
+ launch(&retried, &project).await;
+ settle(&retried).await;
+ assert_verified(&mock, &project, &video, &audio);
+ assert_eq!(mock.confirmations().len(), 1);
+ });
+}
diff --git a/apps/desktop-gpui/src/upload/verify_tests.rs b/apps/desktop-gpui/src/upload/verify_tests.rs
index 5b0f4602d..751cce8f4 100644
--- a/apps/desktop-gpui/src/upload/verify_tests.rs
+++ b/apps/desktop-gpui/src/upload/verify_tests.rs
@@ -459,6 +459,15 @@ impl MockCap {
.count()
}
+ pub(super) fn responses(&self, method: &str, fragment: &str) -> Vec<(u16, Duration)> {
+ self.lock()
+ .requests
+ .iter()
+ .filter(|(m, path, ..)| m == method && path.contains(fragment))
+ .map(|(_, _, status, at)| (*status, *at))
+ .collect()
+ }
+
pub(super) fn timeline(&self) -> String {
self.lock()
.requests