Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use super::*;
use crate::{auth::AuthStore, web_api::UploadRequestContext};
use futures::FutureExt;
use std::{io::Write, sync::atomic::AtomicBool};
const FILE_NAME: &str = "tauri-upload.json";
#[derive(Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct Intent {
version: u32,
video_id: String,
server_url: String,
owner_id: Option<String>,
required_audio: Option<bool>,
local_ready: bool,
cancelled: bool,
preserve_local: bool,
failures: u32,
#[serde(default)]
needs_authentication: bool,
retry_at: Option<i64>,
error: Option<String>,
verification: Option<UploadVerification>,
receipt: Option<VerifiedUploadReceipt>,
}
fn read(directory: &Path) -> Result<Option<Intent>, AuthedApiError> {
let path = directory.join(FILE_NAME);
let metadata = match path.symlink_metadata() {
Ok(metadata) => metadata,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None),
Err(error) => return Err(error.to_string().into()),
};
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
if metadata.file_attributes() & 0x400 != 0 {
return Err("Upload intent is a reparse point".into());
}
}
if metadata.file_type().is_symlink() || !metadata.is_file() || metadata.len() > 65536 {
return Err("Invalid recording upload intent".into());
}
let intent: Intent =
serde_json::from_slice(&std::fs::read(path).map_err(|error| error.to_string())?)?;
if intent.version != 1 || intent.video_id.is_empty() || intent.server_url.is_empty() {
return Err("Unsupported recording upload intent".into());
}
Ok(Some(intent))
}
fn write(directory: &Path, intent: &Intent) -> Result<(), AuthedApiError> {
read(directory)?;
let bytes = serde_json::to_vec_pretty(intent)?;
let temporary = directory.join(format!(".tauri-upload-{}.tmp", uuid::Uuid::new_v4()));
let result = (|| {
let mut file = std::fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&temporary)?;
file.write_all(&bytes)?;
file.sync_all()?;
drop(file);
std::fs::rename(&temporary, directory.join(FILE_NAME))?;
#[cfg(unix)]
std::fs::File::open(directory)?.sync_all()?;
Ok::<_, io::Error>(())
})();
if result.is_err() {
let _ = std::fs::remove_file(temporary);
}
result.map_err(|error| format!("Could not save upload intent: {error}").into())
}
pub(crate) async fn prepare(
app: &AppHandle,
directory: &Path,
video_id: &str,
required_audio: bool,
) -> Result<Arc<Session>, AuthedApiError> {
let server_url = app.make_app_url("").await.trim_end_matches('/').to_string();
let owner_id = AuthStore::get(app)
.map_err(AuthedApiError::AuthStore)?
.and_then(|auth| auth.user_id);
let context = UploadRequestContext::new(
server_url.clone(),
owner_id
.clone()
.ok_or(AuthedApiError::InvalidAuthentication)?,
)?;
context.check(app).await?;
let lock = acquire_upload_lock(directory)?;
if read(directory)?.is_some() {
return Err("Recording already has an upload identity".into());
}
write(
directory,
&Intent {
version: 1,
video_id: video_id.into(),
server_url,
owner_id,
required_audio: Some(required_audio),
local_ready: false,
cancelled: false,
preserve_local: false,
failures: 0,
needs_authentication: false,
retry_at: None,
error: None,
verification: None,
receipt: None,
},
)?;
let session = Session::new(lock.project_path().to_path_buf(), video_id.to_string());
session.adopt(lock)?;
Ok(session)
}
#[derive(Default)]
struct ReadTracker {
active: AtomicUsize,
changed: tokio::sync::Notify,
}
pub(crate) struct ReadGuard(Arc<ReadTracker>);
impl Drop for ReadGuard {
fn drop(&mut self) {
self.0.active.fetch_sub(1, Ordering::AcqRel);
self.0.changed.notify_one();
}
}
#[derive(Clone)]
pub(crate) struct UploadScope {
cancelled: tokio::sync::watch::Receiver<bool>,
reads: Arc<ReadTracker>,
}
tokio::task_local! {
static UPLOAD_SCOPE: UploadScope;
}
impl UploadScope {
pub(crate) fn current() -> Option<Self> {
UPLOAD_SCOPE.try_with(Clone::clone).ok()
}
pub(crate) async fn bind<F: std::future::Future>(self, future: F) -> F::Output {
UPLOAD_SCOPE.scope(self, future).await
}
pub(crate) fn read_guard(&self) -> ReadGuard {
self.reads.active.fetch_add(1, Ordering::AcqRel);
ReadGuard(self.reads.clone())
}
async fn cancelled(&self) {
let mut cancelled = self.cancelled.clone();
while !*cancelled.borrow_and_update() {
if cancelled.changed().await.is_err() {
break;
}
}
}
fn check(&self) -> Result<(), AuthedApiError> {
if *self.cancelled.borrow() {
Err("Recording upload cancelled; local files retained".into())
} else {
Ok(())
}
}
}
pub(crate) async fn cancellable<F: std::future::Future>(
future: F,
) -> Result<F::Output, AuthedApiError> {
if let Some(scope) = UploadScope::current() {
scope.check()?;
let result = tokio::select! {
result = future => result,
_ = scope.cancelled() => return Err("Recording upload cancelled; local files retained".into()),
};
scope.check()?;
Ok(result)
} else {
Ok(future.await)
}
}
pub(crate) async fn file_io<T: Send + 'static>(
operation: impl FnOnce() -> io::Result<T> + Send + 'static,
) -> io::Result<T> {
let scope = UploadScope::current();
if let Some(scope) = &scope {
scope.check().map_err(io::Error::other)?;
}
let guard = scope.map(|scope| scope.read_guard());
let task = tokio::task::spawn_blocking(move || {
let _guard = guard;
operation()
});
cancellable(task)
.await
.map_err(io::Error::other)?
.map_err(io::Error::other)?
}
pub(crate) struct Session {
pub(crate) directory: PathBuf,
video_id: String,
ownership: Mutex<Option<UploadLock>>,
request_context: Mutex<Option<UploadRequestContext>>,
cancelled: tokio::sync::watch::Sender<bool>,
ready: tokio::sync::Notify,
terminal: tokio::sync::watch::Sender<Option<Result<(), String>>>,
verified: Mutex<Option<(UploadVerification, VerifiedUploadReceipt)>>,
ledger: Mutex<()>,
reads: Arc<ReadTracker>,
#[cfg(target_os = "linux")]
strict_control: Mutex<Option<super::strict_instant::Control>>,
}
impl Session {
pub(crate) fn new(directory: PathBuf, video_id: String) -> Arc<Self> {
Arc::new(Self {
directory,
video_id,
ownership: Mutex::new(None),
request_context: Mutex::new(None),
cancelled: tokio::sync::watch::channel(false).0,
ready: tokio::sync::Notify::new(),
terminal: tokio::sync::watch::channel(None).0,
verified: Mutex::new(None),
ledger: Mutex::new(()),
reads: Arc::new(ReadTracker::default()),
#[cfg(target_os = "linux")]
strict_control: Mutex::new(None),
})
}
pub(crate) async fn run<F: std::future::Future>(&self, future: F) -> F::Output {
let scope = UploadScope {
cancelled: self.cancelled.subscribe(),
reads: self.reads.clone(),
};
let result = std::panic::AssertUnwindSafe(scope.bind(future))
.catch_unwind()
.await;
self.wait_for_reads().await;
match result {
Ok(result) => result,
Err(panic) => std::panic::resume_unwind(panic),
}
}
pub(crate) async fn wait_for_reads(&self) {
while self.reads.active.load(Ordering::Acquire) != 0 {
tokio::select! { _ = self.reads.changed.notified() => {}, _ = tokio::time::sleep(Duration::from_millis(10)) => {} }
}
}
pub(crate) fn adopt(&self, lock: UploadLock) -> Result<(), AuthedApiError> {
if self
.directory
.canonicalize()
.map_err(|error| error.to_string())?
!= lock.project_path()
{
return Err("Upload ownership path changed".into());
}
*self
.ownership
.lock()
.unwrap_or_else(PoisonError::into_inner) = Some(lock);
self.load_context()?;
self.check()
}
fn load_context(&self) -> Result<(), AuthedApiError> {
if let Some(intent) = read(&self.directory)? {
if intent.video_id != self.video_id || intent.cancelled {
return Err("Recording upload identity changed or was cancelled".into());
}
let context = UploadRequestContext::new(
intent.server_url,
intent
.owner_id
.ok_or(AuthedApiError::InvalidAuthentication)?,
)?;
*self
.request_context
.lock()
.unwrap_or_else(PoisonError::into_inner) = Some(context);
}
Ok(())
}
pub(crate) fn cached_verification(&self) -> Result<Option<UploadVerification>, AuthedApiError> {
let verification = read(&self.directory)?.and_then(|intent| intent.verification);
if verification
.as_ref()
.is_some_and(UploadVerification::requires_reupload)
{
self.clear_verification()?;
return Ok(None);
}
if let Some(verification) = &verification
&& let Err(error) = verify_local_artifact(&self.directory, verification)
{
self.clear_verification()?;
return Err(error);
}
Ok(verification)
}
pub(crate) fn acquire(&self) -> Result<(), AuthedApiError> {
let mut ownership = self
.ownership
.lock()
.unwrap_or_else(PoisonError::into_inner);
if ownership.is_some() {
return self.check();
}
let lock = acquire_upload_lock(&self.directory)?;
let meta =
RecordingMeta::load_for_project(&self.directory).map_err(|error| error.to_string())?;
if let Some(id) = upload_video_id(&meta.upload)
&& id != self.video_id
{
return Err("Recording upload identity changed".into());
}
self.load_context()?;
*ownership = Some(lock);
self.check()
}
pub(crate) fn context(&self) -> Option<UploadRequestContext> {
self.request_context
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
pub(crate) fn check(&self) -> Result<(), AuthedApiError> {
if *self.cancelled.borrow() {
Err("Recording upload cancelled; local files retained".into())
} else {
Ok(())
}
}
#[cfg(target_os = "linux")]
pub(crate) fn bind_control(&self, control: super::strict_instant::Control) {
*self
.strict_control
.lock()
.unwrap_or_else(PoisonError::into_inner) = Some(control);
}
pub(crate) fn cancel(&self) {
#[cfg(target_os = "linux")]
if let Some(control) = self
.strict_control
.lock()
.unwrap_or_else(PoisonError::into_inner)
.as_ref()
{
control.deny();
}
self.cancelled.send_replace(true);
self.ready.notify_one();
}
pub(crate) async fn cancelled(&self) {
let mut cancelled = self.cancelled.subscribe();
while !*cancelled.borrow_and_update() {
if cancelled.changed().await.is_err() {
break;
}
}
}
pub(crate) fn persist_upload(&self, upload: UploadMeta) -> Result<(), AuthedApiError> {
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
self.check()?;
let mut meta =
RecordingMeta::load_for_project(&self.directory).map_err(|error| error.to_string())?;
meta.upload = Some(upload);
meta.save_for_project().map_err(|error| error.to_string())?;
Ok(())
}
pub(crate) fn persist_local_complete(
&self,
recording: cap_project::InstantRecordingMeta,
sharing: cap_project::SharingMeta,
) -> Result<(), AuthedApiError> {
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
self.check()?;
let mut meta =
RecordingMeta::load_for_project(&self.directory).map_err(|error| error.to_string())?;
meta.inner = cap_project::RecordingMetaInner::Instant(recording);
meta.sharing = Some(sharing);
meta.save_for_project().map_err(|error| error.to_string())?;
Ok(())
}
pub(crate) fn mark_ready(&self, preserve_local: bool) -> Result<(), AuthedApiError> {
self.acquire()?;
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
if let Some(mut intent) = read(&self.directory)? {
intent.local_ready = true;
intent.preserve_local |= preserve_local;
intent.retry_at = None;
write(&self.directory, &intent)?;
}
self.ready.notify_one();
Ok(())
}
pub(crate) async fn wait_ready(&self) -> Result<(), AuthedApiError> {
loop {
self.check()?;
match read(&self.directory)? {
Some(intent) if intent.cancelled => {
return Err("Recording upload was cancelled".into());
}
Some(intent) if !intent.local_ready => {}
_ => return Ok(()),
}
tokio::select! { _ = self.ready.notified() => {}, _ = self.cancelled() => {}, _ = tokio::time::sleep(Duration::from_millis(100)) => {} }
}
}
pub(crate) fn record_failure(&self, error: &AuthedApiError) {
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
let result = (|| {
let Some(mut intent) = read(&self.directory)? else {
return Ok::<_, AuthedApiError>(());
};
intent.needs_authentication = matches!(error, AuthedApiError::InvalidAuthentication);
if !matches!(
error,
AuthedApiError::InvalidAuthentication | AuthedApiError::VerificationPending
) {
intent.failures = intent.failures.saturating_add(1);
}
intent.retry_at = (intent.failures < 5).then(|| {
chrono::Utc::now()
.timestamp()
.saturating_add(30 * (1_i64 << intent.failures.min(5)))
});
intent.error = Some(error.to_string());
write(&self.directory, &intent)
})();
if let Err(error) = result {
warn!(%error, "Could not save upload retry state");
}
}
pub(crate) fn mark_cancelled(&self) -> Result<(), AuthedApiError> {
self.cancel();
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
if let Some(mut intent) = read(&self.directory)? {
intent.cancelled = true;
intent.retry_at = None;
write(&self.directory, &intent)?;
}
Ok(())
}
pub(crate) fn set_verification(
&self,
verification: &UploadVerification,
) -> Result<(), AuthedApiError> {
self.check()?;
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
if let Some(mut intent) = read(&self.directory)? {
if intent.required_audio != Some(verification.required_audio) {
return Err("Upload audio intent changed".into());
}
intent.verification = Some(verification.clone());
intent.receipt = None;
write(&self.directory, &intent)?;
}
Ok(())
}
pub(crate) fn clear_verification(&self) -> Result<(), AuthedApiError> {
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
*self.verified.lock().unwrap_or_else(PoisonError::into_inner) = None;
if let Some(mut intent) = read(&self.directory)? {
intent.verification = None;
intent.receipt = None;
write(&self.directory, &intent)?;
}
Ok(())
}
pub(crate) fn record_receipt(
&self,
verification: &UploadVerification,
receipt: &VerifiedUploadReceipt,
) -> Result<(), AuthedApiError> {
self.check()?;
verification
.verified_receipt(
&self.video_id,
&serde_json::json!({"success":true,"status":"verified","verification":receipt}),
)?
.ok_or("Recording verification is pending")?;
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
*self.verified.lock().unwrap_or_else(PoisonError::into_inner) =
Some((verification.clone(), receipt.clone()));
if let Some(mut intent) = read(&self.directory)? {
intent.verification = Some(verification.clone());
intent.receipt = Some(receipt.clone());
intent.failures = 0;
intent.needs_authentication = false;
intent.retry_at = None;
intent.error = None;
write(&self.directory, &intent)?;
}
Ok(())
}
pub(crate) async fn complete_locally(&self, app: &AppHandle) -> Result<(), AuthedApiError> {
self.check()?;
if let Some(context) = self.context() {
context.check(app).await?;
}
let _ledger = self.ledger.lock().unwrap_or_else(PoisonError::into_inner);
let intent = read(&self.directory)?;
let evidence = intent
.as_ref()
.and_then(|intent| intent.verification.clone().zip(intent.receipt.clone()))
.or_else(|| {
self.verified
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone()
})
.ok_or("Recording verification evidence is missing")?;
let (verification, receipt) = (&evidence.0, &evidence.1);
verification
.verified_receipt(
&self.video_id,
&serde_json::json!({"success":true,"status":"verified","verification":receipt}),
)?
.ok_or("Recording verification is pending")?;
verify_local_artifact(&self.directory, verification)?;
let mut meta =
RecordingMeta::load_for_project(&self.directory).map_err(|error| error.to_string())?;
if !matches!(
meta.inner,
cap_project::RecordingMetaInner::Instant(
cap_project::InstantRecordingMeta::Complete { .. }
)
) || upload_video_id(&meta.upload).is_some_and(|id| id != self.video_id)
|| meta
.sharing
.as_ref()
.is_some_and(|sharing| sharing.id != self.video_id)
|| intent.as_ref().is_some_and(|intent| intent.cancelled)
{
return Err("Recording is not locally ready for upload completion".into());
}
self.check()?;
meta.upload = Some(UploadMeta::Complete);
meta.save_for_project().map_err(|error| error.to_string())?;
self.check()?;
if intent.as_ref().is_some_and(|intent| !intent.preserve_local)
&& crate::general_settings::GeneralSettingsStore::get(app)
.ok()
.flatten()
.unwrap_or_default()
.delete_instant_recordings_after_upload
{
verify_local_artifact(&self.directory, verification)?;
self.check()?;
if let Err(error) = std::fs::remove_dir_all(&self.directory) {
warn!(%error, "Verified recording retained because cleanup failed");
}
}
Ok(())
}
}
fn upload_video_id(upload: &Option<UploadMeta>) -> Option<&str> {
match upload {
Some(
UploadMeta::SegmentUpload { video_id, .. }
| UploadMeta::MultipartUpload { video_id, .. }
| UploadMeta::SinglePartUpload { video_id, .. },
) => Some(video_id),
_ => None,
}
}
fn verify_local_artifact(
directory: &Path,
verification: &UploadVerification,
) -> Result<(), AuthedApiError> {
use cap_recording::upload_verification::UploadArtifact;
match &verification.artifact {
UploadArtifact::Segments { manifest_sha256 } => {
let events = resume::collect_segment_events(directory, verification.required_audio)?;
let manifest = manifest_from_events(&events);
let compact = UploadVerification::segments(
&serde_json::to_vec(&manifest)?,
verification.required_audio,
);
let pretty = UploadVerification::segments(
&serde_json::to_vec_pretty(&manifest)?,
verification.required_audio,
);
if ![compact, pretty].iter().any(|request| matches!(&request.artifact, UploadArtifact::Segments { manifest_sha256: current } if current == manifest_sha256)) {
return Err("Local recording manifest changed after upload".into());
}
}
UploadArtifact::Mp4 {
file_size,
duration,
..
} => {
let path = directory.join("content/output.mp4");
verify_file_path(
&path,
&directory
.canonicalize()
.map_err(|error| error.to_string())?
.join("content/output.mp4"),
)?;
let info = std::fs::symlink_metadata(&path).map_err(|error| error.to_string())?;
if info.file_type().is_symlink()
|| !info.is_file()
|| info.len() != *file_size
|| build_video_meta(&path)?.duration_in_secs != *duration
{
return Err("Local recording changed after upload".into());
}
}
}
Ok(())
}
fn manifest_from_events(
events: &[cap_enc_ffmpeg::segmented_stream::SegmentCompletedEvent],
) -> SegmentUploadManifest {
use cap_enc_ffmpeg::segmented_stream::SegmentMediaType;
let mut state = SegmentUploadState::new();
for event in events {
match (event.is_init, event.media_type) {
(true, SegmentMediaType::Video) => state.video_init_uploaded = true,
(true, SegmentMediaType::Audio) => state.audio_init_uploaded = true,
(false, SegmentMediaType::Video) => {
state
.uploaded_video_segments
.insert(event.index, event.duration);
}
(false, SegmentMediaType::Audio) => {
state
.uploaded_audio_segments
.insert(event.index, event.duration);
}
}
}
state.to_complete_manifest()
}
pub(crate) async fn resume_audio(
app: &AppHandle,
directory: &Path,
fallback: bool,
) -> Result<Option<bool>, AuthedApiError> {
Ok(match read(directory)? {
Some(intent)
if intent.cancelled
|| intent.failures >= 5
|| intent
.retry_at
.is_some_and(|at| at > chrono::Utc::now().timestamp()) =>
{
None
}
Some(intent) => {
if intent.needs_authentication {
let context = UploadRequestContext::new(
intent.server_url,
intent
.owner_id
.ok_or(AuthedApiError::InvalidAuthentication)?,
)?;
if context.check(app).await.is_err() {
return Ok(None);
}
}
intent.required_audio
}
None => Some(fallback),
})
}
pub(crate) async fn resume_existing(
app: AppHandle,
meta: RecordingMeta,
lock: UploadLock,
required_audio: bool,
) -> Result<Arc<Session>, AuthedApiError> {
let directory = meta.project_path.clone();
let video_id = upload_video_id(&meta.upload)
.map(str::to_string)
.ok_or("No resumable upload identity")?;
let session = Session::new(lock.project_path().to_path_buf(), video_id.clone());
session.adopt(lock)?;
session.mark_ready(false)?;
let worker = session.clone();
supervise(app.clone(), session.clone(), async move {
match meta.upload.clone() {
Some(UploadMeta::SegmentUpload {
video_id,
pre_created_video,
recording_dir,
}) => {
verify_bundle_path(&directory, &recording_dir)?;
if video_id != pre_created_video.id || video_id != pre_created_video.config.id {
return Err("Upload identity changed".into());
}
let events = resume::collect_segment_events(&directory, required_audio)?;
let (sender, receiver) = std::sync::mpsc::channel();
for event in events {
sender.send(event).map_err(|error| error.to_string())?;
}
drop(sender);
SegmentUploader::run(
app.clone(),
receiver,
None,
directory.clone(),
pre_created_video,
required_audio,
worker.clone(),
)
.await?;
}
Some(UploadMeta::MultipartUpload {
video_id,
file_path,
pre_created_video,
recording_dir,
}) => {
verify_bundle_path(&directory, &recording_dir)?;
if video_id != pre_created_video.id || video_id != pre_created_video.config.id {
return Err("Upload identity changed".into());
}
verify_file_path(&file_path, &directory.join("content/output.mp4"))?;
InstantMultipartUpload::run(
app.clone(),
file_path,
pre_created_video,
directory.clone(),
None,
required_audio,
worker.clone(),
)
.await?;
}
Some(UploadMeta::SinglePartUpload {
video_id,
file_path,
screenshot_path,
recording_dir,
}) => {
verify_bundle_path(&directory, &recording_dir)?;
verify_file_path(&file_path, &meta.output_path())?;
verify_file_path(&screenshot_path, &directory.join("screenshots/display.jpg"))?;
let metadata = build_video_meta(&file_path)?;
let file_size = std::fs::metadata(&file_path).map_err(|error| error.to_string())?.len();
let duration = metadata.duration_in_secs;
let uploaded = upload_video(
&app,
video_id.clone(),
file_path,
screenshot_path,
meta.sharing.is_some()
&& matches!(meta.inner, cap_project::RecordingMetaInner::Studio(_)),
None,
)
.await?;
if uploaded.id != video_id {
return Err("Server upload identity changed".into());
}
if matches!(meta.inner, cap_project::RecordingMetaInner::Instant(_)) {
let verification = UploadVerification::mp4(file_size, duration, required_audio, uploaded.object_identity.ok_or("Server did not return the uploaded object identity; local recording retained")?)?;
await_upload_verification(&app, &video_id, &verification, &worker).await?;
} else {
let mut current = RecordingMeta::load_for_project(&directory)
.map_err(|error| error.to_string())?;
if upload_video_id(¤t.upload) != Some(video_id.as_str()) {
return Err("Upload identity changed during transfer".into());
}
worker.check()?;
current.upload = Some(UploadMeta::Complete);
current.sharing = Some(cap_project::SharingMeta {
id: uploaded.id,
link: uploaded.link,
content_hash: None,
});
current
.save_for_project()
.map_err(|error| error.to_string())?;
return Ok(());
}
}
_ => return Err("No resumable upload remains".into()),
}
let screenshot = directory.join("screenshots/display.jpg");
if screenshot.is_file() {
let bytes = compress_image(screenshot).await?;
worker.check()?;
singlepart_uploader(
app.clone(),
PresignedS3PutRequest {
video_id,
subpath: "screenshot/screen-capture.jpg".into(),
method: PresignedS3PutRequestMethod::Put,
meta: None,
},
bytes.len() as u64,
futures::stream::once(async move { Ok::<_, io::Error>(Bytes::from(bytes)) }),
)
.await?;
}
worker.complete_locally(&app).await
})
.await?;
Ok(session)
}
fn verify_bundle_path(expected: &Path, stored: &Path) -> Result<(), AuthedApiError> {
if expected.canonicalize().map_err(|error| error.to_string())?
!= stored.canonicalize().map_err(|error| error.to_string())?
{
return Err("Stored recording path changed".into());
}
Ok(())
}
fn verify_file_path(stored: &Path, expected: &Path) -> Result<(), AuthedApiError> {
let parent = expected
.parent()
.ok_or("Upload input has no local parent")?;
let parent_info = parent
.symlink_metadata()
.map_err(|error| error.to_string())?;
if parent_info.file_type().is_symlink() || !parent_info.is_dir() {
return Err("Upload input directory is not a local directory".into());
}
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
if parent_info.file_attributes() & 0x400 != 0 {
return Err("Upload input directory is a reparse point".into());
}
}
let metadata = stored
.symlink_metadata()
.map_err(|error| error.to_string())?;
#[cfg(windows)]
{
use std::os::windows::fs::MetadataExt;
if metadata.file_attributes() & 0x400 != 0 {
return Err("Upload input is a reparse point".into());
}
}
if !metadata.is_file() || metadata.file_type().is_symlink() || metadata.len() == 0 {
return Err("Upload input is not a valid local file".into());
}
verify_bundle_path(expected, stored)
}
fn pending_reupload(meta: &RecordingMeta, intent: &Intent) -> Result<UploadMeta, AuthedApiError> {
use cap_recording::upload_verification::UploadArtifact;
let sharing = meta
.sharing
.as_ref()
.ok_or("Recording share identity is missing")?;
if sharing.id != intent.video_id || intent.cancelled || !intent.local_ready {
return Err("Recording retry identity changed or was cancelled".into());
}
let video = VideoUploadInfo {
id: intent.video_id.clone(),
link: sharing.link.clone(),
config: S3UploadMeta {
id: intent.video_id.clone(),
},
};
let segmented = match intent
.verification
.as_ref()
.map(|request| &request.artifact)
{
Some(UploadArtifact::Segments { .. }) => true,
Some(UploadArtifact::Mp4 { .. }) => false,
None => match meta.project_path.join("content/display").symlink_metadata() {
Ok(_) => true,
Err(error) if error.kind() == io::ErrorKind::NotFound => false,
Err(error) => return Err(error.to_string().into()),
},
};
Ok(if segmented {
UploadMeta::SegmentUpload {
video_id: intent.video_id.clone(),
pre_created_video: video,
recording_dir: meta.project_path.clone(),
}
} else {
UploadMeta::MultipartUpload {
video_id: intent.video_id.clone(),
pre_created_video: video,
recording_dir: meta.project_path.clone(),
file_path: meta.project_path.join("content/output.mp4"),
}
})
}
fn prepare_retry_state(
directory: &Path,
meta: &mut RecordingMeta,
intent: &mut Intent,
save_meta: impl FnOnce(&RecordingMeta) -> Result<(), String>,
) -> Result<(), AuthedApiError> {
let reupload = matches!(meta.upload, Some(UploadMeta::Complete));
if reupload {
meta.upload = Some(pending_reupload(meta, intent)?);
intent.verification = None;
intent.receipt = None;
}
if upload_video_id(&meta.upload) != Some(intent.video_id.as_str()) {
return Err("Recording retry identity changed".into());
}
intent.failures = 0;
intent.needs_authentication = false;
intent.retry_at = None;
intent.error = None;
write(directory, intent)?;
if reupload {
save_meta(meta)?;
}
Ok(())
}
pub(crate) fn reconcile_reupload(meta: &mut RecordingMeta) -> Result<(), AuthedApiError> {
if !matches!(meta.upload, Some(UploadMeta::Complete))
|| !matches!(
meta.inner,
cap_project::RecordingMetaInner::Instant(
cap_project::InstantRecordingMeta::Complete { .. }
)
)
{
return Ok(());
}
let Some(intent) = read(&meta.project_path)? else {
return Ok(());
};
if intent.cancelled
|| !intent.local_ready
|| intent.verification.is_some()
|| intent.receipt.is_some()
{
return Ok(());
}
meta.upload = Some(pending_reupload(meta, &intent)?);
meta.save_for_project().map_err(|error| error.to_string())?;
Ok(())
}
pub(crate) async fn retry_existing(
app: AppHandle,
directory: &Path,
) -> Result<Option<String>, AuthedApiError> {
if read(directory)?.is_none() {
return Ok(None);
}
let lock = acquire_upload_lock(directory)?;
let mut intent = read(directory)?.ok_or("Upload intent disappeared")?;
if intent.cancelled || !intent.local_ready {
return Err("This recording is not available for upload retry".into());
}
let context = UploadRequestContext::new(
intent.server_url.clone(),
intent
.owner_id
.clone()
.ok_or(AuthedApiError::InvalidAuthentication)?,
)?;
context.check(&app).await?;
let required_audio = intent
.required_audio
.ok_or("Recording audio intent is unknown")?;
let mut meta = RecordingMeta::load_for_project(directory).map_err(|error| error.to_string())?;
if !matches!(
meta.inner,
cap_project::RecordingMetaInner::Instant(
cap_project::InstantRecordingMeta::Complete { .. }
)
) {
return Err("Recording must finish locally before retry".into());
}
let link = meta
.sharing
.as_ref()
.map(|sharing| sharing.link.clone())
.ok_or("Recording share identity is missing")?;
prepare_retry_state(directory, &mut meta, &mut intent, |meta| {
meta.save_for_project().map_err(|error| error.to_string())
})?;
let session = resume_existing(app, meta, lock, required_audio).await?;
let mut terminal = session.terminal.subscribe();
timeout(Duration::from_secs(30 * 60), async {
loop {
if let Some(result) = terminal.borrow_and_update().clone() {
result.map_err(AuthedApiError::from)?;
return Ok(Some(link));
}
terminal
.changed()
.await
.map_err(|_| "Upload completion channel closed")?;
}
})
.await
.map_err(|_| AuthedApiError::VerificationPending)?
}
struct Job {
session: Arc<Session>,
handle: JoinHandle<()>,
}
static JOBS: std::sync::OnceLock<Mutex<HashMap<PathBuf, Job>>> = std::sync::OnceLock::new();
static PUMP: std::sync::OnceLock<Mutex<Option<JoinHandle<()>>>> = std::sync::OnceLock::new();
static WAKE: tokio::sync::Notify = tokio::sync::Notify::const_new();
static STOPPING: AtomicBool = AtomicBool::new(false);
fn jobs() -> &'static Mutex<HashMap<PathBuf, Job>> {
JOBS.get_or_init(Mutex::default)
}
pub(crate) fn has_capacity() -> bool {
!STOPPING.load(Ordering::Acquire)
&& jobs().lock().unwrap_or_else(PoisonError::into_inner).len() < 2
}
pub(crate) async fn supervise<F>(
app: AppHandle,
session: Arc<Session>,
work: F,
) -> Result<(), AuthedApiError>
where
F: std::future::Future<Output = Result<(), AuthedApiError>> + Send + 'static,
{
let mut work = Some(work);
let registered = {
let mut jobs = jobs().lock().unwrap_or_else(PoisonError::into_inner);
if STOPPING.load(Ordering::Acquire) || jobs.contains_key(&session.directory) {
false
} else {
let directory = session.directory.clone();
let worker = session.clone();
let context = session.context();
let work = work.take().unwrap();
let handle = spawn_actor(async move {
let result = std::panic::AssertUnwindSafe(
worker.run(crate::web_api::inherit_upload_context(context, work)),
)
.catch_unwind()
.await
.unwrap_or_else(|_| Err("Upload worker failed; local recording retained".into()));
worker
.terminal
.send_replace(Some(result.as_ref().copied().map_err(ToString::to_string)));
if let Err(error) = result {
if !matches!(error, AuthedApiError::VerificationPending) {
crate::notifications::NotificationType::UploadFailed.send(&app);
}
worker.record_failure(&error);
warn!(%error, "Recording upload retained for retry");
}
emit_upload_complete(&app, &worker.video_id);
});
jobs.insert(
directory,
Job {
session: session.clone(),
handle,
},
);
true
}
};
if !registered {
session.cancel();
let result = session
.run(crate::web_api::inherit_upload_context(
session.context(),
work.unwrap(),
))
.await;
session
.terminal
.send_replace(Some(result.as_ref().copied().map_err(ToString::to_string)));
if let Err(error) = result {
session.record_failure(&error);
}
}
Ok(())
}
async fn join_job(job: Job) {
if let Err(error) = job.handle.await {
job.session.record_failure(&AuthedApiError::Other(format!(
"Upload supervisor failed: {error}"
)));
warn!(%error, "Upload supervisor failed");
}
}
pub(crate) async fn reap() {
let completed = {
let mut jobs = jobs().lock().unwrap_or_else(PoisonError::into_inner);
let paths: Vec<_> = jobs
.iter()
.filter(|(_, job)| job.handle.is_finished())
.map(|(path, _)| path.clone())
.collect();
paths
.into_iter()
.filter_map(|path| jobs.remove(&path))
.collect::<Vec<_>>()
};
for job in completed {
join_job(job).await;
}
}
pub(crate) async fn cancel(directory: &Path) {
let job = jobs()
.lock()
.unwrap_or_else(PoisonError::into_inner)
.remove(directory);
if let Some(job) = job {
job.session.mark_cancelled().ok();
join_job(job).await;
}
}
pub(crate) fn mark_cancelled(directory: &Path) -> Result<(), AuthedApiError> {
if let Some(mut intent) = read(directory)? {
intent.cancelled = true;
intent.retry_at = None;
write(directory, &intent)?;
}
Ok(())
}
pub(crate) fn init(app: AppHandle) {
let mut pump = PUMP
.get_or_init(Mutex::default)
.lock()
.unwrap_or_else(PoisonError::into_inner);
if pump.is_some() {
return;
}
*pump = Some(spawn_actor(async move {
loop {
if STOPPING.load(Ordering::Acquire) {
return;
}
tokio::select! {
ready = crate::startup::wait_for_window(&app) => {
if !ready {
return;
}
break;
}
_ = WAKE.notified() => {},
}
}
let mut first = true;
while !STOPPING.load(Ordering::Acquire) {
if let Err(error) = crate::resume_uploads(app.clone(), first).await {
warn!(%error, "Upload reconciliation failed; recordings retained");
}
first = false;
tokio::select! {
_ = WAKE.notified() => {},
_ = tokio::time::sleep(Duration::from_secs(30)) => {},
}
}
}));
}
pub(crate) async fn shutdown() {
STOPPING.store(true, Ordering::Release);
WAKE.notify_one();
let pump = PUMP
.get_or_init(Mutex::default)
.lock()
.unwrap_or_else(PoisonError::into_inner)
.take();
if let Some(pump) = pump {
let _ = pump.await;
}
let owned = std::mem::take(&mut *jobs().lock().unwrap_or_else(PoisonError::into_inner));
for job in owned.values() {
job.session.cancel();
}
for (_, job) in owned {
join_job(job).await;
}
}
#[cfg(test)]
mod tests {
use super::*;
fn project() -> (tempfile::TempDir, Arc<Session>) {
let directory = tempfile::tempdir().unwrap();
std::fs::write(
directory.path().join("retained-media"),
b"original recording bytes",
)
.unwrap();
write(
directory.path(),
&Intent {
version: 1,
video_id: "owned-video".into(),
server_url: "https://example.invalid".into(),
owner_id: Some("owner".into()),
required_audio: Some(true),
local_ready: false,
cancelled: false,
preserve_local: false,
failures: 0,
needs_authentication: false,
retry_at: None,
error: None,
verification: None,
receipt: None,
},
)
.unwrap();
RecordingMeta {
platform: None,
project_path: directory.path().to_path_buf(),
pretty_name: "retained".into(),
sharing: None,
inner: cap_project::RecordingMetaInner::Instant(
cap_project::InstantRecordingMeta::InProgress { recording: true },
),
upload: None,
}
.save_for_project()
.unwrap();
let lock = UploadLock::acquire(directory.path()).unwrap();
let session = Session::new(lock.project_path().to_path_buf(), "owned-video".into());
session.adopt(lock).unwrap();
(directory, session)
}
fn receipt(request: &UploadVerification) -> VerifiedUploadReceipt {
VerifiedUploadReceipt {
version: 1,
video_id: "owned-video".into(),
artifact: request.artifact.clone(),
file_size: 4096,
duration: 10.0,
has_audio: true,
full_decode: true,
required_audio_verified: request.required_audio,
}
}
#[tokio::test]
async fn local_ready_releases_completion_gate_without_waiting_for_network() {
let (directory, session) = project();
let mut gate = Box::pin(session.wait_ready());
assert!(futures::poll!(gate.as_mut()).is_pending());
session.mark_ready(false).unwrap();
gate.await.unwrap();
let intent = read(directory.path()).unwrap().unwrap();
assert!(intent.local_ready);
assert!(intent.verification.is_none());
assert!(intent.receipt.is_none());
assert!(directory.path().join("retained-media").exists());
}
#[tokio::test]
async fn cancellation_is_persisted_and_never_opens_completion_gate() {
let (directory, session) = project();
let mut gate = Box::pin(session.wait_ready());
assert!(futures::poll!(gate.as_mut()).is_pending());
session.mark_cancelled().unwrap();
assert!(gate.await.is_err());
assert!(read(directory.path()).unwrap().unwrap().cancelled);
assert_eq!(
std::fs::read(directory.path().join("retained-media")).unwrap(),
b"original recording bytes"
);
}
#[test]
fn restart_preserves_identity_and_actual_audio_intent_with_exclusive_ownership() {
let (directory, session) = project();
session.mark_ready(false).unwrap();
session.record_failure(&AuthedApiError::Timeout);
assert!(matches!(
UploadLock::acquire(directory.path()),
Err(cap_recording::upload_resume::UploadLockError::Busy)
));
drop(session);
let lock = UploadLock::acquire(directory.path()).unwrap();
let resumed = Session::new(lock.project_path().to_path_buf(), "owned-video".into());
resumed.adopt(lock).unwrap();
let intent = read(directory.path()).unwrap().unwrap();
assert_eq!(intent.video_id, "owned-video");
assert_eq!(intent.owner_id.as_deref(), Some("owner"));
assert_eq!(intent.required_audio, Some(true));
assert!(intent.local_ready);
assert_eq!(intent.failures, 1);
assert!(directory.path().join("retained-media").exists());
}
#[test]
fn processing_and_authentication_do_not_exhaust_failed_transfer_budget() {
let (directory, session) = project();
for _ in 0..8 {
session.record_failure(&AuthedApiError::VerificationPending);
}
assert_eq!(read(directory.path()).unwrap().unwrap().failures, 0);
session.record_failure(&AuthedApiError::InvalidAuthentication);
let intent = read(directory.path()).unwrap().unwrap();
assert!(intent.needs_authentication);
assert_eq!(intent.failures, 0);
for _ in 0..5 {
session.record_failure(&AuthedApiError::Timeout);
}
let intent = read(directory.path()).unwrap().unwrap();
assert_eq!(intent.failures, 5);
assert!(intent.retry_at.is_none());
assert_eq!(intent.video_id, "owned-video");
assert!(directory.path().join("retained-media").exists());
}
#[test]
fn server_retransfer_clears_only_cached_evidence() {
let (directory, session) = project();
let request = UploadVerification::segments(b"manifest", true);
session.set_verification(&request).unwrap();
session
.record_receipt(&request, &receipt(&request))
.unwrap();
session.clear_verification().unwrap();
session.record_failure(&AuthedApiError::ReuploadRequired);
let intent = read(directory.path()).unwrap().unwrap();
assert!(intent.verification.is_none());
assert!(intent.receipt.is_none());
assert_eq!(intent.video_id, "owned-video");
assert!(directory.path().join("retained-media").exists());
}
#[test]
fn wrong_generation_or_probe_only_receipt_never_persists_completion() {
let (directory, session) = project();
let request = UploadVerification::segments(b"manifest", true);
session.set_verification(&request).unwrap();
for change in 0..5 {
let mut invalid = receipt(&request);
match change {
0 => invalid.full_decode = false,
1 => invalid.has_audio = false,
2 => invalid.video_id = "other-video".into(),
3 => invalid.required_audio_verified = false,
_ => {
invalid.artifact =
UploadVerification::segments(b"other-manifest", true).artifact
}
}
assert!(session.record_receipt(&request, &invalid).is_err());
assert!(read(directory.path()).unwrap().unwrap().receipt.is_none());
}
assert!(directory.path().join("retained-media").exists());
}
#[test]
fn unknown_legacy_upload_does_not_acquire_an_invented_sidecar() {
let directory = tempfile::tempdir().unwrap();
let lock = UploadLock::acquire(directory.path()).unwrap();
let session = Session::new(lock.project_path().to_path_buf(), "legacy-video".into());
session.adopt(lock).unwrap();
session.record_failure(&AuthedApiError::Timeout);
session.mark_ready(false).unwrap();
assert!(read(directory.path()).unwrap().is_none());
}
#[tokio::test]
async fn cancelled_job_retains_lock_until_its_worker_is_joined() {
let (directory, session) = project();
let (release, released) = tokio::sync::oneshot::channel();
let worker = session.clone();
let handle = tokio::spawn(async move {
worker.cancelled().await;
released.await.unwrap();
assert!(worker.directory.join("retained-media").exists());
});
let job = Job {
session: session.clone(),
handle,
};
session.cancel();
drop(session);
let mut joined = Box::pin(join_job(job));
assert!(futures::poll!(joined.as_mut()).is_pending());
assert!(matches!(
UploadLock::acquire(directory.path()),
Err(cap_recording::upload_resume::UploadLockError::Busy)
));
release.send(()).unwrap();
joined.await;
assert!(UploadLock::acquire(directory.path()).is_ok());
assert!(directory.path().join("retained-media").exists());
}
#[cfg(unix)]
#[test]
fn upload_input_cannot_escape_through_a_parent_symlink() {
let directory = tempfile::tempdir().unwrap();
let outside = tempfile::tempdir().unwrap();
std::fs::write(outside.path().join("output.mp4"), b"private bytes").unwrap();
std::os::unix::fs::symlink(outside.path(), directory.path().join("content")).unwrap();
let path = directory.path().join("content/output.mp4");
assert!(verify_file_path(&path, &path).is_err());
assert_eq!(
std::fs::read(outside.path().join("output.mp4")).unwrap(),
b"private bytes"
);
}
#[test]
fn legacy_mp4_proof_without_object_generation_retransfers_without_changing_identity() {
let (directory, session) = project();
let mut intent = read(directory.path()).unwrap().unwrap();
intent.verification = Some(serde_json::from_value(serde_json::json!({"version":1,"artifact":{"kind":"mp4","fileSize":4096,"duration":10.0},"requiredAudio":true})).unwrap());
write(directory.path(), &intent).unwrap();
assert!(session.cached_verification().unwrap().is_none());
let retained = read(directory.path()).unwrap().unwrap();
assert!(retained.verification.is_none());
assert!(retained.receipt.is_none());
assert_eq!(retained.video_id, "owned-video");
assert!(directory.path().join("retained-media").exists());
}
#[test]
fn concurrent_local_save_and_upload_start_preserve_both_updates() {
let (directory, session) = project();
let barrier = Arc::new(std::sync::Barrier::new(2));
let worker = session.clone();
let upload_barrier = barrier.clone();
let uploader = std::thread::spawn(move || {
upload_barrier.wait();
worker
.persist_upload(UploadMeta::SinglePartUpload {
video_id: "owned-video".into(),
file_path: worker.directory.join("content/output.mp4"),
screenshot_path: worker.directory.join("screenshots/display.jpg"),
recording_dir: worker.directory.clone(),
})
.unwrap();
});
barrier.wait();
session
.persist_local_complete(
cap_project::InstantRecordingMeta::Complete {
fps: 30,
sample_rate: Some(48000),
},
cap_project::SharingMeta {
id: "owned-video".into(),
link: "https://example.invalid/s/owned-video".into(),
content_hash: None,
},
)
.unwrap();
uploader.join().unwrap();
let meta = RecordingMeta::load_for_project(directory.path()).unwrap();
assert!(matches!(
meta.inner,
cap_project::RecordingMetaInner::Instant(
cap_project::InstantRecordingMeta::Complete { .. }
)
));
assert_eq!(upload_video_id(&meta.upload), Some("owned-video"));
assert_eq!(meta.sharing.unwrap().id, "owned-video");
assert!(directory.path().join("retained-media").exists());
}
#[tokio::test]
async fn cancellation_drops_inherited_request_future_without_authorizing_completion() {
struct PendingRequest(Arc<AtomicBool>);
impl Drop for PendingRequest {
fn drop(&mut self) {
self.0.store(true, Ordering::Release);
}
}
let (_directory, session) = project();
let dropped = Arc::new(AtomicBool::new(false));
let completed = Arc::new(AtomicBool::new(false));
let (entered, started) = tokio::sync::oneshot::channel();
let worker = session.clone();
let request_dropped = dropped.clone();
let completion = completed.clone();
let task = tokio::spawn(async move {
worker
.run(async move {
let task =
tokio::spawn(crate::web_api::inherit_upload_context(None, async move {
let _request = PendingRequest(request_dropped);
entered.send(()).unwrap();
cancellable(std::future::pending::<()>()).await?;
completion.store(true, Ordering::Release);
Ok::<_, AuthedApiError>(())
}));
task.await.unwrap()
})
.await
});
started.await.unwrap();
session.cancel();
assert!(
timeout(Duration::from_secs(2), task)
.await
.unwrap()
.unwrap()
.is_err()
);
assert!(dropped.load(Ordering::Acquire));
assert!(!completed.load(Ordering::Acquire));
}
#[tokio::test]
async fn cancelled_filesystem_future_keeps_ownership_until_real_read_finishes() {
let (directory, session) = project();
let (entered, started) = tokio::sync::oneshot::channel();
let (release, released) = std::sync::mpsc::channel();
let closed = Arc::new(AtomicBool::new(false));
let finished = closed.clone();
let path = directory.path().join("retained-media");
let worker = session.clone();
let mut task = tokio::spawn(async move {
worker
.run(file_io(move || {
use std::io::Read;
let mut file = std::fs::File::open(path)?;
entered.send(()).unwrap();
released.recv_timeout(Duration::from_secs(2)).unwrap();
let mut bytes = Vec::new();
file.read_to_end(&mut bytes)?;
drop(file);
finished.store(true, Ordering::Release);
Ok(bytes)
}))
.await
});
started.await.unwrap();
session.cancel();
assert!(futures::poll!(&mut task).is_pending());
assert!(!closed.load(Ordering::Acquire));
assert!(matches!(
UploadLock::acquire(directory.path()),
Err(cap_recording::upload_resume::UploadLockError::Busy)
));
release.send(()).unwrap();
assert!(
timeout(Duration::from_secs(2), task)
.await
.unwrap()
.unwrap()
.is_err()
);
assert!(closed.load(Ordering::Acquire));
assert_eq!(session.reads.active.load(Ordering::Acquire), 0);
drop(session);
assert!(UploadLock::acquire(directory.path()).is_ok());
}
#[tokio::test]
async fn cancellation_closes_progressive_reader_without_waiting_for_recording_done() {
let (directory, session) = project();
let path = directory.path().join("retained-media");
let (done, receiver) = flume::bounded(1);
let worker = session.clone();
let task = tokio::spawn(async move {
worker
.run(
super::super::from_pending_file_to_chunks(path, Some(receiver))
.try_collect::<Vec<_>>(),
)
.await
});
timeout(Duration::from_secs(2), async {
while session.reads.active.load(Ordering::Acquire) == 0 {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
session.cancel();
assert!(
timeout(Duration::from_secs(2), task)
.await
.unwrap()
.unwrap()
.is_err()
);
assert_eq!(session.reads.active.load(Ordering::Acquire), 0);
assert!(done.is_disconnected());
assert_eq!(
std::fs::read(directory.path().join("retained-media")).unwrap(),
b"original recording bytes"
);
}
fn completed_retry_fixture(
directory: &Path,
session: &Session,
segmented: bool,
) -> (RecordingMeta, Intent) {
session
.persist_local_complete(
cap_project::InstantRecordingMeta::Complete {
fps: 30,
sample_rate: Some(48000),
},
cap_project::SharingMeta {
id: "owned-video".into(),
link: "https://example.invalid/s/owned-video".into(),
content_hash: None,
},
)
.unwrap();
session.mark_ready(false).unwrap();
let request = if segmented {
std::fs::create_dir_all(directory.join("content/display")).unwrap();
UploadVerification::segments(b"manifest", true)
} else {
UploadVerification::mp4(4096, 10.0, true, "\"old-object\"".into()).unwrap()
};
session.set_verification(&request).unwrap();
session
.record_receipt(&request, &receipt(&request))
.unwrap();
let mut meta = RecordingMeta::load_for_project(directory).unwrap();
meta.upload = Some(UploadMeta::Complete);
meta.save_for_project().unwrap();
(meta, read(directory).unwrap().unwrap())
}
#[test]
fn explicit_reupload_reuses_original_identity_and_clears_completed_proof() {
for segmented in [false, true] {
let (directory, session) = project();
let (mut meta, mut intent) =
completed_retry_fixture(directory.path(), &session, segmented);
prepare_retry_state(directory.path(), &mut meta, &mut intent, |meta| {
meta.save_for_project().map_err(|error| error.to_string())
})
.unwrap();
let pending = RecordingMeta::load_for_project(directory.path()).unwrap();
assert_eq!(upload_video_id(&pending.upload), Some("owned-video"));
assert_eq!(
matches!(pending.upload, Some(UploadMeta::SegmentUpload { .. })),
segmented
);
let retained = read(directory.path()).unwrap().unwrap();
assert!(retained.verification.is_none());
assert!(retained.receipt.is_none());
assert_eq!(retained.owner_id.as_deref(), Some("owner"));
assert!(directory.path().join("retained-media").exists());
}
}
#[test]
fn interrupted_reupload_metadata_write_remains_recoverable_without_stale_proof() {
for segmented in [false, true] {
let (directory, session) = project();
let (mut meta, mut intent) =
completed_retry_fixture(directory.path(), &session, segmented);
assert!(
prepare_retry_state(directory.path(), &mut meta, &mut intent, |_| Err(
"injected metadata replacement failure".into()
))
.is_err()
);
let mut original = RecordingMeta::load_for_project(directory.path()).unwrap();
assert!(matches!(original.upload, Some(UploadMeta::Complete)));
assert!(
read(directory.path())
.unwrap()
.unwrap()
.verification
.is_none()
);
reconcile_reupload(&mut original).unwrap();
assert_eq!(upload_video_id(&original.upload), Some("owned-video"));
assert_eq!(
matches!(original.upload, Some(UploadMeta::SegmentUpload { .. })),
segmented
);
assert!(directory.path().join("retained-media").exists());
}
}
}