Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

test(desktop-gpui): add a manual Instant stop tail benchmark

Richie McIlroy422b8a0f1674
diff --git a/apps/desktop-gpui/src/upload/queue.rs b/apps/desktop-gpui/src/upload/queue.rs
index a5b023821..3d2b563db 100644
--- a/apps/desktop-gpui/src/upload/queue.rs
+++ b/apps/desktop-gpui/src/upload/queue.rs
@@ -1244,6 +1244,9 @@ pub(crate) async fn delete_recording(project: PathBuf) -> Result<(), String> {
#[cfg(test)]
mod verify_resume_tests;
+#[cfg(test)]
+mod stop_tail_bench;
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/apps/desktop-gpui/src/upload/queue/stop_tail_bench.rs b/apps/desktop-gpui/src/upload/queue/stop_tail_bench.rs
new file mode 100644
index 000000000..cd2cf48ef
--- /dev/null
+++ b/apps/desktop-gpui/src/upload/queue/stop_tail_bench.rs
@@ -0,0 +1,171 @@
+//! How long an Instant recording takes, after Stop, to publish its final
+//! manifest and send its completion signal, with every API call and object
+//! PUT answered after a fixed delay on the virtual clock. Manual:
+//!
+//! ```sh
+//! STOP_TAIL_API_MS=200 STOP_TAIL_OBJECT_MS=80 \
+//! cargo test --bin cap-gpui stop_tail -- --ignored --nocapture
+//! ```
+
+use super::*;
+use crate::upload::verify_tests::{
+ Fault, MockCap, OWNER, Route, SAMPLE_MP4, Scratch, assert_segments_stored, instant_tracks,
+ rule, virtual_time, write_thumbnail,
+};
+
+const VIDEO_ID: &str = "stoptail01";
+
+fn env_number(name: &str, default: u64) -> u64 {
+ std::env::var(name)
+ .ok()
+ .and_then(|value| value.parse().ok())
+ .unwrap_or(default)
+}
+
+fn recording_project(
+ root: &Path,
+ server: &str,
+ pairs: u32,
+) -> (
+ PathBuf,
+ VideoUploadInfo,
+ Vec<SegmentCompletedEvent>,
+ Vec<SegmentCompletedEvent>,
+) {
+ let project = root.join("instant.cap");
+ std::fs::create_dir_all(project.join("content")).unwrap();
+ std::fs::write(project.join("content/output.mp4"), SAMPLE_MP4).unwrap();
+ let (video, audio) = instant_tracks(&project, pairs);
+ write_thumbnail(&project.join("screenshots/display.jpg"));
+ let video_info = VideoUploadInfo {
+ id: VIDEO_ID.into(),
+ link: format!("{server}/s/{VIDEO_ID}"),
+ config: S3UploadMeta {
+ id: VIDEO_ID.into(),
+ },
+ };
+ RecordingMeta {
+ platform: None,
+ project_path: project.clone(),
+ pretty_name: "Stop tail".into(),
+ sharing: Some(SharingMeta {
+ id: VIDEO_ID.into(),
+ link: video_info.link.clone(),
+ content_hash: None,
+ }),
+ inner: RecordingMetaInner::Instant(InstantRecordingMeta::Complete {
+ fps: 30,
+ sample_rate: Some(48_000),
+ }),
+ upload: Some(UploadMeta::SegmentUpload {
+ video_id: VIDEO_ID.into(),
+ pre_created_video: video_info.clone(),
+ recording_dir: project.clone(),
+ }),
+ }
+ .save_for_project()
+ .unwrap();
+ write_state(
+ &project,
+ &UploadState {
+ version: 1,
+ video_id: VIDEO_ID.into(),
+ server_url: server.into(),
+ owner_id: Some(OWNER.into()),
+ kind: UploadKind::Segments,
+ requested_audio: Some(true),
+ preserve_local: false,
+ phase: UploadPhase::Recording,
+ attempt_count: 0,
+ last_error: None,
+ next_retry_at: None,
+ verification: None,
+ receipt: None,
+ },
+ )
+ .unwrap();
+ (project, video_info, video, audio)
+}
+
+fn last_response(mock: &MockCap, method: &str, fragment: &str) -> Duration {
+ mock.responses(method, fragment)
+ .into_iter()
+ .map(|(_, at)| at)
+ .max()
+ .unwrap_or_default()
+}
+
+async fn settle(manager: &Manager<LiveBackend>) {
+ loop {
+ if manager
+ .jobs
+ .lock()
+ .await
+ .values()
+ .all(|job| job.task.is_finished())
+ {
+ manager.reap().await;
+ return;
+ }
+ tokio::time::sleep(Duration::from_millis(5)).await;
+ }
+}
+
+#[test]
+#[ignore = "manual Instant stop tail benchmark"]
+fn stop_tail_benchmark() {
+ let api = Duration::from_millis(env_number("STOP_TAIL_API_MS", 200));
+ let object = Duration::from_millis(env_number("STOP_TAIL_OBJECT_MS", 80));
+ let pairs = env_number("STOP_TAIL_PAIRS", 30) as u32;
+ let _shared_client = crate::auth::SHARED_API_CLIENT_TEST_LOCK.blocking_lock();
+ let scratch = Scratch::new("stop_tail");
+ virtual_time(async {
+ let epoch = tokio::time::Instant::now();
+ let mock = MockCap::start(vec![
+ rule(Route::Api("/api/"), Fault::Delay(api)).times(u32::MAX),
+ rule(Route::Object(""), Fault::Delay(object)).times(u32::MAX),
+ ])
+ .await;
+ scratch.sign_in(&mock.url);
+ let (project, video_info, video, audio) = recording_project(&scratch.0, &mock.url, pairs);
+ let (sender, receiver) = std::sync::mpsc::channel();
+ let upload = crate::upload::start_instant_upload(
+ video_info,
+ project.clone(),
+ Some(receiver),
+ Arc::new(Mutex::new(())),
+ Some(crate::upload::CompletionAuthorization::new()),
+ )
+ .unwrap();
+ let start = tokio::time::Instant::now();
+ sender.send(video[0].clone()).unwrap();
+ sender.send(audio[0].clone()).unwrap();
+ for k in 1..video.len() {
+ tokio::time::sleep_until(start + Duration::from_secs(2 * k as u64)).await;
+ sender.send(audio[k].clone()).unwrap();
+ sender.send(video[k].clone()).unwrap();
+ }
+ drop(sender);
+ let stopped = epoch.elapsed();
+ let manager = Arc::new(Manager::new(LiveBackend, CONFIRMATION_TIMEOUT));
+ manager.admit(project.clone(), upload, false).await.unwrap();
+ settle(&manager).await;
+ let state = read_state(&project).unwrap().unwrap();
+ assert_eq!(state.phase, UploadPhase::Verified, "{state:?}");
+ assert_segments_stored(&mock, VIDEO_ID, &video, &audio);
+ mock.assert_clean();
+ let since_stop = |at: Duration| at.saturating_sub(stopped).as_secs_f64();
+ eprintln!(
+ "stop-tail api={api:?} object={object:?} pairs={pairs}: thumbnail {:.3}s, final manifest {:.3}s, completion {:.3}s; {} requests, {} presigns",
+ since_stop(last_response(&mock, "PUT", "screenshot/")),
+ since_stop(last_response(&mock, "PUT", "segments/manifest.json")),
+ since_stop(last_response(
+ &mock,
+ "POST",
+ "/api/upload/recording-complete"
+ )),
+ mock.stats().requests,
+ mock.count("POST", "/api/upload/signed"),
+ );
+ });
+}