Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(desktop-gpui): delete the server video of an Instant recording that crashed before capturing anything

Richie McIlroy89d5180cd4de
diff --git a/apps/desktop-gpui/src/upload/instant_cleanup.rs b/apps/desktop-gpui/src/upload/instant_cleanup.rs
index 738f09c48..22952d37d 100644
--- a/apps/desktop-gpui/src/upload/instant_cleanup.rs
+++ b/apps/desktop-gpui/src/upload/instant_cleanup.rs
@@ -11,9 +11,12 @@ const RETRY_MAX_SECS: i64 = 6 * 60 * 60;
const INTERRUPTED_GRACE_SECS: i64 = 30 * 60;
const SWEEP_INTERVAL: Duration = Duration::from_secs(5 * 60);
const MEDIA_SCAN_DEPTH: usize = 3;
+const CRASHED_ADOPTION_AGE_SECS: i64 = 10 * 60;
+const CRASHED_ERROR: &str = "Cap closed before this recording captured anything.";
static JOURNAL_LOCK: Mutex<()> = Mutex::new(());
static SESSION: OnceLock<String> = OnceLock::new();
+static LAUNCHED_AT: OnceLock<i64> = OnceLock::new();
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "kebab-case")]
@@ -145,6 +148,10 @@ fn session_id() -> &'static str {
SESSION.get_or_init(crate::store::new_uuid_v4)
}
+fn launched_at() -> i64 {
+ *LAUNCHED_AT.get_or_init(now)
+}
+
fn journal_path() -> PathBuf {
crate::store::app_data_dir().join(JOURNAL_FILE)
}
@@ -522,10 +529,133 @@ fn locally_protected(
false
}
+/// An Instant recording that crashed after capture began but before it saved
+/// any media leaves a server video nothing can fill: the journal stops
+/// tracking a recording once it starts, and there is nothing to recover. This
+/// journals such a recording as interrupted so the sweep deletes that video,
+/// but only when it is not live anywhere (its upload lock is free), its upload
+/// state was saved before this launch and over ten minutes ago, it is still in
+/// progress, and its folder holds no media. The sweep's own checks then still
+/// apply before anything is deleted.
+fn adopt_crashed_at(path: &Path, recording_dirs: &[PathBuf], launched_at: i64, now: i64) -> usize {
+ let mut found = Vec::new();
+ for directory in recording_dirs {
+ let Ok(entries) = std::fs::read_dir(directory) else {
+ continue;
+ };
+ for entry in entries.flatten() {
+ if let Some(crashed) = crashed_without_media(&entry.path(), launched_at, now) {
+ found.push(crashed);
+ }
+ }
+ }
+ if found.is_empty() {
+ return 0;
+ }
+ let mut adopted = 0;
+ if let Err(error) = update_journal(path, |entries| {
+ for crashed in found {
+ if entries
+ .iter()
+ .all(|entry| entry.video_id != crashed.video_id)
+ {
+ entries.push(crashed);
+ adopted += 1;
+ }
+ }
+ }) {
+ tracing::warn!(%error, "Instant cleanup could not record crashed recordings");
+ return 0;
+ }
+ adopted
+}
+
+fn crashed_without_media(project: &Path, launched_at: i64, now: i64) -> Option<Entry> {
+ let state = queue::read_state(project).ok().flatten()?;
+ if !matches!(
+ state.phase,
+ queue::UploadPhase::Recording
+ | queue::UploadPhase::Retrying
+ | queue::UploadPhase::Failed
+ | queue::UploadPhase::NeedsAuthentication
+ ) {
+ return None;
+ }
+ let owner_id = state.owner_id()?.to_string();
+ let saved = std::fs::symlink_metadata(project.join(queue::STATE_FILE))
+ .and_then(|metadata| metadata.modified())
+ .ok()?
+ .duration_since(std::time::UNIX_EPOCH)
+ .ok()?
+ .as_secs() as i64;
+ if saved >= launched_at || now.saturating_sub(saved) < CRASHED_ADOPTION_AGE_SECS {
+ return None;
+ }
+ let meta = RecordingMeta::load_for_project(project).ok()?;
+ if !matches!(
+ meta.inner,
+ RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { .. })
+ ) || !meta_claims(&meta, state.video_id())
+ {
+ return None;
+ }
+ let _ownership = cap_recording::upload_resume::UploadLock::acquire(project).ok()?;
+ if has_recorded_media(&project.join("content"), MEDIA_SCAN_DEPTH) {
+ return None;
+ }
+ Some(Entry {
+ video_id: state.video_id().to_string(),
+ server_url: state.server_url().to_string(),
+ owner_id,
+ session: session_id().to_string(),
+ stage: Stage::Abandoned,
+ reason: Some(CleanupReason::Interrupted),
+ cause: None,
+ created_at: now,
+ attempts: 0,
+ next_attempt_at: now,
+ project_dir: Some(project.to_path_buf()),
+ })
+}
+
+/// After the sweep deletes the server video of an interrupted recording,
+/// marks the local copy failed so the library stops showing it in progress.
+/// Only a recording that still claims the video, is still in progress and
+/// still holds no media is changed, and nothing is deleted.
+fn mark_crashed_recording_failed(project: &Path, video_id: &str) {
+ let Ok(_ownership) = cap_recording::upload_resume::UploadLock::acquire(project) else {
+ return;
+ };
+ let Ok(mut meta) = RecordingMeta::load_for_project(project) else {
+ return;
+ };
+ if !matches!(
+ meta.inner,
+ RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { .. })
+ ) || !meta_claims(&meta, video_id)
+ || has_recorded_media(&project.join("content"), MEDIA_SCAN_DEPTH)
+ {
+ return;
+ }
+ meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::Failed {
+ error: CRASHED_ERROR.to_string(),
+ });
+ if let Err(error) = meta.save_for_project() {
+ tracing::warn!(%error, video_id, "Instant cleanup could not mark a crashed recording failed");
+ return;
+ }
+ if let Err(error) = queue::record_cancelled(project) {
+ tracing::warn!(%error, video_id, "Instant cleanup could not close a crashed upload");
+ }
+}
+
trait SweepBackend {
fn account_ready(&self, entry: &Entry) -> bool;
fn protected(&self, entry: &Entry) -> impl Future<Output = bool> + Send;
fn delete(&self, entry: &Entry) -> impl Future<Output = Result<(), String>> + Send;
+ fn deleted(&self, _entry: &Entry) -> impl Future<Output = ()> + Send {
+ async {}
+ }
}
#[derive(Debug, Default, PartialEq)]
@@ -571,6 +701,7 @@ async fn sweep(path: &Path, session: &str, now: i64, backend: &impl SweepBackend
}
match backend.delete(&entry).await {
Ok(()) => {
+ backend.deleted(&entry).await;
summary.deleted += 1;
remove.push(entry.video_id);
}
@@ -633,10 +764,39 @@ impl SweepBackend for LiveSweep {
))
.await
}
+
+ async fn deleted(&self, entry: &Entry) {
+ if entry.effective_reason() != CleanupReason::Interrupted {
+ return;
+ }
+ let Some(project) = entry.project_dir.clone() else {
+ return;
+ };
+ let video_id = entry.video_id.clone();
+ let _ =
+ tokio::task::spawn_blocking(move || mark_crashed_recording_failed(&project, &video_id))
+ .await;
+ }
}
async fn run() {
loop {
+ let adopted = tokio::task::spawn_blocking(|| {
+ adopt_crashed_at(
+ &journal_path(),
+ &crate::library::known_recordings_dirs(),
+ launched_at(),
+ now(),
+ )
+ })
+ .await
+ .unwrap_or(0);
+ if adopted > 0 {
+ tracing::info!(
+ adopted,
+ "Instant cleanup found recordings that crashed before capturing"
+ );
+ }
let summary = sweep(&journal_path(), session_id(), now(), &LiveSweep).await;
if summary != SweepSummary::default() {
tracing::info!(?summary, "Instant cleanup sweep finished");
@@ -650,6 +810,7 @@ pub(crate) fn init(cx: &mut gpui::App) {
return;
}
session_id();
+ launched_at();
gpui_tokio::Tokio::spawn(cx, run()).detach();
}
@@ -1211,6 +1372,208 @@ mod tests {
assert!(!normal);
}
+ /// A project left the way a crash during capture leaves it: metadata in
+ /// progress, an upload state saved `saved_secs_ago`, and no media.
+ fn crashed_project(
+ recordings: &Path,
+ name: &str,
+ phase: queue::UploadPhase,
+ saved_secs_ago: u64,
+ ) -> PathBuf {
+ let project = write_project(recordings, name, "video", in_progress());
+ queue::record_capture(
+ &project,
+ &VideoUploadInfo {
+ id: "video".into(),
+ link: "https://cap.test/s/video".into(),
+ config: S3UploadMeta { id: "video".into() },
+ },
+ true,
+ true,
+ )
+ .unwrap();
+ let path = project.join(queue::STATE_FILE);
+ let mut state: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
+ state["owner_id"] = serde_json::json!("owner");
+ state["server_url"] = serde_json::json!("https://cap.test");
+ state["phase"] = serde_json::to_value(phase).unwrap();
+ std::fs::write(&path, serde_json::to_vec(&state).unwrap()).unwrap();
+ std::fs::File::options()
+ .write(true)
+ .open(&path)
+ .unwrap()
+ .set_modified(std::time::SystemTime::now() - Duration::from_secs(saved_secs_ago))
+ .unwrap();
+ project
+ }
+
+ #[test]
+ fn a_recording_that_crashed_before_capturing_is_adopted_with_its_own_identity() {
+ let fixture = Fixture::new();
+ let recordings = fixture.recordings();
+ let project = crashed_project(
+ &recordings,
+ "crashed.cap",
+ queue::UploadPhase::Recording,
+ 3600,
+ );
+ let now = now();
+ let dirs = std::slice::from_ref(&recordings);
+ assert_eq!(adopt_crashed_at(&fixture.journal(), dirs, now, now), 1);
+ let entries = fixture.entries();
+ assert_eq!(entries.len(), 1);
+ let entry = &entries[0];
+ assert_eq!(entry.video_id, "video");
+ assert_eq!(entry.server_url, "https://cap.test");
+ assert_eq!(entry.owner_id, "owner");
+ assert_eq!(entry.stage, Stage::Abandoned);
+ assert_eq!(entry.reason, Some(CleanupReason::Interrupted));
+ assert_eq!(entry.project_dir.as_deref(), Some(project.as_path()));
+ assert!(entry.due("another-session", now));
+ assert!(!locally_protected(dirs, "video", true, Some(&project)));
+ assert_eq!(adopt_crashed_at(&fixture.journal(), dirs, now, now), 0);
+ assert_eq!(fixture.entries().len(), 1);
+ }
+
+ #[test]
+ fn a_crashed_recording_is_left_alone_unless_it_is_certainly_abandoned() {
+ use queue::UploadPhase;
+ let now = now();
+ type Prepare = fn(&Path) -> Option<cap_recording::upload_resume::UploadLock>;
+ let cases: Vec<(&str, UploadPhase, u64, i64, Prepare)> = vec![
+ ("saved recently", UploadPhase::Recording, 300, now, |_| None),
+ (
+ "saved after this launch",
+ UploadPhase::Recording,
+ 3600,
+ now - 7200,
+ |_| None,
+ ),
+ (
+ "live elsewhere",
+ UploadPhase::Recording,
+ 3600,
+ now,
+ |project| Some(cap_recording::upload_resume::UploadLock::acquire(project).unwrap()),
+ ),
+ ("has media", UploadPhase::Recording, 3600, now, |project| {
+ std::fs::write(project.join("content/display/segment_001.m4s"), b"media").unwrap();
+ None
+ }),
+ ("finished", UploadPhase::Recording, 3600, now, |project| {
+ let mut meta = RecordingMeta::load_for_project(project).unwrap();
+ meta.inner = RecordingMetaInner::Instant(InstantRecordingMeta::Complete {
+ fps: 30,
+ sample_rate: None,
+ });
+ meta.save_for_project().unwrap();
+ None
+ }),
+ (
+ "another video",
+ UploadPhase::Recording,
+ 3600,
+ now,
+ |project| {
+ write_project(
+ project.parent().unwrap(),
+ "case.cap",
+ "other",
+ in_progress(),
+ );
+ None
+ },
+ ),
+ ("no owner", UploadPhase::Recording, 3600, now, |project| {
+ let path = project.join(queue::STATE_FILE);
+ let mut state: Value =
+ serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap();
+ state["owner_id"] = Value::Null;
+ std::fs::write(&path, serde_json::to_vec(&state).unwrap()).unwrap();
+ std::fs::File::options()
+ .write(true)
+ .open(&path)
+ .unwrap()
+ .set_modified(std::time::SystemTime::now() - Duration::from_secs(3600))
+ .unwrap();
+ None
+ }),
+ ("uploading", UploadPhase::Pending, 3600, now, |_| None),
+ ("verified", UploadPhase::Verified, 3600, now, |_| None),
+ ("cancelled", UploadPhase::Cancelled, 3600, now, |_| None),
+ ];
+ for (case, phase, saved_secs_ago, launched, prepare) in cases {
+ let fixture = Fixture::new();
+ let recordings = fixture.recordings();
+ let project = crashed_project(&recordings, "case.cap", phase, saved_secs_ago);
+ let _held = prepare(&project);
+ assert_eq!(
+ adopt_crashed_at(
+ &fixture.journal(),
+ std::slice::from_ref(&recordings),
+ launched,
+ now
+ ),
+ 0,
+ "{case}"
+ );
+ assert!(fixture.entries().is_empty(), "{case}");
+ }
+ }
+
+ #[test]
+ fn a_crashed_recording_is_marked_failed_once_its_video_is_deleted() {
+ let fixture = Fixture::new();
+ let recordings = fixture.recordings();
+ let project = crashed_project(
+ &recordings,
+ "crashed.cap",
+ queue::UploadPhase::Recording,
+ 3600,
+ );
+ mark_crashed_recording_failed(&project, "video");
+ let meta = RecordingMeta::load_for_project(&project).unwrap();
+ assert!(matches!(
+ meta.inner,
+ RecordingMetaInner::Instant(InstantRecordingMeta::Failed { ref error }) if error == CRASHED_ERROR
+ ));
+ assert_eq!(
+ queue::read_state(&project).unwrap().unwrap().phase,
+ queue::UploadPhase::Cancelled
+ );
+
+ for (case, prepare) in [
+ (
+ "has media",
+ (|project: &Path| {
+ std::fs::write(project.join("content/display/segment_001.m4s"), b"media")
+ .unwrap()
+ }) as fn(&Path),
+ ),
+ ("another video", |project: &Path| {
+ let name = project.file_name().unwrap().to_str().unwrap();
+ write_project(project.parent().unwrap(), name, "other", in_progress());
+ }),
+ ] {
+ let name = format!("{}.cap", case.replace(' ', "-"));
+ let project = crashed_project(&recordings, &name, queue::UploadPhase::Recording, 3600);
+ prepare(&project);
+ mark_crashed_recording_failed(&project, "video");
+ assert!(
+ matches!(
+ RecordingMeta::load_for_project(&project).unwrap().inner,
+ RecordingMetaInner::Instant(InstantRecordingMeta::InProgress { .. })
+ ),
+ "{case}"
+ );
+ assert_eq!(
+ queue::read_state(&project).unwrap().unwrap().phase,
+ queue::UploadPhase::Recording,
+ "{case}"
+ );
+ }
+ }
+
#[test]
fn an_unreadable_project_that_claims_the_video_protects_it() {
let fixture = Fixture::new();
diff --git a/apps/desktop-gpui/src/upload/queue.rs b/apps/desktop-gpui/src/upload/queue.rs
index 9d8495c1e..9cf7bf0f3 100644
--- a/apps/desktop-gpui/src/upload/queue.rs
+++ b/apps/desktop-gpui/src/upload/queue.rs
@@ -9,7 +9,7 @@ use std::time::SystemTime;
static STATE_CHANGED: tokio::sync::Notify = tokio::sync::Notify::const_new();
-const STATE_FILE: &str = "instant-upload.json";
+pub(super) const STATE_FILE: &str = "instant-upload.json";
const MAX_STATE_BYTES: u64 = 64 * 1024;
const CONFIRMATION_TIMEOUT: Duration = Duration::from_secs(45);
const RECONCILE_INTERVAL: Duration = Duration::from_secs(30);
@@ -59,6 +59,14 @@ impl UploadState {
&self.video_id
}
+ pub(crate) fn server_url(&self) -> &str {
+ &self.server_url
+ }
+
+ pub(crate) fn owner_id(&self) -> Option<&str> {
+ self.owner_id.as_deref()
+ }
+
pub(super) fn request_context(&self) -> Result<auth::UploadRequestContext, String> {
auth::UploadRequestContext::for_upload(&self.server_url, self.owner_id.as_deref())
.map_err(|error| error.to_string())