Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use std::collections::{HashMap, VecDeque};
use std::io::{Read, Seek, SeekFrom};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::{Duration, Instant};
use cap_enc_ffmpeg::segmented_stream::{SegmentCompletedEvent, SegmentMediaType};
use cap_project::{RecordingMeta, S3UploadMeta, SharingMeta, UploadMeta, VideoUploadInfo};
use cap_recording::upload_preparation::{Preparation, Segment};
use futures_util::{StreamExt as _, stream::FuturesUnordered};
use reqwest::StatusCode;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use crate::auth::{self, AuthApiError};
pub(crate) mod instant_cleanup;
#[cfg(test)]
mod multipart_tests;
pub(crate) mod queue;
#[cfg(test)]
mod real_app_tests;
#[cfg(test)]
mod verify_tests;
const MIN_CHUNK_SIZE: u64 = 5 * 1024 * 1024;
const MAX_CHUNK_SIZE: u64 = 15 * 1024 * 1024;
const DRIVE_CHUNK_ALIGNMENT: u64 = 256 * 1024;
const MAX_SEGMENT_UPLOADS: usize = 6;
const SEGMENT_URL_PREFETCH: u32 = 20;
const SEGMENT_UPLOAD_ATTEMPTS: u32 = 3;
const SEGMENT_RETRY_WINDOW: Duration = Duration::from_secs(5 * 60);
const SEGMENT_RETRY_MIN_DELAY: Duration = Duration::from_secs(2);
const SEGMENT_RETRY_MAX_DELAY: Duration = Duration::from_secs(30);
const MANIFEST_UPLOAD_INTERVAL: Duration = Duration::from_secs(1);
const MANIFEST_SUBPATH: &str = "segments/manifest.json";
// Presigned S3 PUT URLs are signed for 30 minutes and accept repeated PUTs, so
// the manifest reuses one well inside that window instead of signing a new URL
// every second. Google Drive upload sessions are single use and never reused.
const MANIFEST_URL_REUSE: Duration = Duration::from_secs(10 * 60);
const UPLOAD_CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
const UPLOAD_TCP_KEEPALIVE: Duration = Duration::from_secs(30);
const UPLOAD_POOL_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
#[derive(Debug, Clone, Deserialize)]
struct SignedUploadTarget {
url: String,
#[serde(default)]
headers: HashMap<String, String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UploadResult {
Success(String),
NotAuthenticated,
UpgradeRequired,
}
pub struct InstantUpload {
pub video: VideoUploadInfo,
segment_upload: Option<tokio::task::JoinHandle<Result<(), String>>>,
cancel: Arc<AtomicBool>,
metadata_lock: Arc<Mutex<()>>,
completion_permit: Option<tokio::sync::oneshot::Sender<()>>,
completion_control: Option<CompletionControl>,
bridge: Option<std::thread::JoinHandle<()>>,
ownership: Option<cap_recording::upload_resume::UploadLock>,
prior_attempts: u32,
request_context: Option<auth::UploadRequestContext>,
reads: Arc<UploadReads>,
}
#[derive(Default)]
struct UploadReads {
active: std::sync::atomic::AtomicUsize,
finished: tokio::sync::Notify,
}
struct UploadReadGuard(Arc<UploadReads>);
impl Drop for UploadReadGuard {
fn drop(&mut self) {
if self.0.active.fetch_sub(1, Ordering::AcqRel) == 1 {
self.0.finished.notify_one();
}
}
}
impl UploadReads {
async fn join(&self) {
while self.active.load(Ordering::Acquire) != 0 {
self.finished.notified().await;
}
}
}
tokio::task_local! {
static UPLOAD_READS: Arc<UploadReads>;
}
async fn tracked_upload_read<T: Send + 'static>(
read: impl FnOnce() -> T + Send + 'static,
) -> Result<T, tokio::task::JoinError> {
let guard = UPLOAD_READS
.try_with(|reads| {
reads.active.fetch_add(1, Ordering::AcqRel);
UploadReadGuard(reads.clone())
})
.ok();
tokio::task::spawn_blocking(move || {
let _guard = guard;
read()
})
.await
}
async fn with_upload_context<F: Future>(
context: Option<auth::UploadRequestContext>,
reads: Arc<UploadReads>,
future: F,
) -> F::Output {
UPLOAD_READS
.scope(reads, async move {
match context {
Some(context) => context.run(future).await,
None => future.await,
}
})
.await
}
#[derive(Clone)]
pub(crate) struct CompletionControl {
denied: tokio::sync::watch::Sender<bool>,
cancel: Arc<AtomicBool>,
expected_manifest: Arc<Mutex<Option<SegmentUploadManifest>>>,
}
impl CompletionControl {
pub(crate) fn deny(&self) {
self.cancel.store(true, Ordering::Release);
self.denied.send_replace(true);
}
}
pub(crate) struct CompletionAuthorization {
permit: tokio::sync::oneshot::Sender<()>,
required: CompletionRequirement,
control: CompletionControl,
}
struct CompletionRequirement {
permission: tokio::sync::oneshot::Receiver<()>,
denied: tokio::sync::watch::Receiver<bool>,
expected_manifest: Arc<Mutex<Option<SegmentUploadManifest>>>,
}
impl CompletionAuthorization {
pub(crate) fn new() -> Self {
let (permit, permission) = tokio::sync::oneshot::channel();
let (denied, denial) = tokio::sync::watch::channel(false);
let expected_manifest = Arc::new(Mutex::new(None));
Self {
permit,
required: CompletionRequirement {
permission,
denied: denial,
expected_manifest: expected_manifest.clone(),
},
control: CompletionControl {
denied,
cancel: Arc::new(AtomicBool::new(false)),
expected_manifest,
},
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct SegmentManifestEntry {
index: u32,
duration: f64,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct SegmentUploadManifest {
version: u32,
video_init_uploaded: bool,
audio_init_uploaded: bool,
video_segments: Vec<SegmentManifestEntry>,
audio_segments: Vec<SegmentManifestEntry>,
is_complete: bool,
}
impl Default for SegmentUploadManifest {
fn default() -> Self {
Self {
version: 2,
video_init_uploaded: false,
audio_init_uploaded: false,
video_segments: Vec::new(),
audio_segments: Vec::new(),
is_complete: false,
}
}
}
impl SegmentUploadManifest {
fn record(&mut self, event: &SegmentCompletedEvent) {
match (event.is_init, event.media_type) {
(true, SegmentMediaType::Video) => self.video_init_uploaded = true,
(true, SegmentMediaType::Audio) => self.audio_init_uploaded = true,
(false, media_type) => {
let segments = match media_type {
SegmentMediaType::Video => &mut self.video_segments,
SegmentMediaType::Audio => &mut self.audio_segments,
};
if let Some(segment) = segments
.iter_mut()
.find(|segment| segment.index == event.index)
{
segment.duration = event.duration;
} else {
segments.push(SegmentManifestEntry {
index: event.index,
duration: event.duration,
});
segments.sort_unstable_by_key(|segment| segment.index);
}
}
}
}
fn has_video_content(&self) -> bool {
self.video_init_uploaded && !self.video_segments.is_empty()
}
}
// Only the share page's early playback reads this; the complete manifest stays
// the source of truth for everything else.
const RECORDED_LENGTH_SUBPATH: &str = "segments/recording.json";
const RECORDED_LENGTH_TIMEOUT: Duration = Duration::from_secs(10);
fn recorded_length_json(manifest: &SegmentUploadManifest) -> Option<Vec<u8>> {
let duration: f64 = manifest
.video_segments
.iter()
.map(|segment| segment.duration)
.sum();
if manifest.video_segments.is_empty() || !duration.is_finite() || duration <= 0.0 {
return None;
}
serde_json::to_vec(&json!({
"version": 1,
"duration": duration,
"video_segments": manifest.video_segments.len(),
"audio_segments": manifest.audio_segments.len(),
}))
.ok()
}
async fn publish_recorded_length(video_id: String, bytes: Vec<u8>, cancel: Arc<AtomicBool>) {
match tokio::time::timeout(
RECORDED_LENGTH_TIMEOUT,
presigned_put_bytes_inner(&video_id, RECORDED_LENGTH_SUBPATH, bytes, Some(&cancel)),
)
.await
{
Ok(Ok(())) => {}
Ok(Err(error)) => tracing::debug!(%error, "Recorded length upload failed"),
Err(_) => tracing::debug!("Recorded length upload timed out"),
}
}
async fn alongside<T>(main: impl Future<Output = T>, side: impl Future<Output = ()>) -> T {
let main = std::pin::pin!(main);
let side = std::pin::pin!(side);
match futures_util::future::select(main, side).await {
futures_util::future::Either::Left((output, _)) => output,
futures_util::future::Either::Right(((), main)) => main.await,
}
}
pub async fn prepare_instant_upload(
camera_only: bool,
project_name: String,
organization_id: Option<String>,
) -> Result<VideoUploadInfo, String> {
if store_auth_missing() {
return Err("Please sign in to use instant recording".to_string());
}
let recording_mode = if camera_only {
"desktopMP4"
} else {
"desktopSegments"
};
let config = create_or_get_video_with_mode(
false,
None,
Some(project_name),
None,
organization_id,
recording_mode,
)
.await
.map_err(|error| match error {
AuthApiError::InvalidAuthentication => {
"Your session has expired. Please sign in again to use instant recording.".to_string()
}
AuthApiError::UpgradeRequired => "Instant recording requires an upgraded plan.".to_string(),
error => format!("Could not create the shareable link: {error}"),
})?;
Ok(VideoUploadInfo {
id: config.id.clone(),
link: format!("{}/s/{}", auth::server_url(), config.id),
config,
})
}
pub(crate) fn start_instant_upload(
video: VideoUploadInfo,
project_path: PathBuf,
segment_rx: Option<std::sync::mpsc::Receiver<SegmentCompletedEvent>>,
metadata_lock: Arc<Mutex<()>>,
authorization: Option<CompletionAuthorization>,
) -> Result<InstantUpload, String> {
let ownership = cap_recording::upload_resume::UploadLock::acquire(&project_path)
.map_err(|error| error.to_string())?;
let state =
queue::read_state(&project_path)?.ok_or("The recording has no saved upload identity")?;
let request_context = state.request_context()?;
start_instant_upload_with_ownership(
video,
project_path,
segment_rx,
metadata_lock,
authorization,
ownership,
state.attempt_count(),
Some(request_context),
)
}
#[allow(clippy::too_many_arguments)]
fn start_instant_upload_with_ownership(
video: VideoUploadInfo,
project_path: PathBuf,
segment_rx: Option<std::sync::mpsc::Receiver<SegmentCompletedEvent>>,
metadata_lock: Arc<Mutex<()>>,
authorization: Option<CompletionAuthorization>,
ownership: cap_recording::upload_resume::UploadLock,
prior_attempts: u32,
request_context: Option<auth::UploadRequestContext>,
) -> Result<InstantUpload, String> {
let (completion_permit, required, completion_control) = match authorization {
Some(authorization) => (
Some(authorization.permit),
Some(authorization.required),
Some(authorization.control),
),
None => (None, None, None),
};
let cancel = completion_control.as_ref().map_or_else(
|| Arc::new(AtomicBool::new(false)),
|control| control.cancel.clone(),
);
let reads = Arc::new(UploadReads::default());
let mut bridge = None;
let segment_upload = if let Some(segment_rx) = segment_rx {
let (events_tx, events_rx) = flume::unbounded();
let bridge_cancel = cancel.clone();
bridge = Some(
std::thread::Builder::new()
.name("gpui-instant-segments".to_string())
.stack_size(crate::MEDIA_THREAD_STACK_SIZE)
.spawn(move || {
while !bridge_cancel.load(Ordering::Acquire) && !events_tx.is_disconnected() {
match segment_rx.recv_timeout(Duration::from_millis(20)) {
Ok(event) => {
if events_tx.send(event).is_err() {
break;
}
}
Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break,
}
}
})
.map_err(|error| format!("Failed to start instant upload: {error}"))?,
);
let upload_video = video.clone();
let upload_cancel = cancel.clone();
let upload_metadata_lock = metadata_lock.clone();
let context = request_context.clone();
let upload_reads = reads.clone();
Some(tokio::spawn(with_upload_context(
context,
upload_reads,
async move {
run_segment_upload(
upload_video,
project_path,
events_rx,
upload_cancel,
upload_metadata_lock,
required,
)
.await
},
)))
} else {
None
};
Ok(InstantUpload {
video,
segment_upload,
cancel,
metadata_lock,
completion_permit,
completion_control,
bridge,
ownership: Some(ownership),
prior_attempts,
request_context,
reads,
})
}
impl InstantUpload {
pub fn video(&self) -> &VideoUploadInfo {
&self.video
}
pub(crate) fn metadata_lock(&self) -> &Mutex<()> {
&self.metadata_lock
}
#[cfg(test)]
pub(crate) fn cancellation_token(&self) -> Arc<AtomicBool> {
self.cancel.clone()
}
#[cfg(target_os = "linux")]
pub(crate) fn completion_control(&self) -> Option<CompletionControl> {
self.completion_control.clone()
}
pub(crate) fn authorize_completion(&mut self) -> Result<(), String> {
if self.cancel.load(Ordering::Acquire) {
return Err("Cancelled Instant recording cannot complete".into());
}
if let Some(permit) = self.completion_permit.take() {
permit
.send(())
.map_err(|_| "Instant completion authorization was lost".to_string())?;
}
Ok(())
}
fn authorize_manifest(&mut self, expected: SegmentUploadManifest) -> Result<(), String> {
let control = self
.completion_control
.as_ref()
.ok_or("Upload has no completion guard")?;
*control
.expected_manifest
.lock()
.unwrap_or_else(|error| error.into_inner()) = Some(expected);
self.authorize_completion()
}
pub async fn finish_segments(&mut self) -> Result<(), String> {
check_segment_cancelled(&self.cancel)?;
let Some(upload) = self.segment_upload.as_mut() else {
return Ok(());
};
let result = upload
.await
.map_err(|error| format!("Instant segment upload task failed: {error}"));
drop(self.segment_upload.take());
self.join_bridge()?;
check_segment_cancelled(&self.cancel)?;
result?
}
fn join_bridge(&mut self) -> Result<(), String> {
if let Some(bridge) = self.bridge.take() {
bridge
.join()
.map_err(|_| "Instant upload event bridge failed".to_string())?;
}
Ok(())
}
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 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> {
self.abort_segments().await;
if let Some(ownership) = &self.ownership {
queue::record_cancelled(ownership.project_path())?;
}
with_upload_context(
self.request_context.clone(),
self.reads.clone(),
delete_instant_video_with_query(&self.video.id, query),
)
.await
}
pub(crate) async fn abort_segments(&mut self) {
if let Some(control) = &self.completion_control {
control.deny();
}
drop(self.completion_permit.take());
self.cancel.store(true, Ordering::Release);
if let Some(upload) = self.segment_upload.take() {
upload.abort();
let _ = upload.await;
}
if let Err(error) = self.join_bridge() {
tracing::warn!(%error, "Instant upload bridge cleanup failed");
}
self.reads.join().await;
}
}
pub(crate) async fn delete_instant_video_with_query(
video_id: &str,
query: Option<&str>,
) -> Result<(), String> {
let mut path = format!(
"/api/desktop/video/delete?videoId={}",
urlencoding(video_id)
);
if let Some(query) = query {
path.push('&');
path.push_str(query);
}
let response = auth::authed_request(reqwest::Method::DELETE, &path, None)
.await
.map_err(|error| format!("Failed to delete instant recording: {error}"))?;
let status = response.status();
if status.is_success() || status == StatusCode::NOT_FOUND {
return Ok(());
}
Err(format!(
"Failed to delete instant recording {video_id}: {status}"
))
}
async fn run_segment_upload(
video: VideoUploadInfo,
project_path: PathBuf,
events: flume::Receiver<SegmentCompletedEvent>,
cancel: Arc<AtomicBool>,
metadata_lock: Arc<Mutex<()>>,
authorization: Option<CompletionRequirement>,
) -> Result<(), String> {
let result = upload_segments(
&LiveSegmentTransport::default(),
&video.id,
events,
cancel.clone(),
authorization,
)
.await;
if let Err(error) = &result
&& !cancel.load(Ordering::Acquire)
&& let Err(save_error) =
crate::recording::persist_instant_upload_failure(&project_path, error, &metadata_lock)
{
tracing::error!("Failed to persist instant upload failure: {save_error}");
}
result
}
#[derive(Debug)]
enum SegmentUploadError {
Fatal(String),
Retryable {
event: SegmentCompletedEvent,
error: String,
},
}
impl From<String> for SegmentUploadError {
fn from(error: String) -> Self {
Self::Fatal(error)
}
}
fn segment_error_is_retryable(error: &AuthApiError) -> bool {
match error {
AuthApiError::InvalidAuthentication | AuthApiError::UpgradeRequired => false,
AuthApiError::Status(status, _) => {
!status.is_client_error()
|| matches!(
*status,
StatusCode::REQUEST_TIMEOUT | StatusCode::TOO_MANY_REQUESTS
)
}
AuthApiError::Timeout | AuthApiError::Other(_) => true,
}
}
fn exhausted_segment_error(
event: SegmentCompletedEvent,
error: AuthApiError,
) -> SegmentUploadError {
let message = format!(
"Failed to upload instant segment {}: {error}",
segment_subpath(&event)
);
if segment_error_is_retryable(&error) {
SegmentUploadError::Retryable {
event,
error: message,
}
} else {
SegmentUploadError::Fatal(message)
}
}
fn segment_retry_backoff(round: u32) -> Duration {
SEGMENT_RETRY_MIN_DELAY
.saturating_mul(1 << round.min(8))
.min(SEGMENT_RETRY_MAX_DELAY)
}
trait SegmentTransport: Send + Sync {
fn prepare(
&self,
_video_id: &str,
_segments: Vec<Segment>,
) -> impl Future<Output = Result<Option<Vec<Segment>>, String>> + Send {
std::future::ready(Ok(None))
}
fn prefetch(
&self,
video_id: &str,
start: u32,
count: u32,
) -> impl Future<Output = Result<HashMap<String, String>, String>> + Send;
fn segment(
&self,
video_id: String,
event: SegmentCompletedEvent,
signed_urls: Arc<Mutex<HashMap<String, String>>>,
cancel: Arc<AtomicBool>,
) -> impl Future<Output = Result<SegmentCompletedEvent, SegmentUploadError>> + Send;
fn manifest(
&self,
video_id: &str,
manifest: &SegmentUploadManifest,
cancel: &Arc<AtomicBool>,
) -> impl Future<Output = Result<(), String>> + Send;
fn complete(
&self,
video_id: &str,
cancel: &Arc<AtomicBool>,
) -> impl Future<Output = Result<(), String>> + Send;
}
struct ReusableUploadTarget {
target: SignedUploadTarget,
signed_at: tokio::time::Instant,
}
impl ReusableUploadTarget {
fn new(target: SignedUploadTarget, signed_at: tokio::time::Instant) -> Option<Self> {
(!is_google_drive_resumable_url(&target.url)).then_some(Self { target, signed_at })
}
fn is_fresh(&self) -> bool {
self.signed_at.elapsed() < MANIFEST_URL_REUSE
}
}
#[derive(Default)]
struct LiveSegmentTransport {
manifest_target: Mutex<Option<ReusableUploadTarget>>,
}
impl LiveSegmentTransport {
fn reusable_manifest_target(&self) -> Option<ReusableUploadTarget> {
self.manifest_target
.lock()
.unwrap_or_else(|error| error.into_inner())
.take()
.filter(ReusableUploadTarget::is_fresh)
}
fn keep_manifest_target(&self, target: Option<ReusableUploadTarget>) {
*self
.manifest_target
.lock()
.unwrap_or_else(|error| error.into_inner()) = target;
}
}
impl SegmentTransport for LiveSegmentTransport {
async fn prepare(
&self,
video_id: &str,
segments: Vec<Segment>,
) -> Result<Option<Vec<Segment>>, String> {
tokio::time::timeout(Duration::from_secs(20), async {
#[derive(Deserialize)]
struct Response {
version: u32,
prepared: Vec<Segment>,
}
let response = auth::authed_request(
reqwest::Method::POST,
"/api/recording/prepare",
Some(json!({ "videoId": video_id, "segments": segments })),
)
.await
.map_err(|error| error.to_string())?;
let status = response.status();
if status == StatusCode::NOT_FOUND || status == StatusCode::METHOD_NOT_ALLOWED {
return Ok(None);
}
if !status.is_success() {
return Err(format!("Recording preparation returned {status}"));
}
let response = response
.json::<Response>()
.await
.map_err(|error| error.to_string())?;
Ok((response.version == 1 && response.prepared.len() <= 32)
.then_some(response.prepared))
})
.await
.map_err(|error| error.to_string())?
}
async fn prefetch(
&self,
video_id: &str,
start: u32,
count: u32,
) -> Result<HashMap<String, String>, String> {
let signed_at = tokio::time::Instant::now();
let mut urls = prefetch_segment_urls(video_id, start, count)
.await
.map_err(|error| error.to_string())?;
if let Some(url) = urls.remove(MANIFEST_SUBPATH) {
self.keep_manifest_target(ReusableUploadTarget::new(
SignedUploadTarget {
url,
headers: HashMap::new(),
},
signed_at,
));
}
Ok(urls)
}
async fn segment(
&self,
video_id: String,
event: SegmentCompletedEvent,
signed_urls: Arc<Mutex<HashMap<String, String>>>,
cancel: Arc<AtomicBool>,
) -> Result<SegmentCompletedEvent, SegmentUploadError> {
upload_segment_with_retry(video_id, event, signed_urls, cancel).await
}
async fn manifest(
&self,
video_id: &str,
manifest: &SegmentUploadManifest,
cancel: &Arc<AtomicBool>,
) -> Result<(), String> {
upload_segment_manifest_with_retry(self, video_id, manifest, cancel).await
}
async fn complete(&self, video_id: &str, cancel: &Arc<AtomicBool>) -> Result<(), String> {
signal_recording_complete_with_retry(video_id, cancel).await
}
}
async fn upload_segments(
transport: &impl SegmentTransport,
video_id: &str,
events: flume::Receiver<SegmentCompletedEvent>,
cancel: Arc<AtomicBool>,
mut authorization: Option<CompletionRequirement>,
) -> Result<(), String> {
let mut authorized = authorization.is_none();
let mut manifest = SegmentUploadManifest::default();
let mut uploads = FuturesUnordered::new();
let mut events_closed = false;
let mut last_manifest_upload: Option<tokio::time::Instant> = None;
let mut preparation = Preparation::default();
let mut preparation_enabled = true;
let mut preparation_batch = Vec::new();
let mut preparation_interval = tokio::time::interval(Duration::from_secs(30));
preparation_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut preparation_request = None;
let mut next_preparation_request = tokio::time::Instant::now();
let mut next_prefetch = SEGMENT_URL_PREFETCH + 1;
let mut deferred = VecDeque::new();
let mut first_failures: HashMap<String, (tokio::time::Instant, String)> = HashMap::new();
let mut retry_round = 0u32;
let mut retry_at = tokio::time::Instant::now();
let prefetched = checked_segment_step(&cancel, || async {
Ok(transport.prefetch(video_id, 1, SEGMENT_URL_PREFETCH).await)
})
.await?;
let signed_urls = Arc::new(Mutex::new(prefetched.unwrap_or_else(|error| {
tracing::warn!("Failed to prefetch instant upload URLs: {error}");
HashMap::new()
})));
loop {
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".into());
}
if events_closed && uploads.is_empty() && deferred.is_empty() && authorized {
break;
}
let retry_deadline = first_failures
.values()
.map(|(first_failure, _)| *first_failure + SEGMENT_RETRY_WINDOW)
.min();
let guarded = authorization.is_some();
let (permission, denial) = match authorization.as_mut() {
Some(required) => (Some(&mut required.permission), Some(&mut required.denied)),
None => (None, None),
};
tokio::select! {
_ = preparation_interval.tick(), if preparation_enabled && preparation_request.is_none() => {
if tokio::time::Instant::now() < next_preparation_request { continue; }
preparation_batch = preparation.next_batch(manifest.video_segments.iter().map(|segment| segment.index), manifest.audio_segments.iter().map(|segment| segment.index));
if !preparation_batch.is_empty() {
preparation_request = Some(Box::pin(transport.prepare(video_id, preparation_batch.clone())));
}
}
response = async { preparation_request.as_mut().unwrap().await }, if preparation_request.is_some() => {
preparation_request = None;
match response {
Ok(Some(prepared)) => preparation.acknowledge(&preparation_batch, &prepared),
Ok(None) => preparation_enabled = false,
Err(error) => {
preparation.request_failed();
tracing::debug!(%error, "Optional recording preparation unavailable");
}
}
next_preparation_request = tokio::time::Instant::now() + preparation.retry_delay();
}
permission = async { permission.unwrap().await }, if !authorized => {
permission.map_err(|_| "Instant completion was not authorized".to_string())?;
authorized = true;
}
_ = async {
let denial = denial.unwrap();
let denied = *denial.borrow_and_update();
if !denied { let _ = denial.changed().await; }
}, if guarded => {
return Err("Instant completion authorization was revoked".into());
}
next_event = events.recv_async(), if !events_closed && uploads.len() < MAX_SEGMENT_UPLOADS => {
match next_event {
Ok(event) => {
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".to_string());
}
if event.media_type == SegmentMediaType::Video
&& event.index.saturating_add(5) >= next_prefetch
{
match checked_segment_step(&cancel, || async {
Ok(transport.prefetch(video_id, next_prefetch, SEGMENT_URL_PREFETCH).await)
}).await? {
Ok(urls) => {
signed_urls.lock().unwrap_or_else(|error| error.into_inner()).extend(urls);
next_prefetch = next_prefetch.saturating_add(SEGMENT_URL_PREFETCH);
}
Err(error) => tracing::warn!("Failed to extend instant upload URLs: {error}"),
}
}
uploads.push(transport.segment(
video_id.to_string(),
event,
signed_urls.clone(),
cancel.clone(),
));
}
Err(_) => events_closed = true,
}
}
_ = async { tokio::time::sleep_until(retry_deadline.unwrap()).await }, if retry_deadline.is_some() => {
let error = first_failures
.values()
.min_by_key(|(first_failure, _)| *first_failure)
.map(|(_, error)| error.clone())
.unwrap_or_default();
return Err(error);
}
_ = tokio::time::sleep_until(retry_at), if !deferred.is_empty() && uploads.len() < MAX_SEGMENT_UPLOADS => {
while uploads.len() < MAX_SEGMENT_UPLOADS {
let Some(event) = deferred.pop_front() else { break };
uploads.push(transport.segment(
video_id.to_string(),
event,
signed_urls.clone(),
cancel.clone(),
));
}
}
Some(upload) = uploads.next(), if !uploads.is_empty() => {
check_segment_cancelled(&cancel)?;
let event = match upload {
Ok(event) => event,
Err(SegmentUploadError::Fatal(error)) => return Err(error),
Err(SegmentUploadError::Retryable { event, error }) => {
let now = tokio::time::Instant::now();
let (first_failure, last_error) = first_failures
.entry(segment_subpath(&event))
.or_insert_with(|| (now, String::new()));
if now.duration_since(*first_failure) >= SEGMENT_RETRY_WINDOW {
return Err(error);
}
last_error.clone_from(&error);
if retry_at <= now {
retry_at = now + segment_retry_backoff(retry_round);
retry_round = retry_round.saturating_add(1);
}
tracing::warn!(deferred = deferred.len() + 1, "Instant segment upload deferred for retry: {error}");
deferred.push_back(event);
continue;
}
};
if !first_failures.is_empty() {
first_failures.remove(&segment_subpath(&event));
retry_round = 0;
retry_at = tokio::time::Instant::now();
}
manifest.record(&event);
if manifest.has_video_content()
&& last_manifest_upload.is_none_or(|last| last.elapsed() >= MANIFEST_UPLOAD_INTERVAL)
{
check_segment_cancelled(&cancel)?;
let uploaded = transport.manifest(video_id, &manifest, &cancel).await;
check_segment_cancelled(&cancel)?;
if let Err(error) = uploaded {
tracing::warn!("Instant progress manifest upload failed; retrying at the next interval: {error}");
}
last_manifest_upload = Some(tokio::time::Instant::now());
}
}
else => break,
}
}
drop(preparation_request);
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".to_string());
}
if !manifest.has_video_content() {
return Err(format!(
"Segment upload completed without video segments for {video_id}"
));
}
manifest.is_complete = true;
let expected = authorization.as_ref().and_then(|required| {
required
.expected_manifest
.lock()
.unwrap_or_else(|error| error.into_inner())
.clone()
});
if expected
.as_ref()
.is_some_and(|expected| expected != &manifest)
{
return Err("Uploaded segments do not match the complete local recording".into());
}
checked_segment_step(&cancel, || transport.manifest(video_id, &manifest, &cancel)).await?;
if expected.is_some() {
return Ok(());
}
checked_segment_step(&cancel, || transport.complete(video_id, &cancel)).await
}
fn check_segment_cancelled(cancel: &AtomicBool) -> Result<(), String> {
if cancel.load(Ordering::Acquire) {
Err("Instant recording upload cancelled".into())
} else {
Ok(())
}
}
async fn checked_segment_step<T, F>(
cancel: &AtomicBool,
step: impl FnOnce() -> F,
) -> Result<T, String>
where
F: Future<Output = Result<T, String>>,
{
check_segment_cancelled(cancel)?;
let result = step().await;
check_segment_cancelled(cancel)?;
result
}
async fn segment_retry_delay(cancel: &AtomicBool, delay: Duration) -> Result<(), String> {
checked_segment_step(cancel, || async {
tokio::time::sleep(delay).await;
Ok(())
})
.await
}
fn prefetched_segment_paths(start: u32, count: u32) -> Vec<String> {
let mut subpaths = Vec::with_capacity((count as usize).saturating_mul(2).saturating_add(3));
if start == 1 {
subpaths.push("segments/video/init.mp4".to_string());
subpaths.push("segments/audio/init.mp4".to_string());
subpaths.push(MANIFEST_SUBPATH.to_string());
}
for index in start..start.saturating_add(count) {
subpaths.push(format!("segments/video/segment_{index:03}.m4s"));
subpaths.push(format!("segments/audio/segment_{index:03}.m4s"));
}
subpaths
}
async fn prefetch_segment_urls(
video_id: &str,
start: u32,
count: u32,
) -> Result<HashMap<String, String>, AuthApiError> {
#[derive(Deserialize)]
struct BatchResponse {
urls: HashMap<String, String>,
}
let response = auth::authed_request(
reqwest::Method::POST,
"/api/upload/signed/batch",
Some(json!({
"videoId": video_id,
"subpaths": prefetched_segment_paths(start, count),
})),
)
.await?;
let status = response.status();
if !status.is_success() {
return Err(AuthApiError::Other(format!(
"api/upload_signed_batch/{status}"
)));
}
response
.json::<BatchResponse>()
.await
.map(|batch| batch.urls)
.map_err(|error| AuthApiError::Other(format!("api/upload_signed_batch/response: {error}")))
}
async fn upload_segment_with_retry(
video_id: String,
event: SegmentCompletedEvent,
signed_urls: Arc<Mutex<HashMap<String, String>>>,
cancel: Arc<AtomicBool>,
) -> Result<SegmentCompletedEvent, SegmentUploadError> {
let subpath = segment_subpath(&event);
let bytes = read_completed_segment(&event, &subpath, &cancel).await?;
let mut cached_url = signed_urls
.lock()
.unwrap_or_else(|error| error.into_inner())
.remove(&subpath);
for attempt in 0..SEGMENT_UPLOAD_ATTEMPTS {
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".to_string().into());
}
if attempt > 0 {
segment_retry_delay(&cancel, Duration::from_millis(250u64 << attempt)).await?;
}
let result = if let Some(url) = cached_url.take() {
upload_signed_bytes_inner(
SignedUploadTarget {
url,
headers: HashMap::new(),
},
&subpath,
bytes.clone(),
Some(&cancel),
)
.await
} else {
presigned_put_bytes_inner(&video_id, &subpath, bytes.clone(), Some(&cancel)).await
};
check_segment_cancelled(&cancel)?;
match result {
Ok(()) => return Ok(event),
Err(AuthApiError::InvalidAuthentication) => {
return Err(SegmentUploadError::Fatal(
"Authentication expired while uploading the instant recording".into(),
));
}
Err(error) if attempt + 1 == SEGMENT_UPLOAD_ATTEMPTS => {
return Err(exhausted_segment_error(event, error));
}
Err(error) => tracing::warn!(
subpath,
attempt = attempt + 1,
"Instant recording segment upload failed; retrying: {error}"
),
}
}
Err(SegmentUploadError::Fatal(format!(
"Failed to upload instant segment {subpath}"
)))
}
async fn read_completed_segment(
event: &SegmentCompletedEvent,
subpath: &str,
cancel: &AtomicBool,
) -> Result<Vec<u8>, String> {
if event.file_size == 0 {
return Err(format!(
"Instant recording segment has no completed byte count: {subpath}"
));
}
let started = Instant::now();
loop {
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".to_string());
}
let bytes = tracked_upload_read({
let path = event.path.clone();
move || std::fs::read(path)
})
.await
.map_err(|error| format!("Failed to read instant segment {subpath}: {error}"))?;
match bytes {
Ok(bytes) if !bytes.is_empty() && bytes.len() as u64 == event.file_size => {
return Ok(bytes);
}
Ok(_) if started.elapsed() >= Duration::from_secs(10) => {
return Err(format!(
"Instant recording segment is incomplete: {subpath}"
));
}
Err(error) if started.elapsed() >= Duration::from_secs(10) => {
return Err(format!("Failed to read instant segment {subpath}: {error}"));
}
_ => tokio::time::sleep(Duration::from_millis(50)).await,
}
}
}
fn segment_subpath(event: &SegmentCompletedEvent) -> String {
match (event.is_init, event.media_type) {
(true, SegmentMediaType::Video) => "segments/video/init.mp4".to_string(),
(true, SegmentMediaType::Audio) => "segments/audio/init.mp4".to_string(),
(false, SegmentMediaType::Video) => {
format!("segments/video/segment_{:03}.m4s", event.index)
}
(false, SegmentMediaType::Audio) => {
format!("segments/audio/segment_{:03}.m4s", event.index)
}
}
}
async fn upload_segment_manifest(
transport: &LiveSegmentTransport,
video_id: &str,
manifest: &SegmentUploadManifest,
cancel: &AtomicBool,
) -> Result<(), String> {
let bytes = serde_json::to_vec(manifest)
.map_err(|error| format!("Failed to serialize instant upload manifest: {error}"))?;
if let Some(reusable) = transport.reusable_manifest_target() {
match upload_signed_bytes_inner(
reusable.target.clone(),
MANIFEST_SUBPATH,
bytes.clone(),
Some(cancel),
)
.await
{
Ok(()) => {
transport.keep_manifest_target(Some(reusable));
return Ok(());
}
Err(error @ AuthApiError::Status(..)) => {
check_segment_cancelled(cancel)?;
tracing::debug!(
"Reused instant manifest URL was rejected; signing a new one: {error}"
);
}
Err(error) => {
return Err(format!(
"Failed to upload instant recording manifest: {error}"
));
}
}
}
let signed_at = tokio::time::Instant::now();
let target = presign_put_target(video_id, MANIFEST_SUBPATH, Some(cancel))
.await
.map_err(|error| format!("Failed to upload instant recording manifest: {error}"))?;
let reusable = ReusableUploadTarget::new(target.clone(), signed_at);
upload_signed_bytes_inner(target, MANIFEST_SUBPATH, bytes, Some(cancel))
.await
.map_err(|error| format!("Failed to upload instant recording manifest: {error}"))?;
transport.keep_manifest_target(reusable);
Ok(())
}
async fn upload_segment_manifest_with_retry(
transport: &LiveSegmentTransport,
video_id: &str,
manifest: &SegmentUploadManifest,
cancel: &AtomicBool,
) -> Result<(), String> {
for attempt in 0..SEGMENT_UPLOAD_ATTEMPTS {
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".to_string());
}
match checked_segment_step(cancel, || {
upload_segment_manifest(transport, video_id, manifest, cancel)
})
.await
{
Ok(()) => return Ok(()),
Err(error) if attempt + 1 == SEGMENT_UPLOAD_ATTEMPTS => return Err(error),
Err(error) => {
tracing::warn!(
attempt = attempt + 1,
"Instant manifest upload failed: {error}"
);
segment_retry_delay(cancel, Duration::from_millis(250u64 << attempt)).await?;
}
}
}
Err("Instant recording manifest upload failed".to_string())
}
async fn signal_recording_complete_with_retry(
video_id: &str,
cancel: &AtomicBool,
) -> Result<(), String> {
for attempt in 0..SEGMENT_UPLOAD_ATTEMPTS {
if cancel.load(Ordering::Acquire) {
return Err("Instant recording upload cancelled".to_string());
}
match checked_segment_step(cancel, || signal_recording_complete(video_id)).await {
Ok(()) => return Ok(()),
Err(error) if attempt + 1 == SEGMENT_UPLOAD_ATTEMPTS => return Err(error),
Err(error) => {
tracing::warn!(
attempt = attempt + 1,
"Instant completion signal failed: {error}"
);
segment_retry_delay(cancel, Duration::from_millis(250u64 << attempt)).await?;
}
}
}
Err("Failed to finish instant recording upload".to_string())
}
async fn signal_recording_complete(video_id: &str) -> Result<(), String> {
let response = auth::authed_request(
reqwest::Method::POST,
"/api/upload/recording-complete",
Some(json!({ "videoId": video_id })),
)
.await
.map_err(|error| format!("Failed to finish instant recording upload: {error}"))?;
let status = response.status();
if status.is_success() {
return Ok(());
}
Err(format!(
"Failed to finish instant recording upload: {status}"
))
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct UploadedPart {
part_number: u32,
etag: String,
size: usize,
#[serde(skip)]
object_identity: Option<String>,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct VideoMeta {
#[serde(rename = "durationInSecs")]
duration_in_secs: f64,
width: u32,
height: u32,
#[serde(skip_serializing_if = "Option::is_none")]
fps: Option<f32>,
}
fn check_export_cancelled(cancel: &AtomicBool) -> Result<(), AuthApiError> {
if cancel.load(Ordering::Acquire) {
Err(AuthApiError::Other("Export cancelled".into()))
} else {
Ok(())
}
}
async fn checked_upload_step<T, F>(
cancel: &AtomicBool,
step: impl FnOnce() -> F,
) -> Result<T, AuthApiError>
where
F: Future<Output = Result<T, AuthApiError>>,
{
check_export_cancelled(cancel)?;
let result = step().await;
check_export_cancelled(cancel)?;
result
}
pub async fn upload_exported_video(
project_path: PathBuf,
organization_id: Option<String>,
progress: impl Fn(f64),
cancel: std::sync::Arc<AtomicBool>,
) -> Result<UploadResult, String> {
upload_exported_video_inner(project_path, organization_id, progress, cancel, false)
.await
.map(|(result, _)| result)
}
async fn upload_exported_video_inner(
project_path: PathBuf,
organization_id: Option<String>,
progress: impl Fn(f64),
cancel: Arc<AtomicBool>,
defer_completion: bool,
) -> Result<(UploadResult, Option<String>), String> {
check_export_cancelled(&cancel).map_err(|error| error.to_string())?;
if store_auth_missing() {
let _ = crate::store::set_auth(None);
return Ok((UploadResult::NotAuthenticated, None));
}
let mut meta = RecordingMeta::load_for_project(&project_path)
.map_err(|error| format!("Failed to load recording metadata: {error}"))?;
let file_path = meta.output_path();
if !file_path.exists() {
if !defer_completion {
crate::app_sounds::play_notification();
}
return Err("Failed to upload video: Rendered video not found".into());
}
let metadata = build_video_meta(&file_path)?;
if !crate::store::auth_snapshot().is_upgraded() && metadata.duration_in_secs > 300.0 {
return Ok((UploadResult::UpgradeRequired, None));
}
progress(0.0);
if cancel.load(Ordering::Relaxed) {
return Err("Export cancelled".into());
}
// The recording-time thumbnail is best-effort, so regenerate a missing
// `screenshots/display.jpg` from the exported video rather than shipping a
// share with no thumbnail or failing a video that could still be shared.
let screenshot_path = meta.project_path.join("screenshots/display.jpg");
if !screenshot_path.exists()
&& let Err(error) = crate::library::create_screenshot(&file_path, &screenshot_path, None)
{
return Err(format!("Failed to generate thumbnail: {error}"));
}
let video_id = match reusable_video_id(meta.sharing.as_ref(), meta.upload.as_ref()) {
Some(video_id) => video_id,
None => {
let video_id = match checked_upload_step(&cancel, request_video_id).await {
Ok(video_id) => video_id,
Err(AuthApiError::InvalidAuthentication) => {
return Ok((UploadResult::NotAuthenticated, None));
}
Err(AuthApiError::UpgradeRequired) => {
return Ok((UploadResult::UpgradeRequired, None));
}
Err(error) => return Err(error.to_string()),
};
meta.upload = Some(UploadMeta::SinglePartUpload {
video_id: video_id.clone(),
file_path: file_path.clone(),
screenshot_path: screenshot_path.clone(),
recording_dir: project_path.clone(),
});
meta.save_for_project()
.map_err(|error| format!("Failed to persist upload identity: {error}"))?;
video_id
}
};
let s3_config = match checked_upload_step(&cancel, || {
create_or_get_video(
false,
Some(video_id.clone()),
Some(meta.pretty_name.clone()),
Some(&metadata),
organization_id,
)
})
.await
{
Ok(config) => config,
Err(AuthApiError::InvalidAuthentication) => {
return Ok((UploadResult::NotAuthenticated, None));
}
Err(AuthApiError::UpgradeRequired) => return Ok((UploadResult::UpgradeRequired, None)),
Err(error) => return Err(error.to_string()),
};
if s3_config.id != video_id {
return Err("Server did not preserve the reserved upload identity".into());
}
meta.upload = Some(UploadMeta::SinglePartUpload {
video_id: s3_config.id.clone(),
file_path: file_path.clone(),
screenshot_path: screenshot_path.clone(),
recording_dir: project_path.clone(),
});
meta.save_for_project()
.map_err(|error| format!("Failed to persist upload state: {error}"))?;
match checked_upload_step(&cancel, || {
upload_video(
&s3_config.id,
&file_path,
&metadata,
progress,
&cancel,
meta.sharing.is_some(),
)
})
.await
{
Ok((link, object_identity)) => {
let link = meta
.sharing
.as_ref()
.map(|sharing| sharing.link.clone())
.unwrap_or(link);
meta.sharing = Some(SharingMeta {
link: link.clone(),
id: s3_config.id.clone(),
content_hash: None,
});
meta.save_for_project()
.map_err(|error| format!("Failed to persist sharing state: {error}"))?;
if let Err(error) = checked_upload_step(&cancel, || {
upload_screenshot_with_cancel(&s3_config.id, &screenshot_path, &cancel)
})
.await
{
return Err(format!("thumbnail upload failed: {error}"));
}
check_export_cancelled(&cancel).map_err(|error| error.to_string())?;
if !defer_completion {
meta.upload = Some(UploadMeta::Complete);
meta.save_for_project()
.map_err(|error| format!("Failed to persist completed upload: {error}"))?;
}
check_export_cancelled(&cancel).map_err(|error| error.to_string())?;
Ok((UploadResult::Success(link), object_identity))
}
Err(AuthApiError::UpgradeRequired) => Ok((UploadResult::UpgradeRequired, None)),
Err(AuthApiError::InvalidAuthentication) => Ok((UploadResult::NotAuthenticated, None)),
Err(error) => {
if !defer_completion && !cancel.load(Ordering::Relaxed) {
crate::app_sounds::play_notification();
}
Err(error.to_string())
}
}
}
fn reusable_video_id(sharing: Option<&SharingMeta>, upload: Option<&UploadMeta>) -> Option<String> {
sharing
.map(|sharing| sharing.id.clone())
.or_else(|| match upload {
Some(UploadMeta::SinglePartUpload { video_id, .. })
| Some(UploadMeta::SegmentUpload { video_id, .. })
| Some(UploadMeta::MultipartUpload { video_id, .. }) => Some(video_id.clone()),
_ => None,
})
}
fn store_auth_missing() -> bool {
!crate::store::auth_snapshot().signed_in()
}
async fn request_video_id() -> Result<String, AuthApiError> {
let response =
auth::authed_request(reqwest::Method::GET, "/api/desktop/video/new-id", None).await?;
if response.status() != StatusCode::OK {
let status = response.status();
return Err(AuthApiError::Other(format!(
"request_video_id/error/{status}"
)));
}
let text = response
.text()
.await
.map_err(|error| AuthApiError::Other(format!("Failed to read response body: {error}")))?;
let config = serde_json::from_str::<S3UploadMeta>(&text)
.map_err(|_| AuthApiError::Other("Invalid reserved video ID response".into()))?;
Ok(config.id)
}
/// `create_or_get_video` (`src-tauri/upload.rs:340-436`): passing an existing
/// `video_id` re-uses that server record (which is what keeps a share link
/// stable across re-uploads), and `is_screenshot` marks the record the way the
/// screenshot share flow needs (`isScreenshot=true` on the create URL).
async fn create_or_get_video(
is_screenshot: bool,
video_id: Option<String>,
name: Option<String>,
meta: Option<&VideoMeta>,
organization_id: Option<String>,
) -> Result<S3UploadMeta, AuthApiError> {
create_or_get_video_with_mode(
is_screenshot,
video_id,
name,
meta,
organization_id,
"desktopMP4",
)
.await
}
async fn create_or_get_video_with_mode(
is_screenshot: bool,
video_id: Option<String>,
name: Option<String>,
meta: Option<&VideoMeta>,
organization_id: Option<String>,
recording_mode: &str,
) -> Result<S3UploadMeta, AuthApiError> {
let mut path = format!(
"/api/desktop/video/create?recordingMode={}",
urlencoding(recording_mode)
);
if let Some(id) = video_id {
path.push_str(&format!("&videoId={id}"));
path.push_str("&createWithId=true");
}
if is_screenshot {
path.push_str("&isScreenshot=true");
}
if let Some(name) = name {
path.push_str(&format!("&name={}", urlencoding(&name)));
}
if let Some(meta) = meta {
path.push_str(&format!("&durationInSecs={}", meta.duration_in_secs));
path.push_str(&format!("&width={}", meta.width));
path.push_str(&format!("&height={}", meta.height));
if let Some(fps) = meta.fps {
path.push_str(&format!("&fps={fps}"));
}
}
if let Some(org_id) = organization_id {
path.push_str(&format!("&orgId={org_id}"));
}
let response = auth::authed_request(reqwest::Method::GET, &path, None).await?;
if response.status() != StatusCode::OK {
let status = response.status();
let body = response.text().await.unwrap_or_default();
if status == StatusCode::FORBIDDEN && body.contains("upgrade_required") {
return Err(AuthApiError::UpgradeRequired);
}
return Err(AuthApiError::Other(format!(
"create_or_get_video/error/{status}"
)));
}
let text = response
.text()
.await
.map_err(|error| AuthApiError::Other(format!("Failed to read response body: {error}")))?;
serde_json::from_str::<S3UploadMeta>(&text)
.map_err(|_| AuthApiError::Other("Invalid video creation response".into()))
}
#[derive(Debug)]
enum ReplacementUploadAttempt<T, S = ()> {
Completed(T),
RestartRequired(S),
}
async fn retry_replacement_upload<T, S, F, Fut>(
replace_existing: bool,
cancel: &AtomicBool,
mut state: S,
mut attempt: F,
) -> Result<T, AuthApiError>
where
F: FnMut(S) -> Fut,
Fut: Future<Output = Result<ReplacementUploadAttempt<T, S>, AuthApiError>>,
{
for attempt_index in 0..2 {
match checked_upload_step(cancel, || attempt(state)).await? {
ReplacementUploadAttempt::Completed(value) => return Ok(value),
ReplacementUploadAttempt::RestartRequired(next)
if replace_existing && attempt_index == 0 =>
{
// Aborting a legacy Drive session can delete the published mapping.
state = next;
}
ReplacementUploadAttempt::RestartRequired(_) => break,
}
}
Err(replacement_restart_error())
}
fn replacement_restart_error() -> AuthApiError {
AuthApiError::Other("api/upload_multipart_complete/409/REPLACEMENT_RESTART_REQUIRED".into())
}
fn is_legacy_replacement_upload(replace_existing: bool, upload_id: &str) -> bool {
replace_existing && !upload_id.starts_with("cap-reupload.")
}
fn validate_replacement_restart_session(
restarted: bool,
upload_id: &str,
) -> Result<(), AuthApiError> {
if restarted && !upload_id.starts_with("cap-reupload.") {
return Err(replacement_restart_error());
}
Ok(())
}
#[derive(Debug, PartialEq, Eq)]
struct ReplacementUploadFile {
path: PathBuf,
size: u64,
modified: std::time::SystemTime,
}
impl ReplacementUploadFile {
fn read(path: &Path) -> Result<Self, AuthApiError> {
let metadata = std::fs::symlink_metadata(path).map_err(|error| {
AuthApiError::Other(format!("Failed to inspect replacement export: {error}"))
})?;
if !metadata.file_type().is_file() || metadata.len() == 0 {
return Err(replacement_source_changed());
}
Ok(Self {
path: path.canonicalize().map_err(|error| {
AuthApiError::Other(format!("Failed to resolve replacement export: {error}"))
})?,
size: metadata.len(),
modified: metadata.modified().map_err(|error| {
AuthApiError::Other(format!(
"Failed to inspect replacement export time: {error}"
))
})?,
})
}
}
#[derive(Debug, PartialEq, Eq)]
struct ReplacementUploadChunk {
offset: u64,
size: usize,
md5: String,
}
#[derive(Debug)]
struct ReplacementUploadSource {
file: ReplacementUploadFile,
chunks: Vec<ReplacementUploadChunk>,
sealed: bool,
}
fn replacement_source_changed() -> AuthApiError {
AuthApiError::Other("Rendered video changed during replacement upload".into())
}
impl ReplacementUploadSource {
fn new(path: &Path) -> Result<Self, AuthApiError> {
Ok(Self {
file: ReplacementUploadFile::read(path)?,
chunks: Vec::new(),
sealed: false,
})
}
fn validate_file(&self, path: &Path) -> Result<(), AuthApiError> {
if ReplacementUploadFile::read(path)? != self.file {
return Err(replacement_source_changed());
}
Ok(())
}
fn check_chunk(
&mut self,
part_number: u32,
offset: u64,
bytes: &[u8],
file_size: u64,
) -> Result<(), AuthApiError> {
let index = usize::try_from(part_number)
.ok()
.and_then(|part| part.checked_sub(1))
.ok_or_else(replacement_source_changed)?;
if file_size != self.file.size || bytes.is_empty() {
return Err(replacement_source_changed());
}
let chunk = ReplacementUploadChunk {
offset,
size: bytes.len(),
md5: md5_base64(bytes),
};
if self.sealed {
if self.chunks.get(index) != Some(&chunk) {
return Err(replacement_source_changed());
}
} else {
let expected_offset = self
.chunks
.last()
.map(|previous| previous.offset.saturating_add(previous.size as u64))
.unwrap_or(0);
if index != self.chunks.len() || offset != expected_offset {
return Err(replacement_source_changed());
}
self.chunks.push(chunk);
}
Ok(())
}
fn seal_parts(&mut self, parts: &[UploadedPart]) -> Result<(), AuthApiError> {
if parts.len() != self.chunks.len() || parts.is_empty() {
return Err(replacement_source_changed());
}
let mut size = 0u64;
for (index, (part, chunk)) in parts.iter().zip(&self.chunks).enumerate() {
if usize::try_from(part.part_number).ok() != Some(index + 1)
|| part.size != chunk.size
|| chunk.offset != size
{
return Err(replacement_source_changed());
}
size = size
.checked_add(chunk.size as u64)
.ok_or_else(replacement_source_changed)?;
}
if size != self.file.size {
return Err(replacement_source_changed());
}
self.sealed = true;
Ok(())
}
}
async fn upload_video(
video_id: &str,
file_path: &Path,
metadata: &VideoMeta,
progress: impl Fn(f64),
cancel: &AtomicBool,
replace_existing: bool,
) -> Result<(String, Option<String>), AuthApiError> {
let progress = &progress;
let result = retry_replacement_upload(
replace_existing,
cancel,
None,
|mut source: Option<ReplacementUploadSource>| async move {
if let Some(source) = &source {
source.validate_file(file_path)?;
}
let initiate =
checked_upload_step(cancel, || multipart_initiate(video_id, replace_existing))
.await?;
validate_replacement_restart_session(source.is_some(), &initiate.upload_id)?;
if source.is_none()
&& is_legacy_replacement_upload(replace_existing, &initiate.upload_id)
{
source = Some(ReplacementUploadSource::new(file_path)?);
}
let is_drive =
is_google_drive_upload(initiate.provider.as_deref(), &initiate.upload_id);
let parts = upload_parts(
video_id,
&initiate.upload_id,
file_path,
is_drive,
progress,
cancel,
source.as_mut(),
)
.await?;
check_export_cancelled(cancel)?;
if let Some(source) = &mut source {
source.validate_file(file_path)?;
source.seal_parts(&parts)?;
}
let completed_identity = checked_upload_step(cancel, || {
multipart_complete(
video_id,
&initiate.upload_id,
&parts,
Some(metadata),
replace_existing,
)
})
.await?;
let completed_identity = match completed_identity {
ReplacementUploadAttempt::Completed(identity) => identity,
ReplacementUploadAttempt::RestartRequired(()) => {
if source.is_none() {
return Err(replacement_restart_error());
}
return Ok(ReplacementUploadAttempt::RestartRequired(source));
}
};
let object_identity = if is_drive {
parts
.iter()
.rev()
.find_map(|part| part.object_identity.clone())
} else {
completed_identity
};
Ok(ReplacementUploadAttempt::Completed((
format!("{}/s/{video_id}", auth::server_url()),
object_identity,
)))
},
)
.await?;
progress(1.0);
Ok(result)
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct InitiateResponse {
upload_id: String,
provider: Option<String>,
}
async fn multipart_initiate(
video_id: &str,
replace_existing: bool,
) -> Result<InitiateResponse, AuthApiError> {
let response = auth::authed_request(
reqwest::Method::POST,
"/api/upload/multipart/initiate",
Some(json!({
"videoId": video_id,
"contentType": "video/mp4",
"replaceExisting": replace_existing
})),
)
.await
.map_err(|error| {
AuthApiError::Other(format!("api/upload_multipart_initiate/request: {error}"))
})?;
if !response.status().is_success() {
let status = response.status().as_u16();
return Err(AuthApiError::Other(format!(
"api/upload_multipart_initiate/{status}"
)));
}
response.json().await.map_err(|error| {
AuthApiError::Other(format!("api/upload_multipart_initiate/response: {error}"))
})
}
async fn multipart_presign(
client: &reqwest::Client,
video_id: &str,
upload_id: &str,
part_number: u32,
md5_sum: Option<&str>,
) -> Result<String, AuthApiError> {
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Response {
presigned_url: String,
}
let mut body = serde_json::Map::from_iter([
("videoId".into(), json!(video_id)),
("uploadId".into(), json!(upload_id)),
("partNumber".into(), json!(part_number)),
]);
if let Some(md5_sum) = md5_sum {
body.insert("md5Sum".into(), json!(md5_sum));
}
let response = auth::authed_request_with(
client,
reqwest::Method::POST,
"/api/upload/multipart/presign-part",
Some(Value::Object(body)),
)
.await
.map_err(|error| {
AuthApiError::Other(format!(
"api/upload_multipart_presign_part/request: {error}"
))
})?;
if !response.status().is_success() {
let status = response.status().as_u16();
return Err(AuthApiError::Other(format!(
"api/upload_multipart_presign_part/{status}"
)));
}
response
.json::<Response>()
.await
.map(|data| data.presigned_url)
.map_err(|error| {
AuthApiError::Other(format!(
"api/upload_multipart_presign_part/response: {error}"
))
})
}
async fn multipart_complete(
video_id: &str,
upload_id: &str,
parts: &[UploadedPart],
meta: Option<&VideoMeta>,
replace_existing: bool,
) -> Result<ReplacementUploadAttempt<Option<String>>, AuthApiError> {
let mut body = json!({
"videoId": video_id,
"uploadId": upload_id,
"parts": parts,
"replaceExisting": replace_existing,
});
if let Some(meta) = meta
&& let Value::Object(object) = &mut body
&& let Ok(Value::Object(extra)) = serde_json::to_value(meta)
{
object.extend(extra);
}
let response = auth::authed_request(
reqwest::Method::POST,
"/api/upload/multipart/complete",
Some(body),
)
.await
.map_err(|error| {
AuthApiError::Other(format!("api/upload_multipart_complete/request: {error}"))
})?;
let status = response.status();
if !status.is_success() {
if status == StatusCode::CONFLICT {
let body = response.json::<Value>().await.unwrap_or(Value::Null);
if replacement_restart_required(status, &body) {
return Ok(ReplacementUploadAttempt::RestartRequired(()));
}
}
return Err(AuthApiError::Other(format!(
"api/upload_multipart_complete/{}",
status.as_u16()
)));
}
let response = response.json::<Value>().await.unwrap_or(Value::Null);
Ok(ReplacementUploadAttempt::Completed(
response
.get("objectIdentity")
.and_then(Value::as_str)
.map(str::to_string),
))
}
fn replacement_restart_required(status: StatusCode, body: &Value) -> bool {
status == StatusCode::CONFLICT
&& body.get("code").and_then(Value::as_str) == Some("REPLACEMENT_RESTART_REQUIRED")
}
async fn upload_parts(
video_id: &str,
upload_id: &str,
file_path: &Path,
is_drive: bool,
progress: &impl Fn(f64),
cancel: &AtomicBool,
replacement_source: Option<&mut ReplacementUploadSource>,
) -> Result<Vec<UploadedPart>, AuthApiError> {
let file_size = std::fs::metadata(file_path)
.map_err(|error| AuthApiError::Other(format!("Failed to read export size: {error}")))?
.len();
if file_size == 0 {
return Err(AuthApiError::Other("Rendered video is empty".into()));
}
let transport = LivePartTransport {
video_id,
upload_id,
is_drive,
use_md5: auth::is_server_url_custom(),
api: auth::api_client()?,
storage: reqwest::Client::new(),
};
upload_file_parts(
&transport,
file_path,
file_size,
chunk_size_for(file_size),
progress,
cancel,
replacement_source,
)
.await
}
struct PartChunk {
part_number: u32,
offset: u64,
bytes: bytes::Bytes,
}
struct PresignedPart {
url: String,
md5: Option<String>,
}
trait PartTransport: Sync {
fn presign(
&self,
chunk: &PartChunk,
cancel: &AtomicBool,
) -> impl Future<Output = Result<PresignedPart, AuthApiError>> + Send;
fn put(
&self,
presigned: &PresignedPart,
chunk: &PartChunk,
total_size: u64,
cancel: &AtomicBool,
) -> impl Future<Output = Result<UploadedPart, AuthApiError>> + Send;
}
/// Every part of one upload goes through the same two clients, so parts after
/// the first reuse the open API and storage connections. The clients live only
/// as long as the upload, so a later upload never starts on a pooled
/// connection from an earlier network.
struct LivePartTransport<'a> {
video_id: &'a str,
upload_id: &'a str,
is_drive: bool,
use_md5: bool,
api: reqwest::Client,
storage: reqwest::Client,
}
impl PartTransport for LivePartTransport<'_> {
async fn presign(
&self,
chunk: &PartChunk,
cancel: &AtomicBool,
) -> Result<PresignedPart, AuthApiError> {
let md5 = self.use_md5.then(|| md5_base64(&chunk.bytes));
let url = checked_upload_step(cancel, || {
multipart_presign(
&self.api,
self.video_id,
self.upload_id,
chunk.part_number,
md5.as_deref(),
)
})
.await?;
Ok(PresignedPart { url, md5 })
}
async fn put(
&self,
presigned: &PresignedPart,
chunk: &PartChunk,
total_size: u64,
cancel: &AtomicBool,
) -> Result<UploadedPart, AuthApiError> {
put_presigned_part(
&self.storage,
&presigned.url,
chunk,
total_size,
self.is_drive,
presigned.md5.as_deref(),
cancel,
)
.await
}
}
/// Part requests only observe cancellation between requests, so this races
/// them against the cancel flag to drop an in-flight part promptly.
async fn upload_part_chunk(
transport: &impl PartTransport,
chunk: &PartChunk,
total_size: u64,
cancel: &AtomicBool,
) -> Result<UploadedPart, AuthApiError> {
tokio::select! {
biased;
() = wait_for_export_cancel(cancel) => Err(AuthApiError::Other("Export cancelled".into())),
result = async {
let presigned = transport.presign(chunk, cancel).await?;
transport.put(&presigned, chunk, total_size, cancel).await
} => result,
}
}
async fn wait_for_export_cancel(cancel: &AtomicBool) {
while !cancel.load(Ordering::Acquire) {
tokio::time::sleep(Duration::from_millis(100)).await;
}
}
/// Parts go strictly one at a time, so an interrupted connection only ever
/// loses the one part that was in flight.
async fn upload_file_parts(
transport: &impl PartTransport,
file_path: &Path,
file_size: u64,
chunk_size: u64,
progress: &impl Fn(f64),
cancel: &AtomicBool,
mut replacement_source: Option<&mut ReplacementUploadSource>,
) -> Result<Vec<UploadedPart>, AuthApiError> {
let mut parts = Vec::new();
let mut failed = Vec::new();
let mut offset = 0u64;
let mut uploaded_bytes = 0u64;
let mut part_number = 1u32;
while offset < file_size {
if cancel.load(Ordering::Relaxed) {
return Err(AuthApiError::Other("Export cancelled".into()));
}
let size = (file_size - offset).min(chunk_size) as usize;
let chunk = read_chunk(file_path, offset, size)?;
if let Some(source) = &mut replacement_source {
source.check_chunk(part_number, offset, &chunk, file_size)?;
}
let chunk = PartChunk {
part_number,
offset,
bytes: chunk.into(),
};
match upload_part_chunk(transport, &chunk, file_size, cancel).await {
Ok(part) => {
uploaded_bytes += size as u64;
progress((uploaded_bytes as f64 / file_size as f64).min(0.99));
parts.push(part);
}
Err(error) => {
check_export_cancelled(cancel)?;
tracing::warn!(part_number, error = %error, "chunk upload failed; will retry");
failed.push((chunk, error));
}
}
offset += size as u64;
part_number += 1;
}
for (chunk, first_error) in failed {
if cancel.load(Ordering::Relaxed) {
return Err(AuthApiError::Other("Export cancelled".into()));
}
match upload_part_chunk(transport, &chunk, file_size, cancel).await {
Ok(part) => {
uploaded_bytes += chunk.bytes.len() as u64;
progress((uploaded_bytes as f64 / file_size as f64).min(0.99));
parts.push(part);
}
Err(_) => {
check_export_cancelled(cancel)?;
return Err(first_error);
}
}
}
parts.sort_by_key(|part| part.part_number);
let mut deduped = HashMap::new();
for part in parts {
deduped.insert(part.part_number, part);
}
let mut parts = deduped.into_values().collect::<Vec<_>>();
parts.sort_by_key(|part| part.part_number);
Ok(parts)
}
async fn put_presigned_part(
client: &reqwest::Client,
url: &str,
chunk: &PartChunk,
total_size: u64,
is_drive: bool,
md5_sum: Option<&str>,
cancel: &AtomicBool,
) -> Result<UploadedPart, AuthApiError> {
let PartChunk {
part_number,
offset,
ref bytes,
} = *chunk;
let mut attempt = 0u32;
loop {
let mut request = client
.put(url)
.header("Content-Length", bytes.len())
.timeout(Duration::from_secs(5 * 60))
.body(bytes.clone());
if is_drive || is_google_drive_resumable_url(url) {
let end = offset.saturating_add(bytes.len() as u64).saturating_sub(1);
request = request.header(
"Content-Range",
format!("bytes {offset}-{end}/{total_size}"),
);
}
if let Some(md5_sum) = md5_sum {
request = request.header("Content-MD5", md5_sum);
}
let response =
checked_upload_step(cancel, || async { Ok(send_upload_request(request).await) })
.await?;
match response {
Ok(response) => {
if !upload_status_ok(
url,
response.status(),
offset,
bytes.len() as u64,
total_size,
) {
let status = response.status();
return Err(AuthApiError::Other(format!(
"uploader/part/{part_number}/status/{status}"
)));
}
let etag = response
.headers()
.get("ETag")
.and_then(|value| value.to_str().ok())
.unwrap_or("")
.trim_matches('"')
.to_string();
let object_identity = if (is_drive || is_google_drive_resumable_url(url))
&& response.status().is_success()
{
response.json::<Value>().await.ok().and_then(|value| {
cap_recording::upload_verification::completed_drive_object_identity(
&value, total_size,
)
})
} else {
None
};
return Ok(UploadedPart {
part_number,
etag,
size: bytes.len(),
object_identity,
});
}
Err(error) if is_network_error(&error) && attempt < 4 => {
attempt += 1;
let delay = Duration::from_secs(2u64.saturating_pow(attempt).min(30));
tracing::info!(
part_number,
attempt,
"network error uploading chunk; retrying in {delay:?}: {error}"
);
checked_upload_step(cancel, || async {
tokio::time::sleep(delay).await;
Ok(())
})
.await?;
}
Err(error) => {
return Err(AuthApiError::Other(format!(
"uploader/part/{part_number}/error: {error}"
)));
}
}
}
}
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, 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, 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/
/// signed` for the URL, then the raw body. The thumbnail upload and the
/// rendered-screenshot upload are both this shape (`singlepart_uploader` +
/// `PresignedS3PutRequest` in the Tauri binary).
async fn presigned_put_bytes(
video_id: &str,
subpath: &str,
bytes: Vec<u8>,
) -> Result<(), AuthApiError> {
presigned_put_bytes_inner(video_id, subpath, bytes, None).await
}
async fn optional_upload_step<T, F>(
cancel: Option<&AtomicBool>,
step: impl FnOnce() -> F,
) -> Result<T, AuthApiError>
where
F: Future<Output = Result<T, AuthApiError>>,
{
match cancel {
Some(cancel) => checked_upload_step(cancel, step).await,
None => step().await,
}
}
async fn presigned_put_bytes_inner(
video_id: &str,
subpath: &str,
bytes: Vec<u8>,
cancel: Option<&AtomicBool>,
) -> Result<(), AuthApiError> {
let target = presign_put_target(video_id, subpath, cancel).await?;
upload_signed_bytes_inner(target, subpath, bytes, cancel).await
}
async fn presign_put_target(
video_id: &str,
subpath: &str,
cancel: Option<&AtomicBool>,
) -> Result<SignedUploadTarget, AuthApiError> {
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Response {
presigned_put_data: SignedUploadTarget,
}
let response = optional_upload_step(cancel, || {
auth::authed_request(
reqwest::Method::POST,
"/api/upload/signed",
Some(json!({
"videoId": video_id,
"subpath": subpath,
"method": "put",
})),
)
})
.await?;
let status = response.status();
if !status.is_success() {
return Err(AuthApiError::Status(
status,
format!("api/upload_signed/{}", status.as_u16()),
));
}
response
.json::<Response>()
.await
.map(|response| response.presigned_put_data)
.map_err(|error| AuthApiError::Other(format!("api/upload_signed/response: {error}")))
}
async fn upload_signed_bytes_inner(
target: SignedUploadTarget,
subpath: &str,
bytes: Vec<u8>,
cancel: Option<&AtomicBool>,
) -> Result<(), AuthApiError> {
static CLIENT: OnceLock<reqwest::Client> = OnceLock::new();
let length = bytes.len() as u64;
let mut request = CLIENT
.get_or_init(upload_client)
.put(&target.url)
.header("Content-Length", length)
.header("Content-Type", upload_content_type(subpath))
.timeout(Duration::from_secs(5 * 60))
.body(bytes);
if is_google_drive_resumable_url(&target.url) && length > 0 {
request = request.header(
"Content-Range",
format!("bytes 0-{}/{}", length.saturating_sub(1), length),
);
}
for (name, value) in target.headers {
request = request.header(name, value);
}
let response = optional_upload_step(cancel, || async {
send_upload_request(request).await.map_err(|error| {
if error.is_timeout() {
AuthApiError::Timeout
} else {
AuthApiError::Other(error.to_string())
}
})
})
.await?;
let status = response.status();
if !status.is_success() {
return Err(AuthApiError::Status(
status,
format!("upload failed: {status}"),
));
}
Ok(())
}
fn upload_client() -> reqwest::Client {
reqwest::Client::builder()
.connect_timeout(UPLOAD_CONNECT_TIMEOUT)
.tcp_keepalive(UPLOAD_TCP_KEEPALIVE)
.pool_idle_timeout(UPLOAD_POOL_IDLE_TIMEOUT)
.build()
.unwrap_or_else(|error| {
tracing::warn!("Falling back to the default upload client: {error}");
reqwest::Client::new()
})
}
async fn send_upload_request(
request: reqwest::RequestBuilder,
) -> Result<reqwest::Response, reqwest::Error> {
request.send().await.map_err(reqwest::Error::without_url)
}
fn upload_content_type(subpath: &str) -> &'static str {
if subpath.ends_with(".json") {
"application/json"
} else if subpath.ends_with(".mp4") || subpath.ends_with(".m4s") {
"video/mp4"
} else if subpath.ends_with(".png") {
"image/png"
} else if subpath.ends_with(".jpg") || subpath.ends_with(".jpeg") {
"image/jpeg"
} else {
"application/octet-stream"
}
}
// ---------------------------------------------------------------------------
// Screenshot share upload
// ---------------------------------------------------------------------------
/// A created-or-reused server video record, with the share link derived from
/// its id -- `UploadedItem` in the Tauri binary.
pub struct UploadedItem {
pub link: String,
pub id: String,
}
/// What the screenshot share flow's upload step resolved to. The two
/// non-success arms carry the exact toasts `shareLinkFromUploadResult` maps
/// them to on the window side.
pub enum ScreenshotShareOutcome {
Uploaded(UploadedItem),
NotAuthenticated,
UpgradeRequired,
}
/// `screenshot_upload_subpath` (`src-tauri/upload.rs:259-265`): the composited
/// image lands under the record's screenshot key, extension by content type.
fn screenshot_upload_subpath(content_type: &str) -> &'static str {
if content_type.eq_ignore_ascii_case("image/png") {
"screenshot/screen-capture.png"
} else {
"screenshot/screen-capture.jpg"
}
}
/// `upload_rendered_screenshot` (`src-tauri/lib.rs:3761-3796`), minus the
/// clipboard/meta halves the window owns: gate on auth exactly as the Tauri
/// command does, create-or-get the screenshot video record (re-using the
/// sharing id when the caller has one, so the link survives re-uploads), and
/// presigned-PUT the encoded bytes to the screenshot subpath.
pub async fn upload_rendered_screenshot(
image_bytes: Vec<u8>,
content_type: &str,
video_id: Option<String>,
) -> Result<ScreenshotShareOutcome, String> {
let auth = crate::store::auth_snapshot();
if !auth.signed_in() {
// The Tauri command resets a corrupt/absent auth store on this path.
let _ = crate::store::set_auth(None);
return Ok(ScreenshotShareOutcome::NotAuthenticated);
}
if !auth.is_upgraded() {
return Ok(ScreenshotShareOutcome::UpgradeRequired);
}
match upload_screenshot_bytes(image_bytes, content_type, video_id).await {
Ok(item) => Ok(ScreenshotShareOutcome::Uploaded(item)),
Err(AuthApiError::InvalidAuthentication) => Ok(ScreenshotShareOutcome::NotAuthenticated),
Err(AuthApiError::UpgradeRequired) => Ok(ScreenshotShareOutcome::UpgradeRequired),
Err(error) => Err(error.to_string()),
}
}
/// `upload_screenshot_bytes` (`src-tauri/upload.rs:279-307`).
async fn upload_screenshot_bytes(
image_bytes: Vec<u8>,
content_type: &str,
video_id: Option<String>,
) -> Result<UploadedItem, AuthApiError> {
let s3_config = create_or_get_video(true, video_id, None, None, None).await?;
let subpath = screenshot_upload_subpath(content_type);
presigned_put_bytes(&s3_config.id, subpath, image_bytes).await?;
Ok(UploadedItem {
link: format!("{}/s/{}", auth::server_url(), s3_config.id),
id: s3_config.id,
})
}
fn compress_image(path: &Path) -> Result<Vec<u8>, AuthApiError> {
cap_gpui_kernels::codec::compress_image_jpeg(path).map_err(AuthApiError::Other)
}
fn build_video_meta(path: &Path) -> Result<VideoMeta, String> {
let input = ffmpeg::format::input(path)
.map_err(|error| format!("Failed to read input file: {error}"))?;
let video_stream = input
.streams()
.best(ffmpeg::media::Type::Video)
.ok_or_else(|| "Failed to find appropriate video stream in file".to_string())?;
let video_codec =
ffmpeg::codec::context::Context::from_parameters(video_stream.parameters())
.map_err(|error| format!("Unable to read video codec information: {error}"))?;
let video = video_codec
.decoder()
.video()
.map_err(|error| format!("Unable to get video decoder: {error}"))?;
Ok(VideoMeta {
duration_in_secs: input.duration() as f64 / f64::from(ffmpeg::ffi::AV_TIME_BASE),
width: video.width(),
height: video.height(),
fps: video
.frame_rate()
.map(|rate| rate.numerator() as f32 / rate.denominator() as f32),
})
}
fn read_chunk(path: &Path, offset: u64, size: usize) -> Result<Vec<u8>, AuthApiError> {
let mut file = std::fs::File::open(path)
.map_err(|error| AuthApiError::Other(format!("Failed to open export: {error}")))?;
file.seek(SeekFrom::Start(offset))
.map_err(|error| AuthApiError::Other(format!("Failed to seek export: {error}")))?;
let mut buffer = vec![0u8; size];
file.read_exact(&mut buffer)
.map_err(|error| AuthApiError::Other(format!("Failed to read export chunk: {error}")))?;
Ok(buffer)
}
fn chunk_size_for(file_size: u64) -> u64 {
let size = (file_size / 100).clamp(MIN_CHUNK_SIZE, MAX_CHUNK_SIZE);
size / DRIVE_CHUNK_ALIGNMENT * DRIVE_CHUNK_ALIGNMENT
}
fn md5_base64(bytes: &[u8]) -> String {
let digest = cap_gpui_kernels::codec::md5(bytes);
base64::Engine::encode(&base64::engine::general_purpose::STANDARD, digest)
}
fn is_google_drive_resumable_url(url: &str) -> bool {
let Ok(url) = reqwest::Url::parse(url) else {
return false;
};
url.host_str().is_some_and(|host| {
(host == "googleapis.com" || host.ends_with(".googleapis.com"))
&& url.path().starts_with("/upload/drive/")
})
}
fn is_google_drive_upload(provider: Option<&str>, upload_id: &str) -> bool {
provider == Some("googleDrive") || is_google_drive_resumable_url(upload_id)
}
fn upload_status_ok(
url: &str,
status: StatusCode,
offset: u64,
size: u64,
total_size: u64,
) -> bool {
status.is_success()
|| (is_google_drive_resumable_url(url)
&& status == StatusCode::PERMANENT_REDIRECT
&& offset.saturating_add(size) < total_size)
}
fn is_network_error(error: &reqwest::Error) -> bool {
error.is_timeout() || error.is_connect() || error.is_request() || error.is_body()
}
fn urlencoding(value: &str) -> String {
let mut encoded = String::new();
for byte in value.bytes() {
match byte {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
encoded.push(byte as char);
}
_ => encoded.push_str(&format!("%{byte:02X}")),
}
}
encoded
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn presigned_transfer_errors_never_expose_secret_urls() {
let client = reqwest::Client::new();
for url in [
"cap-test://upload.invalid/private-object?X-Amz-Signature=fake-s3-secret",
"cap-test://upload.invalid/private-object?upload_id=fake-drive-secret",
] {
let original = client.put(url).send().await.unwrap_err();
assert_eq!(original.url().unwrap().as_str(), url);
assert!(original.to_string().contains("fake-"));
let error = send_upload_request(client.put(url)).await.unwrap_err();
assert!(error.is_builder());
assert!(error.url().is_none());
let direct = upload_signed_bytes_inner(
SignedUploadTarget {
url: url.into(),
headers: HashMap::new(),
},
"segments/video/segment_001.m4s",
vec![1, 2, 3],
None,
)
.await
.unwrap_err();
for message in [error.to_string(), format!("{error:?}"), direct.to_string()] {
assert!(!message.is_empty());
for secret in [
"fake-",
"upload.invalid",
"private-object",
"upload_id",
"X-Amz",
] {
assert!(!message.contains(secret), "Upload error leaked a secret");
}
}
}
}
#[test]
fn abort_segments_waits_until_the_upload_task_has_stopped() {
struct Dropped(Arc<AtomicBool>);
impl Drop for Dropped {
fn drop(&mut self) {
self.0.store(true, Ordering::Release);
}
}
tokio::runtime::Builder::new_current_thread()
.build()
.unwrap()
.block_on(async {
let dropped = Arc::new(AtomicBool::new(false));
let upload_dropped = dropped.clone();
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
let task = tokio::spawn(async move {
let _dropped = Dropped(upload_dropped);
let _ = started_tx.send(());
std::future::pending::<()>().await;
Ok(())
});
started_rx.await.unwrap();
let mut upload = InstantUpload {
video: VideoUploadInfo {
id: "test".into(),
link: "https://example.invalid/s/test".into(),
config: S3UploadMeta { id: "test".into() },
},
segment_upload: Some(task),
cancel: Arc::new(AtomicBool::new(false)),
metadata_lock: Arc::new(Mutex::new(())),
completion_permit: None,
completion_control: None,
bridge: None,
ownership: None,
prior_attempts: 0,
request_context: None,
reads: Arc::new(UploadReads::default()),
};
{
let mut finish = Box::pin(upload.finish_segments());
assert!(
std::future::poll_fn(|context| std::task::Poll::Ready(
finish.as_mut().poll(context)
))
.await
.is_pending()
);
}
assert!(upload.segment_upload.is_some());
upload.abort_segments().await;
assert!(dropped.load(Ordering::Acquire));
assert!(upload.cancel.load(Ordering::Acquire));
});
}
fn upload_with_task(
task: tokio::task::JoinHandle<Result<(), String>>,
control: Option<CompletionControl>,
) -> InstantUpload {
InstantUpload {
video: VideoUploadInfo {
id: "owned-upload".into(),
link: "https://example.invalid/s/owned-upload".into(),
config: S3UploadMeta {
id: "owned-upload".into(),
},
},
segment_upload: Some(task),
cancel: control
.as_ref()
.map(|control| control.cancel.clone())
.unwrap_or_else(|| Arc::new(AtomicBool::new(false))),
metadata_lock: Arc::new(Mutex::new(())),
completion_permit: None,
completion_control: control,
bridge: None,
ownership: None,
prior_attempts: 0,
request_context: None,
reads: Arc::new(UploadReads::default()),
}
}
#[tokio::test]
async fn denied_segment_finish_waits_until_the_owned_task_has_joined() {
let authorization = CompletionAuthorization::new();
let control = authorization.control.clone();
let finished = Arc::new(AtomicBool::new(false));
let task_finished = finished.clone();
let (release, released) = tokio::sync::oneshot::channel();
let task = tokio::spawn(async move {
released.await.unwrap();
task_finished.store(true, Ordering::Release);
Ok(())
});
let mut upload = upload_with_task(task, Some(control.clone()));
{
let mut finish = Box::pin(upload.finish_segments());
assert!(
std::future::poll_fn(|context| std::task::Poll::Ready(
finish.as_mut().poll(context)
))
.await
.is_pending()
);
control.deny();
assert!(
std::future::poll_fn(|context| std::task::Poll::Ready(
finish.as_mut().poll(context)
))
.await
.is_pending()
);
assert!(!finished.load(Ordering::Acquire));
release.send(()).unwrap();
assert!(finish.await.unwrap_err().contains("cancelled"));
}
assert!(finished.load(Ordering::Acquire));
assert!(upload.segment_upload.is_none());
upload.abort_segments().await;
}
#[tokio::test]
async fn segment_finish_preserves_results_and_removes_only_joined_handles() {
for result in [Ok(()), Err("segment transfer failed".to_string())] {
let expected = result.clone();
let mut upload = upload_with_task(tokio::spawn(async move { result }), None);
assert_eq!(upload.finish_segments().await, expected);
assert!(upload.segment_upload.is_none());
upload.abort_segments().await;
}
let task = tokio::spawn(std::future::pending::<Result<(), String>>());
task.abort();
let mut upload = upload_with_task(task, None);
assert!(
upload
.finish_segments()
.await
.unwrap_err()
.contains("Instant segment upload task failed")
);
assert!(upload.segment_upload.is_none());
upload.abort_segments().await;
let task: tokio::task::JoinHandle<Result<(), String>> =
tokio::spawn(async { panic!("synthetic segment task panic") });
let mut upload = upload_with_task(task, None);
assert!(
upload
.finish_segments()
.await
.unwrap_err()
.contains("Instant segment upload task failed")
);
assert!(upload.segment_upload.is_none());
upload.abort_segments().await;
let task = tokio::spawn(std::future::pending::<Result<(), String>>());
let mut upload = upload_with_task(task, None);
upload.cancel.store(true, Ordering::Release);
assert!(
upload
.finish_segments()
.await
.unwrap_err()
.contains("cancelled")
);
assert!(upload.segment_upload.is_some());
upload.abort_segments().await;
assert!(upload.segment_upload.is_none());
}
fn segment_event(
index: u32,
duration: f64,
is_init: bool,
media_type: SegmentMediaType,
) -> SegmentCompletedEvent {
SegmentCompletedEvent {
path: PathBuf::from("segment.m4s"),
index,
duration,
file_size: 16,
is_init,
media_type,
}
}
/// The finished segment manifest this app uploads, checked against the
/// files the web server's own parser is tested with
/// (`apps/web/__tests__/unit/desktop-segments-manifest-contract.test.ts`),
/// so neither side can change the format without the other noticing. Run
/// with `CAP_UPDATE_CONTRACT_FIXTURES=1` to rewrite the files after an
/// intended change.
#[test]
fn finished_segment_manifests_match_the_server_contract_fixtures() {
let fixtures = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("../web/__tests__/fixtures/desktop-segments");
for (name, audio) in [("with-audio", 2), ("video-only", 0)] {
let mut manifest = SegmentUploadManifest::default();
manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
for (index, duration) in [(1, 2.0), (2, 2.0), (3, 1.25)] {
manifest.record(&segment_event(
index,
duration,
false,
SegmentMediaType::Video,
));
}
if audio > 0 {
manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Audio));
for index in 1..=audio {
manifest.record(&segment_event(index, 3.0, false, SegmentMediaType::Audio));
}
}
manifest.is_complete = true;
let uploaded = serde_json::to_value(&manifest).unwrap();
let path = fixtures.join(format!("finished-manifest-{name}.json"));
if std::env::var_os("CAP_UPDATE_CONTRACT_FIXTURES").is_some() {
std::fs::create_dir_all(&fixtures).unwrap();
let mut json = Vec::new();
let formatter = serde_json::ser::PrettyFormatter::with_indent(b"\t");
let mut serializer = serde_json::Serializer::with_formatter(&mut json, formatter);
serde::Serialize::serialize(&uploaded, &mut serializer).unwrap();
json.push(b'\n');
std::fs::write(&path, json).unwrap();
}
let fixture: serde_json::Value = serde_json::from_slice(
&std::fs::read(&path).unwrap_or_else(|error| panic!("{}: {error}", path.display())),
)
.unwrap();
assert_eq!(
fixture,
uploaded,
"{} no longer matches what the app uploads",
path.display()
);
}
}
#[test]
fn recorded_length_sums_the_complete_local_video_track() {
let mut manifest = SegmentUploadManifest::default();
manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
manifest.record(&segment_event(2, 2.0, false, SegmentMediaType::Video));
manifest.record(&segment_event(1, 2.0, false, SegmentMediaType::Video));
manifest.record(&segment_event(3, 0.5, false, SegmentMediaType::Video));
manifest.record(&segment_event(1, 2.0, false, SegmentMediaType::Audio));
let value: Value =
serde_json::from_slice(&recorded_length_json(&manifest).unwrap()).unwrap();
assert_eq!(
value,
json!({ "version": 1, "duration": 4.5, "video_segments": 3, "audio_segments": 1 })
);
}
#[test]
fn recorded_length_is_skipped_without_a_usable_video_length() {
assert!(recorded_length_json(&SegmentUploadManifest::default()).is_none());
for duration in [0.0, f64::NAN, f64::INFINITY] {
let mut manifest = SegmentUploadManifest::default();
manifest.record(&segment_event(1, duration, false, SegmentMediaType::Video));
assert!(recorded_length_json(&manifest).is_none(), "{duration}");
}
}
#[tokio::test]
async fn alongside_never_waits_for_its_side_task() {
let side_ran = Arc::new(AtomicBool::new(false));
let flag = side_ran.clone();
let output = alongside(async { 7 }, async move {
std::future::pending::<()>().await;
flag.store(true, Ordering::SeqCst);
})
.await;
assert_eq!(output, 7);
assert!(!side_ran.load(Ordering::SeqCst));
}
#[tokio::test]
async fn alongside_finishes_its_main_task_after_a_quick_side_task() {
let (sender, receiver) = tokio::sync::oneshot::channel::<u32>();
let side_ran = Arc::new(AtomicBool::new(false));
let flag = side_ran.clone();
let output = alongside(async { receiver.await.unwrap() }, async move {
flag.store(true, Ordering::SeqCst);
sender.send(9).unwrap();
})
.await;
assert_eq!(output, 9);
assert!(side_ran.load(Ordering::SeqCst));
}
#[test]
fn segment_manifest_requires_init_and_orders_video_and_audio() {
let mut manifest = SegmentUploadManifest::default();
manifest.record(&segment_event(3, 1.5, false, SegmentMediaType::Video));
manifest.record(&segment_event(1, 2.0, false, SegmentMediaType::Video));
manifest.record(&segment_event(2, 2.0, false, SegmentMediaType::Audio));
manifest.record(&segment_event(1, 1.8, false, SegmentMediaType::Audio));
assert!(!manifest.has_video_content());
manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Audio));
assert!(manifest.has_video_content());
assert_eq!(
manifest
.video_segments
.iter()
.map(|segment| segment.index)
.collect::<Vec<_>>(),
vec![1, 3]
);
assert_eq!(
manifest
.audio_segments
.iter()
.map(|segment| segment.index)
.collect::<Vec<_>>(),
vec![1, 2]
);
assert!(manifest.video_init_uploaded);
assert!(manifest.audio_init_uploaded);
assert!(!manifest.is_complete);
}
#[test]
fn initial_segment_batch_prefetches_initializers_and_matching_media_pairs() {
let paths = prefetched_segment_paths(1, 3);
assert_eq!(paths.len(), 9);
assert!(paths.contains(&"segments/video/init.mp4".to_string()));
assert!(paths.contains(&"segments/audio/init.mp4".to_string()));
assert!(paths.contains(&"segments/manifest.json".to_string()));
assert!(paths.contains(&"segments/video/segment_001.m4s".to_string()));
assert!(paths.contains(&"segments/audio/segment_003.m4s".to_string()));
}
#[test]
fn subsequent_segment_batches_do_not_repeat_initializers() {
assert_eq!(
prefetched_segment_paths(21, 2),
vec![
"segments/video/segment_021.m4s",
"segments/audio/segment_021.m4s",
"segments/video/segment_022.m4s",
"segments/audio/segment_022.m4s",
]
);
}
#[test]
fn segment_manifest_updates_replayed_segments_without_duplicates() {
let mut manifest = SegmentUploadManifest::default();
manifest.record(&segment_event(4, 1.0, false, SegmentMediaType::Video));
manifest.record(&segment_event(4, 2.5, false, SegmentMediaType::Video));
assert_eq!(
manifest.video_segments,
vec![SegmentManifestEntry {
index: 4,
duration: 2.5,
}]
);
}
#[test]
fn segment_upload_paths_match_tauri_storage_layout() {
assert_eq!(
segment_subpath(&segment_event(0, 0.0, true, SegmentMediaType::Video)),
"segments/video/init.mp4"
);
assert_eq!(
segment_subpath(&segment_event(0, 0.0, true, SegmentMediaType::Audio)),
"segments/audio/init.mp4"
);
assert_eq!(
segment_subpath(&segment_event(7, 2.0, false, SegmentMediaType::Video)),
"segments/video/segment_007.m4s"
);
assert_eq!(
segment_subpath(&segment_event(14, 2.0, false, SegmentMediaType::Audio)),
"segments/audio/segment_014.m4s"
);
}
#[test]
fn signed_upload_content_types_match_media() {
assert_eq!(
upload_content_type("segments/manifest.json"),
"application/json"
);
assert_eq!(upload_content_type("segments/video/init.mp4"), "video/mp4");
assert_eq!(
upload_content_type("segments/audio/segment_001.m4s"),
"video/mp4"
);
assert_eq!(
upload_content_type("screenshot/screen-capture.jpg"),
"image/jpeg"
);
assert_eq!(
upload_content_type("screenshot/screen-capture.png"),
"image/png"
);
}
#[test]
fn chunk_size_clamps() {
assert_eq!(chunk_size_for(1), MIN_CHUNK_SIZE);
// A hundredth of the file, clamped: the upper assertion needs a file
// whose hundredth actually exceeds the cap (1.5 GiB does; the old
// `MIN_CHUNK_SIZE * 200` = 1000 MiB sat below it and asserted the
// wrong side of the clamp).
assert_eq!(chunk_size_for(MAX_CHUNK_SIZE * 200), MAX_CHUNK_SIZE);
assert_eq!(chunk_size_for(MIN_CHUNK_SIZE * 50), MIN_CHUNK_SIZE);
}
#[test]
fn chunk_sizes_satisfy_drive_resumable_alignment() {
for file_size in [
1,
MIN_CHUNK_SIZE * 100,
MIN_CHUNK_SIZE * 100 + 100,
600 * 1024 * 1024,
1024 * 1024 * 1024,
MAX_CHUNK_SIZE * 100 - 100,
MAX_CHUNK_SIZE * 100,
MAX_CHUNK_SIZE * 200,
] {
let chunk_size = chunk_size_for(file_size);
assert!((MIN_CHUNK_SIZE..=MAX_CHUNK_SIZE).contains(&chunk_size));
assert_eq!(
chunk_size % (256 * 1024),
0,
"Drive requires aligned intermediate chunks for a {file_size}-byte export"
);
}
}
#[test]
fn drive_url_detection() {
assert!(is_google_drive_resumable_url(
"https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable"
));
assert!(!is_google_drive_resumable_url(
"https://s3.amazonaws.com/bucket/key"
));
assert!(is_google_drive_upload(Some("googleDrive"), "abc"));
}
#[test]
fn reusable_video_id_prefers_sharing_state() {
let sharing = SharingMeta {
link: "https://cap.so/s/shared".into(),
id: "shared".into(),
content_hash: None,
};
let upload = UploadMeta::SinglePartUpload {
video_id: "pending".into(),
file_path: PathBuf::from("video.mp4"),
screenshot_path: PathBuf::from("display.jpg"),
recording_dir: PathBuf::from("recording.cap"),
};
assert_eq!(
reusable_video_id(Some(&sharing), Some(&upload)).as_deref(),
Some("shared")
);
}
#[test]
fn reusable_video_id_resumes_persisted_upload() {
let upload = UploadMeta::SinglePartUpload {
video_id: "pending".into(),
file_path: PathBuf::from("video.mp4"),
screenshot_path: PathBuf::from("display.jpg"),
recording_dir: PathBuf::from("recording.cap"),
};
assert_eq!(
reusable_video_id(None, Some(&upload)).as_deref(),
Some("pending")
);
assert_eq!(
reusable_video_id(
None,
Some(&UploadMeta::Failed {
error: "network".into(),
}),
),
None
);
}
#[derive(Default)]
struct FakeSegmentTransport {
delay_preparation: AtomicBool,
preparation_started: tokio::sync::Notify,
preparation_dropped: AtomicBool,
manifests: Mutex<Vec<bool>>,
completed: std::sync::atomic::AtomicUsize,
uploaded: std::sync::atomic::AtomicUsize,
fail_segment: AtomicBool,
fatal_segment: AtomicBool,
status_failure: Mutex<Option<StatusCode>>,
retryable_failures: std::sync::atomic::AtomicUsize,
stall_retries: AtomicBool,
segment_calls: std::sync::atomic::AtomicUsize,
segment_call_limit: std::sync::atomic::AtomicUsize,
segment_failed: tokio::sync::Notify,
manifest_failures: std::sync::atomic::AtomicUsize,
manifest_attempts: std::sync::atomic::AtomicUsize,
last_manifest: Mutex<Option<SegmentUploadManifest>>,
delay_complete: AtomicBool,
complete_started: tokio::sync::Notify,
complete_response: tokio::sync::Notify,
prefetch_count: std::sync::atomic::AtomicUsize,
delay_prefetch_at: std::sync::atomic::AtomicUsize,
prefetch_started: tokio::sync::Notify,
prefetch_response: tokio::sync::Notify,
}
impl SegmentTransport for FakeSegmentTransport {
async fn prepare(&self, _: &str, _: Vec<Segment>) -> Result<Option<Vec<Segment>>, String> {
if !self.delay_preparation.load(Ordering::Acquire) {
return Ok(None);
}
struct Finish<'a>(&'a AtomicBool);
impl Drop for Finish<'_> {
fn drop(&mut self) {
self.0.store(true, Ordering::Release);
}
}
let _finish = Finish(&self.preparation_dropped);
self.preparation_started.notify_one();
std::future::pending().await
}
async fn prefetch(
&self,
_: &str,
_: u32,
_: u32,
) -> Result<HashMap<String, String>, String> {
let request = self.prefetch_count.fetch_add(1, Ordering::AcqRel) + 1;
if request == self.delay_prefetch_at.load(Ordering::Acquire) {
self.prefetch_started.notify_one();
self.prefetch_response.notified().await;
}
Ok(HashMap::new())
}
async fn segment(
&self,
_: String,
event: SegmentCompletedEvent,
_: Arc<Mutex<HashMap<String, String>>>,
_: Arc<AtomicBool>,
) -> Result<SegmentCompletedEvent, SegmentUploadError> {
let calls = self.segment_calls.fetch_add(1, Ordering::AcqRel) + 1;
let limit = self.segment_call_limit.load(Ordering::Acquire);
if limit > 0 && calls > limit {
return Err(SegmentUploadError::Fatal(
"segment call limit exceeded".into(),
));
}
if self.fatal_segment.load(Ordering::Acquire) {
return Err(SegmentUploadError::Fatal(
"Authentication expired while uploading the instant recording".into(),
));
}
let retry = self.fail_segment.load(Ordering::Acquire)
|| self
.retryable_failures
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |left| {
left.checked_sub(1)
})
.is_ok();
if let Some(status) = *self.status_failure.lock().unwrap() {
return Err(exhausted_segment_error(
event,
AuthApiError::Status(status, format!("upload failed: {status}")),
));
}
if retry {
self.segment_failed.notify_one();
return Err(exhausted_segment_error(
event,
AuthApiError::Other("segment upload failed".into()),
));
}
if self.stall_retries.load(Ordering::Acquire) {
tokio::time::sleep(Duration::from_secs(5 * 60) * SEGMENT_UPLOAD_ATTEMPTS).await;
return Err(exhausted_segment_error(event, AuthApiError::Timeout));
}
self.uploaded.fetch_add(1, Ordering::AcqRel);
Ok(event)
}
async fn manifest(
&self,
_: &str,
manifest: &SegmentUploadManifest,
_: &Arc<AtomicBool>,
) -> Result<(), String> {
self.manifest_attempts.fetch_add(1, Ordering::AcqRel);
if !manifest.is_complete
&& self
.manifest_failures
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |left| {
left.checked_sub(1)
})
.is_ok()
{
return Err("manifest upload failed".into());
}
self.manifests.lock().unwrap().push(manifest.is_complete);
*self.last_manifest.lock().unwrap() = Some(manifest.clone());
Ok(())
}
async fn complete(&self, _: &str, _: &Arc<AtomicBool>) -> Result<(), String> {
self.completed.fetch_add(1, Ordering::AcqRel);
if self.delay_complete.load(Ordering::Acquire) {
self.complete_started.notify_one();
self.complete_response.notified().await;
}
Ok(())
}
}
#[tokio::test]
async fn stopped_upload_drops_optional_preparation_without_waiting_for_it() {
let transport = FakeSegmentTransport::default();
transport.delay_preparation.store(true, Ordering::Release);
let (sender, events) = flume::unbounded();
sender
.send(segment_event(0, 0.0, true, SegmentMediaType::Video))
.unwrap();
sender
.send(segment_event(1, 1.0, false, SegmentMediaType::Video))
.unwrap();
let upload = upload_segments(
&transport,
"preparation",
events,
Arc::new(AtomicBool::new(false)),
None,
);
tokio::pin!(upload);
tokio::select! {
_ = transport.preparation_started.notified() => {}
result = &mut upload => panic!("Upload ended before preparation: {result:?}"),
_ = tokio::time::sleep(Duration::from_secs(35)) => panic!("Preparation did not start"),
}
drop(sender);
tokio::time::timeout(Duration::from_secs(1), upload)
.await
.unwrap()
.unwrap();
assert!(transport.preparation_dropped.load(Ordering::Acquire));
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
assert_eq!(transport.manifests.lock().unwrap().last(), Some(&true));
}
fn closed_segment_events() -> flume::Receiver<SegmentCompletedEvent> {
let (sender, receiver) = flume::unbounded();
sender
.send(segment_event(0, 0.0, true, SegmentMediaType::Video))
.unwrap();
sender
.send(segment_event(1, 1.0, false, SegmentMediaType::Video))
.unwrap();
drop(sender);
receiver
}
#[tokio::test]
async fn segmented_complete_response_after_revocation_cannot_publish_delete_or_share() {
let transport = FakeSegmentTransport::default();
transport.delay_complete.store(true, Ordering::Release);
let authorization = CompletionAuthorization::new();
let cancel = authorization.control.cancel.clone();
authorization.permit.send(()).unwrap();
let published = AtomicBool::new(false);
let deleted = AtomicBool::new(false);
let shared = AtomicBool::new(false);
let future = async {
crate::recording::finish_instant_upload_locally(
Some(&cancel),
upload_segments(
&transport,
"revoked-completion",
closed_segment_events(),
cancel.clone(),
Some(authorization.required),
),
|| {
published.store(true, Ordering::Release);
Ok(())
},
async {
deleted.store(true, Ordering::Release);
Ok(())
},
)
.await?;
shared.store(true, Ordering::Release);
Ok::<(), anyhow::Error>(())
};
tokio::pin!(future);
tokio::select! {
_ = transport.complete_started.notified() => {}
result = &mut future => panic!("Completion did not wait: {result:?}"),
}
authorization.control.deny();
transport.complete_response.notify_one();
assert!(future.await.unwrap_err().to_string().contains("cancelled"));
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
assert!(!published.load(Ordering::Acquire));
assert!(!deleted.load(Ordering::Acquire));
assert!(!shared.load(Ordering::Acquire));
}
#[tokio::test]
async fn segmented_prefetch_response_after_revocation_cannot_start_more_uploads() {
for pause_at in [1, 2] {
let transport = FakeSegmentTransport::default();
transport
.delay_prefetch_at
.store(pause_at, Ordering::Release);
let authorization = CompletionAuthorization::new();
authorization.permit.send(()).unwrap();
let (sender, receiver) = flume::unbounded();
sender
.send(segment_event(0, 0.0, true, SegmentMediaType::Video))
.unwrap();
sender
.send(segment_event(20, 1.0, false, SegmentMediaType::Video))
.unwrap();
drop(sender);
let future = upload_segments(
&transport,
"revoked-prefetch",
receiver,
authorization.control.cancel.clone(),
Some(authorization.required),
);
tokio::pin!(future);
tokio::select! {
_ = transport.prefetch_started.notified() => {}
result = &mut future => panic!("Prefetch did not wait: {result:?}"),
}
let uploaded = transport.uploaded.load(Ordering::Acquire);
authorization.control.deny();
transport.prefetch_response.notify_one();
assert!(future.await.unwrap_err().contains("cancelled"));
assert_eq!(transport.uploaded.load(Ordering::Acquire), uploaded);
assert_eq!(transport.prefetch_count.load(Ordering::Acquire), pause_at);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
}
}
#[tokio::test]
async fn segmented_retry_delay_observes_revocation_before_next_request() {
let cancel = AtomicBool::new(false);
let requested = AtomicBool::new(false);
let future = async {
segment_retry_delay(&cancel, Duration::from_millis(20)).await?;
checked_segment_step(&cancel, || async {
requested.store(true, Ordering::Release);
Ok(())
})
.await
};
tokio::pin!(future);
assert!(
tokio::time::timeout(Duration::from_millis(1), &mut future)
.await
.is_err()
);
cancel.store(true, Ordering::Release);
assert!(future.await.unwrap_err().contains("cancelled"));
assert!(!requested.load(Ordering::Acquire));
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn segmented_screenshot_uses_shared_revocation_before_reading_file() {
let authorization = CompletionAuthorization::new();
let control = authorization.control.clone();
let upload = InstantUpload {
video: VideoUploadInfo {
id: "cancelled-thumbnail".into(),
link: "https://example.invalid/s/cancelled-thumbnail".into(),
config: S3UploadMeta {
id: "cancelled-thumbnail".into(),
},
},
segment_upload: None,
cancel: control.cancel.clone(),
metadata_lock: Arc::new(Mutex::new(())),
completion_permit: Some(authorization.permit),
completion_control: Some(control.clone()),
bridge: None,
ownership: None,
prior_attempts: 0,
request_context: None,
reads: Arc::new(UploadReads::default()),
};
control.deny();
assert!(
upload
.screenshot_upload(Path::new("/not-a-recording/cancelled.cap"))
.await
.unwrap_err()
.contains("Export cancelled")
);
}
#[tokio::test]
async fn segmented_presign_response_revocation_prevents_following_put() {
let cancel = AtomicBool::new(false);
let put_started = AtomicBool::new(false);
let (response, received) = tokio::sync::oneshot::channel();
let future = async {
optional_upload_step(Some(&cancel), || async {
received.await.unwrap();
Ok(())
})
.await?;
optional_upload_step(Some(&cancel), || async {
put_started.store(true, Ordering::Release);
Ok(())
})
.await
};
tokio::pin!(future);
assert!(
tokio::time::timeout(Duration::from_millis(1), &mut future)
.await
.is_err()
);
cancel.store(true, Ordering::Release);
response.send(()).unwrap();
assert!(future.await.is_err());
assert!(!put_started.load(Ordering::Acquire));
}
#[tokio::test]
async fn closed_capture_events_wait_for_successful_stop_permission_before_complete() {
let transport = FakeSegmentTransport::default();
let authorization = CompletionAuthorization::new();
let future = upload_segments(
&transport,
"owned-attempt",
closed_segment_events(),
Arc::new(AtomicBool::new(false)),
Some(authorization.required),
);
tokio::pin!(future);
assert!(
tokio::time::timeout(Duration::from_millis(10), &mut future)
.await
.is_err()
);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(
transport
.manifests
.lock()
.unwrap()
.iter()
.all(|complete| !complete)
);
authorization.permit.send(()).unwrap();
future.await.unwrap();
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
assert_eq!(transport.manifests.lock().unwrap().last(), Some(&true));
}
#[tokio::test]
async fn failed_stop_denies_completion_even_after_all_segments_uploaded() {
let transport = FakeSegmentTransport::default();
let authorization = CompletionAuthorization::new();
let future = upload_segments(
&transport,
"failed-attempt",
closed_segment_events(),
Arc::new(AtomicBool::new(false)),
Some(authorization.required),
);
tokio::pin!(future);
assert!(
tokio::time::timeout(Duration::from_millis(10), &mut future)
.await
.is_err()
);
assert_eq!(transport.uploaded.load(Ordering::Acquire), 2);
drop(authorization.permit);
assert!(future.await.unwrap_err().contains("not authorized"));
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(
transport
.manifests
.lock()
.unwrap()
.iter()
.all(|complete| !complete)
);
}
#[tokio::test(start_paused = true)]
async fn cancelled_or_failed_upload_cannot_complete_with_a_queued_permission() {
for fail_segment in [false, true] {
let transport = FakeSegmentTransport::default();
transport
.fail_segment
.store(fail_segment, Ordering::Release);
let authorization = CompletionAuthorization::new();
authorization.permit.send(()).unwrap();
assert!(
upload_segments(
&transport,
"failed-attempt",
closed_segment_events(),
Arc::new(AtomicBool::new(!fail_segment)),
Some(authorization.required)
)
.await
.is_err()
);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(
transport
.manifests
.lock()
.unwrap()
.iter()
.all(|complete| !complete)
);
}
}
#[tokio::test]
async fn permission_from_an_old_attempt_cannot_release_a_new_attempt() {
let old = CompletionAuthorization::new();
drop(old.required);
let current = CompletionAuthorization::new();
let transport = FakeSegmentTransport::default();
let future = upload_segments(
&transport,
"new-attempt",
closed_segment_events(),
Arc::new(AtomicBool::new(false)),
Some(current.required),
);
tokio::pin!(future);
assert!(old.permit.send(()).is_err());
assert!(
tokio::time::timeout(Duration::from_millis(10), &mut future)
.await
.is_err()
);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
current.permit.send(()).unwrap();
future.await.unwrap();
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
}
#[tokio::test]
async fn legacy_upload_without_authorization_preserves_channel_close_completion() {
let transport = FakeSegmentTransport::default();
upload_segments(
&transport,
"legacy-attempt",
closed_segment_events(),
Arc::new(AtomicBool::new(false)),
None,
)
.await
.unwrap();
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
}
#[tokio::test]
async fn aborting_upload_revokes_its_completion_permission_before_retry() {
let authorization = CompletionAuthorization::new();
let mut upload = InstantUpload {
video: VideoUploadInfo {
id: "cancelled".into(),
link: "https://example.invalid/s/cancelled".into(),
config: S3UploadMeta {
id: "cancelled".into(),
},
},
segment_upload: None,
cancel: Arc::new(AtomicBool::new(false)),
metadata_lock: Arc::new(Mutex::new(())),
completion_permit: Some(authorization.permit),
completion_control: Some(authorization.control),
bridge: None,
ownership: None,
prior_attempts: 0,
request_context: None,
reads: Arc::new(UploadReads::default()),
};
upload.abort_segments().await;
assert!(authorization.required.permission.await.is_err());
assert!(upload.authorize_completion().is_err());
}
#[tokio::test]
async fn revocation_wakes_pending_completion_without_upload_mutex_or_permit_drop() {
let authorization = CompletionAuthorization::new();
let transport = FakeSegmentTransport::default();
let future = upload_segments(
&transport,
"revoked-attempt",
closed_segment_events(),
authorization.control.cancel.clone(),
Some(authorization.required),
);
tokio::pin!(future);
assert!(
tokio::time::timeout(Duration::from_millis(10), &mut future)
.await
.is_err()
);
authorization.control.deny();
assert!(
tokio::time::timeout(Duration::from_secs(1), future)
.await
.unwrap()
.is_err()
);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(
transport
.manifests
.lock()
.unwrap()
.iter()
.all(|complete| !complete)
);
assert!(authorization.permit.send(()).is_err());
}
#[tokio::test]
async fn finalized_manifest_must_match_all_required_local_segments() {
for missing_audio in [false, true] {
let transport = FakeSegmentTransport::default();
let authorization = CompletionAuthorization::new();
let mut expected = SegmentUploadManifest::default();
expected.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
expected.record(&segment_event(1, 1.0, false, SegmentMediaType::Video));
if missing_audio {
expected.record(&segment_event(0, 0.0, true, SegmentMediaType::Audio));
expected.record(&segment_event(1, 1.0, false, SegmentMediaType::Audio));
}
expected.is_complete = true;
*authorization.control.expected_manifest.lock().unwrap() = Some(expected);
authorization.permit.send(()).unwrap();
let result = upload_segments(
&transport,
"same-video",
closed_segment_events(),
authorization.control.cancel.clone(),
Some(authorization.required),
)
.await;
assert_eq!(result.is_err(), missing_audio);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert_eq!(
transport.manifests.lock().unwrap().contains(&true),
!missing_audio
);
}
}
fn audio_video_segment_events() -> (
flume::Receiver<SegmentCompletedEvent>,
SegmentUploadManifest,
) {
let (sender, receiver) = flume::unbounded();
let mut expected = SegmentUploadManifest::default();
for media_type in [SegmentMediaType::Video, SegmentMediaType::Audio] {
for index in 0..3 {
let event = segment_event(index, f64::from(index), index == 0, media_type);
expected.record(&event);
sender.send(event).unwrap();
}
}
expected.is_complete = true;
(receiver, expected)
}
#[tokio::test(start_paused = true)]
async fn segment_failing_past_its_attempts_is_retried_into_the_final_manifest() {
let transport = FakeSegmentTransport::default();
transport.retryable_failures.store(4, Ordering::Release);
let authorization = CompletionAuthorization::new();
let (events, expected) = audio_video_segment_events();
*authorization.control.expected_manifest.lock().unwrap() = Some(expected.clone());
authorization.permit.send(()).unwrap();
let started = tokio::time::Instant::now();
upload_segments(
&transport,
"flaky-network",
events,
authorization.control.cancel.clone(),
Some(authorization.required),
)
.await
.unwrap();
assert!(started.elapsed() < SEGMENT_RETRY_WINDOW);
assert_eq!(transport.segment_calls.load(Ordering::Acquire), 10);
assert_eq!(transport.uploaded.load(Ordering::Acquire), 6);
assert_eq!(
transport.last_manifest.lock().unwrap().as_ref(),
Some(&expected)
);
}
#[tokio::test(start_paused = true)]
async fn successful_upload_retries_deferred_segments_without_waiting_for_backoff() {
let transport = FakeSegmentTransport::default();
transport.retryable_failures.store(1, Ordering::Release);
let (sender, events) = flume::unbounded();
sender
.send(segment_event(0, 0.0, true, SegmentMediaType::Video))
.unwrap();
let future = upload_segments(
&transport,
"recovered-network",
events,
Arc::new(AtomicBool::new(false)),
None,
);
tokio::pin!(future);
tokio::select! {
_ = transport.segment_failed.notified() => {}
result = &mut future => panic!("Upload ended before the init segment failed: {result:?}"),
}
let started = tokio::time::Instant::now();
sender
.send(segment_event(1, 1.0, false, SegmentMediaType::Video))
.unwrap();
drop(sender);
future.await.unwrap();
assert_eq!(started.elapsed(), Duration::ZERO);
assert_eq!(transport.segment_calls.load(Ordering::Acquire), 3);
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
let manifest = transport.last_manifest.lock().unwrap().clone().unwrap();
assert!(manifest.is_complete && manifest.video_init_uploaded);
assert_eq!(manifest.video_segments.len(), 1);
}
#[tokio::test]
async fn progress_manifest_failure_does_not_end_the_live_upload() {
let transport = FakeSegmentTransport::default();
transport
.manifest_failures
.store(usize::MAX, Ordering::Release);
upload_segments(
&transport,
"manifest-blip",
closed_segment_events(),
Arc::new(AtomicBool::new(false)),
None,
)
.await
.unwrap();
assert_eq!(transport.manifest_attempts.load(Ordering::Acquire), 2);
assert_eq!(*transport.manifests.lock().unwrap(), vec![true]);
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
}
#[tokio::test(start_paused = true)]
async fn segment_that_never_uploads_fails_the_run_after_the_retry_window() {
let transport = FakeSegmentTransport::default();
transport.fail_segment.store(true, Ordering::Release);
let authorization = CompletionAuthorization::new();
authorization.permit.send(()).unwrap();
let started = tokio::time::Instant::now();
let error = upload_segments(
&transport,
"offline",
closed_segment_events(),
authorization.control.cancel.clone(),
Some(authorization.required),
)
.await
.unwrap_err();
assert!(error.contains("segment upload failed"));
assert_eq!(started.elapsed(), SEGMENT_RETRY_WINDOW);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(transport.manifests.lock().unwrap().is_empty());
}
#[tokio::test(start_paused = true)]
async fn stalled_retry_cannot_outlive_the_retry_window() {
let transport = FakeSegmentTransport::default();
transport.retryable_failures.store(1, Ordering::Release);
transport.stall_retries.store(true, Ordering::Release);
let (sender, events) = flume::unbounded();
sender
.send(segment_event(0, 0.0, true, SegmentMediaType::Video))
.unwrap();
drop(sender);
let started = tokio::time::Instant::now();
let error = upload_segments(
&transport,
"stalled-retry",
events,
Arc::new(AtomicBool::new(false)),
None,
)
.await
.unwrap_err();
assert!(error.contains("segment upload failed"), "{error}");
assert_eq!(started.elapsed(), SEGMENT_RETRY_WINDOW);
assert_eq!(transport.segment_calls.load(Ordering::Acquire), 2);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
}
#[tokio::test(start_paused = true)]
async fn deferred_segments_beyond_the_upload_limit_still_back_off() {
let transport = FakeSegmentTransport::default();
transport.fail_segment.store(true, Ordering::Release);
let segments = 2 * MAX_SEGMENT_UPLOADS as u32;
let (sender, events) = flume::unbounded();
for index in 0..segments {
sender
.send(segment_event(
index,
f64::from(index),
index == 0,
SegmentMediaType::Video,
))
.unwrap();
}
drop(sender);
let mut rounds = 1;
let mut elapsed = Duration::ZERO;
for round in 0.. {
elapsed += segment_retry_backoff(round);
if elapsed >= SEGMENT_RETRY_WINDOW {
break;
}
rounds += 1;
}
transport
.segment_call_limit
.store(segments as usize * rounds, Ordering::Release);
let error = upload_segments(
&transport,
"long-outage",
events,
Arc::new(AtomicBool::new(false)),
None,
)
.await
.unwrap_err();
assert!(error.contains("segment upload failed"), "{error}");
}
#[tokio::test(start_paused = true)]
async fn revocation_while_a_segment_waits_for_retry_aborts_promptly() {
let transport = FakeSegmentTransport::default();
transport.fail_segment.store(true, Ordering::Release);
let authorization = CompletionAuthorization::new();
authorization.permit.send(()).unwrap();
let future = upload_segments(
&transport,
"revoked-during-retry",
closed_segment_events(),
authorization.control.cancel.clone(),
Some(authorization.required),
);
tokio::pin!(future);
tokio::select! {
_ = transport.segment_failed.notified() => {}
result = &mut future => panic!("Upload ended before a segment failed: {result:?}"),
}
let calls = transport.segment_calls.load(Ordering::Acquire);
authorization.control.deny();
let result = tokio::time::timeout(Duration::from_millis(1), future)
.await
.expect("revocation waited for the segment retry backoff");
assert!(result.is_err());
assert_eq!(transport.segment_calls.load(Ordering::Acquire), calls);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(transport.manifests.lock().unwrap().is_empty());
}
#[tokio::test(start_paused = true)]
async fn authentication_failure_still_ends_the_live_upload_immediately() {
let transport = FakeSegmentTransport::default();
transport.fatal_segment.store(true, Ordering::Release);
let authorization = CompletionAuthorization::new();
authorization.permit.send(()).unwrap();
let started = tokio::time::Instant::now();
let error = upload_segments(
&transport,
"signed-out",
closed_segment_events(),
authorization.control.cancel.clone(),
Some(authorization.required),
)
.await
.unwrap_err();
assert!(error.contains("Authentication expired"));
assert_eq!(started.elapsed(), Duration::ZERO);
assert_eq!(transport.segment_calls.load(Ordering::Acquire), 1);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
}
#[tokio::test(start_paused = true)]
async fn permanent_http_failure_ends_the_live_upload_without_deferral() {
for status in [
StatusCode::NOT_FOUND,
StatusCode::FORBIDDEN,
StatusCode::GONE,
] {
let transport = FakeSegmentTransport::default();
*transport.status_failure.lock().unwrap() = Some(status);
let authorization = CompletionAuthorization::new();
authorization.permit.send(()).unwrap();
let started = tokio::time::Instant::now();
let error = upload_segments(
&transport,
"deleted-video",
closed_segment_events(),
authorization.control.cancel.clone(),
Some(authorization.required),
)
.await
.unwrap_err();
assert!(error.contains(status.as_str()), "{error}");
assert_eq!(started.elapsed(), Duration::ZERO);
assert_eq!(transport.segment_calls.load(Ordering::Acquire), 1);
assert_eq!(transport.completed.load(Ordering::Acquire), 0);
assert!(transport.manifests.lock().unwrap().is_empty());
}
}
#[tokio::test(start_paused = true)]
async fn transient_http_failure_is_deferred_until_it_uploads() {
let transport = FakeSegmentTransport::default();
*transport.status_failure.lock().unwrap() = Some(StatusCode::SERVICE_UNAVAILABLE);
let future = upload_segments(
&transport,
"server-blip",
closed_segment_events(),
Arc::new(AtomicBool::new(false)),
None,
);
tokio::pin!(future);
tokio::select! {
_ = tokio::time::sleep(Duration::from_secs(10)) => {}
result = &mut future => panic!("A 503 ended the live upload: {result:?}"),
}
assert!(transport.segment_calls.load(Ordering::Acquire) > 2);
*transport.status_failure.lock().unwrap() = None;
future.await.unwrap();
assert_eq!(transport.completed.load(Ordering::Acquire), 1);
assert_eq!(transport.manifests.lock().unwrap().last(), Some(&true));
}
#[test]
fn only_transient_failures_are_deferred_for_retry() {
let status = |code: u16| {
segment_error_is_retryable(&AuthApiError::Status(
StatusCode::from_u16(code).unwrap(),
format!("upload failed: {code}"),
))
};
assert!(!segment_error_is_retryable(
&AuthApiError::InvalidAuthentication
));
assert!(!segment_error_is_retryable(&AuthApiError::UpgradeRequired));
for permanent in [400, 401, 402, 403, 404, 410, 413, 422] {
assert!(!status(permanent), "{permanent} must not be deferred");
}
for transient in [408, 429, 500, 502, 503, 504] {
assert!(status(transient), "{transient} must be deferred");
}
assert!(segment_error_is_retryable(&AuthApiError::Timeout));
assert!(segment_error_is_retryable(&AuthApiError::Other(
"error sending request".into()
)));
}
#[test]
fn status_failures_keep_their_previous_messages() {
assert_eq!(
AuthApiError::Status(StatusCode::NOT_FOUND, "api/upload_signed/404".into()).to_string(),
"api/upload_signed/404"
);
}
#[test]
fn deferred_segment_backoff_doubles_up_to_its_cap() {
let delays: Vec<_> = [0, 1, 2, 3, 4, 40]
.map(|round| segment_retry_backoff(round).as_secs())
.into();
assert_eq!(delays, vec![2, 4, 8, 16, 30, 30]);
}
#[tokio::test]
async fn cancelling_upload_waits_for_its_blocking_file_read() {
let reads = Arc::new(UploadReads::default());
let (started, entered) = tokio::sync::oneshot::channel();
let (release, released) = std::sync::mpsc::channel();
let task = tokio::spawn(with_upload_context(None, reads.clone(), async move {
tracked_upload_read(move || {
started.send(()).unwrap();
released.recv().unwrap();
})
.await
.unwrap();
}));
entered.await.unwrap();
task.abort();
assert!(task.await.unwrap_err().is_cancelled());
let still_reading = tokio::time::timeout(Duration::from_millis(10), reads.join())
.await
.is_err();
release.send(()).unwrap();
tokio::time::timeout(Duration::from_secs(1), reads.join())
.await
.unwrap();
assert!(still_reading);
assert_eq!(reads.active.load(Ordering::Acquire), 0);
}
}
#[cfg(test)]
mod replacement_upload_restart_tests {
use super::*;
use std::sync::atomic::AtomicUsize;
#[test]
fn only_legacy_replacements_capture_a_restart_source() {
assert!(is_legacy_replacement_upload(true, "raw-s3-upload"));
assert!(is_legacy_replacement_upload(
true,
"https://googleapis.com/upload/legacy"
));
assert!(!is_legacy_replacement_upload(false, "raw-s3-upload"));
assert!(!is_legacy_replacement_upload(
true,
"cap-reupload.signed-token"
));
assert!(!is_legacy_replacement_upload(true, "cap-reupload."));
}
#[test]
fn only_the_exact_conflict_code_requests_a_restart() {
let body = json!({ "code": "REPLACEMENT_RESTART_REQUIRED" });
assert!(replacement_restart_required(StatusCode::CONFLICT, &body));
for status in [
StatusCode::OK,
StatusCode::BAD_REQUEST,
StatusCode::INTERNAL_SERVER_ERROR,
] {
assert!(!replacement_restart_required(status, &body));
}
for body in [
Value::Null,
json!({}),
json!({ "error": "REPLACEMENT_RESTART_REQUIRED" }),
json!({ "code": "OTHER_CONFLICT" }),
json!({ "code": "replacement_restart_required" }),
json!({ "code": ["REPLACEMENT_RESTART_REQUIRED"] }),
json!({ "code": "REPLACEMENT_RESTART_REQUIRED extra" }),
] {
assert!(!replacement_restart_required(StatusCode::CONFLICT, &body));
}
}
#[tokio::test]
async fn restarts_the_whole_replacement_once_and_returns_only_the_second_identity() {
let cancel = AtomicBool::new(false);
let events = Mutex::new(Vec::new());
let cancel = &cancel;
let events = &events;
let result = retry_replacement_upload(true, cancel, 0usize, |attempt| async move {
checked_upload_step(cancel, || async {
events.lock().unwrap().push((attempt, "initiate"));
Ok(())
})
.await?;
checked_upload_step(cancel, || async {
events.lock().unwrap().push((attempt, "parts"));
Ok(())
})
.await?;
checked_upload_step(cancel, || async {
events.lock().unwrap().push((attempt, "complete"));
Ok(if attempt == 0 {
ReplacementUploadAttempt::RestartRequired(1)
} else {
ReplacementUploadAttempt::Completed("new-object-identity")
})
})
.await
})
.await
.unwrap();
assert_eq!(result, "new-object-identity");
assert_eq!(
*events.lock().unwrap(),
[
(0, "initiate"),
(0, "parts"),
(0, "complete"),
(1, "initiate"),
(1, "parts"),
(1, "complete"),
]
);
}
#[tokio::test]
async fn restart_requires_a_signed_session_before_any_further_upload_work() {
for upload_id in ["legacy-again", "cap-reupload.signed"] {
let uploads = AtomicUsize::new(0);
let uploads = &uploads;
let result = retry_replacement_upload(
true,
&AtomicBool::new(false),
false,
|restarted| async move {
validate_replacement_restart_session(
restarted,
if restarted { upload_id } else { "legacy-first" },
)?;
uploads.fetch_add(1, Ordering::AcqRel);
Ok(if restarted {
ReplacementUploadAttempt::Completed(())
} else {
ReplacementUploadAttempt::RestartRequired(true)
})
},
)
.await;
assert_eq!(result.is_ok(), upload_id.starts_with("cap-reupload."));
assert_eq!(
uploads.load(Ordering::Acquire),
if result.is_ok() { 2 } else { 1 }
);
}
}
#[tokio::test]
async fn repeated_restart_requests_fail_after_two_attempts() {
let attempts = AtomicUsize::new(0);
let result: Result<(), _> =
retry_replacement_upload(true, &AtomicBool::new(false), (), |()| async {
attempts.fetch_add(1, Ordering::AcqRel);
Ok(ReplacementUploadAttempt::RestartRequired(()))
})
.await;
assert!(
result
.unwrap_err()
.to_string()
.contains("REPLACEMENT_RESTART_REQUIRED")
);
assert_eq!(attempts.load(Ordering::Acquire), 2);
}
#[tokio::test]
async fn first_uploads_and_other_errors_do_not_restart() {
let attempts = AtomicUsize::new(0);
let result: Result<(), _> =
retry_replacement_upload(false, &AtomicBool::new(false), (), |()| async {
attempts.fetch_add(1, Ordering::AcqRel);
Ok(ReplacementUploadAttempt::RestartRequired(()))
})
.await;
assert!(result.is_err());
assert_eq!(attempts.load(Ordering::Acquire), 1);
for message in [
"api/upload_multipart_complete/409",
"api/upload_multipart_complete/500",
"Failed to read export chunk",
] {
attempts.store(0, Ordering::Release);
let result: Result<(), _> =
retry_replacement_upload(true, &AtomicBool::new(false), (), |()| async {
attempts.fetch_add(1, Ordering::AcqRel);
Err(AuthApiError::Other(message.into()))
})
.await;
assert_eq!(result.unwrap_err().to_string(), message);
assert_eq!(attempts.load(Ordering::Acquire), 1);
}
}
#[tokio::test]
async fn cancellation_before_upload_prevents_both_attempts() {
let result: Result<(), _> =
retry_replacement_upload(true, &AtomicBool::new(true), (), |()| async {
panic!("Cancelled upload must not initiate")
})
.await;
assert!(result.unwrap_err().to_string().contains("Export cancelled"));
}
#[tokio::test]
async fn cancellation_during_the_conflict_response_prevents_restart() {
let cancel = Arc::new(AtomicBool::new(false));
let attempts = Arc::new(AtomicUsize::new(0));
let worker_cancel = cancel.clone();
let worker_attempts = attempts.clone();
let (entered, entered_rx) = tokio::sync::oneshot::channel();
let (release, released) = tokio::sync::oneshot::channel();
let worker = tokio::spawn(async move {
let mut entered = Some(entered);
let mut released = Some(released);
retry_replacement_upload(true, &worker_cancel, (), |()| {
worker_attempts.fetch_add(1, Ordering::AcqRel);
let entered = entered.take().unwrap();
let released = released.take().unwrap();
async move {
entered.send(()).unwrap();
released.await.unwrap();
Ok(ReplacementUploadAttempt::<(), _>::RestartRequired(()))
}
})
.await
});
entered_rx.await.unwrap();
cancel.store(true, Ordering::Release);
release.send(()).unwrap();
assert!(
worker
.await
.unwrap()
.unwrap_err()
.to_string()
.contains("Export cancelled")
);
assert_eq!(attempts.load(Ordering::Acquire), 1);
}
#[tokio::test]
async fn cancellation_during_restarted_parts_prevents_completion() {
let cancel = AtomicBool::new(false);
let completed = AtomicUsize::new(0);
let cancel = &cancel;
let completed = &completed;
let result: Result<(), _> =
retry_replacement_upload(true, cancel, 0, |attempt| async move {
if attempt == 0 {
return Ok(ReplacementUploadAttempt::RestartRequired(1));
}
checked_upload_step(cancel, || async {
cancel.store(true, Ordering::Release);
Ok(())
})
.await?;
checked_upload_step(cancel, || async {
completed.fetch_add(1, Ordering::AcqRel);
Ok(ReplacementUploadAttempt::Completed(()))
})
.await
})
.await;
assert!(result.unwrap_err().to_string().contains("Export cancelled"));
assert_eq!(completed.load(Ordering::Acquire), 0);
}
fn source() -> ReplacementUploadSource {
ReplacementUploadSource {
file: ReplacementUploadFile {
path: PathBuf::from("export.mp4"),
size: 6,
modified: std::time::SystemTime::UNIX_EPOCH,
},
chunks: Vec::new(),
sealed: false,
}
}
fn parts() -> Vec<UploadedPart> {
(1..=2)
.map(|part_number| UploadedPart {
part_number,
etag: format!("part-{part_number}"),
size: 3,
object_identity: None,
})
.collect()
}
#[test]
fn restarted_reads_match_the_original_bytes_offsets_and_total() {
let mut source = source();
source.check_chunk(1, 0, b"abc", 6).unwrap();
source.check_chunk(2, 3, b"def", 6).unwrap();
source.seal_parts(&parts()).unwrap();
source.check_chunk(1, 0, b"abc", 6).unwrap();
source.check_chunk(2, 3, b"def", 6).unwrap();
assert!(source.check_chunk(1, 0, b"abd", 6).is_err());
assert!(source.check_chunk(1, 1, b"abc", 6).is_err());
assert!(source.check_chunk(1, 0, b"abc", 7).is_err());
assert!(source.check_chunk(3, 6, b"ghi", 6).is_err());
assert!(source.check_chunk(0, 0, b"abc", 6).is_err());
assert!(source.check_chunk(1, 0, b"", 6).is_err());
}
#[test]
fn completion_requires_the_full_contiguous_original_part_inventory() {
let mut source = source();
assert!(source.check_chunk(2, 0, b"abc", 6).is_err());
source.check_chunk(1, 0, b"abc", 6).unwrap();
assert!(source.seal_parts(&parts()[..1]).is_err());
assert!(source.check_chunk(2, 4, b"def", 6).is_err());
source.check_chunk(2, 3, b"def", 6).unwrap();
let mut wrong_parts = parts();
wrong_parts[1].part_number = 1;
assert!(source.seal_parts(&wrong_parts).is_err());
wrong_parts[1].part_number = 2;
wrong_parts[1].size = 2;
assert!(source.seal_parts(&wrong_parts).is_err());
source.seal_parts(&parts()).unwrap();
}
#[test]
fn changed_file_metadata_is_rejected_before_a_fresh_initiation() {
static NEXT_FILE: AtomicUsize = AtomicUsize::new(0);
let path = std::env::temp_dir().join(format!(
"cap-gpui-replacement-{}-{}-{}.mp4",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos(),
NEXT_FILE.fetch_add(1, Ordering::AcqRel),
));
std::fs::write(&path, b"abcdef").unwrap();
let source = ReplacementUploadSource::new(&path).unwrap();
source.validate_file(&path).unwrap();
std::fs::write(&path, b"changed-file").unwrap();
let changed = source.validate_file(&path);
std::fs::remove_file(&path).unwrap();
assert!(
changed
.unwrap_err()
.to_string()
.contains("Rendered video changed")
);
}
}
#[cfg(test)]
mod exported_upload_cancellation_tests {
use super::*;
use std::sync::atomic::AtomicUsize;
#[tokio::test]
async fn cancelled_export_returns_before_auth_metadata_or_upload_submission() {
let result = upload_exported_video(
PathBuf::from("/not-a-recording/cancelled.cap"),
None,
|_| panic!("Cancelled export must not start"),
Arc::new(AtomicBool::new(true)),
)
.await;
assert!(result.unwrap_err().contains("Export cancelled"));
}
#[tokio::test]
async fn cancellation_during_an_inflight_step_prevents_following_complete_submission() {
let cancel = Arc::new(AtomicBool::new(false));
let requested = Arc::new(AtomicUsize::new(0));
let worker_cancel = cancel.clone();
let worker_requested = requested.clone();
let (entered, entered_rx) = tokio::sync::oneshot::channel();
let (release, released) = tokio::sync::oneshot::channel();
let worker = tokio::spawn(async move {
checked_upload_step(&worker_cancel, || async {
entered.send(()).unwrap();
released.await.unwrap();
Ok(())
})
.await?;
checked_upload_step(&worker_cancel, || async {
worker_requested.fetch_add(1, Ordering::AcqRel);
Ok(())
})
.await
});
entered_rx.await.unwrap();
cancel.store(true, Ordering::Release);
release.send(()).unwrap();
assert!(
worker
.await
.unwrap()
.unwrap_err()
.to_string()
.contains("Export cancelled")
);
assert_eq!(requested.load(Ordering::Acquire), 0);
}
#[tokio::test]
async fn cancellation_while_retry_waits_prevents_retry_and_complete() {
let cancel = Arc::new(AtomicBool::new(false));
let attempts = Arc::new(AtomicUsize::new(0));
let worker_cancel = cancel.clone();
let worker_attempts = attempts.clone();
let (waiting, waiting_rx) = tokio::sync::oneshot::channel();
let (release, released) = tokio::sync::oneshot::channel();
let worker = tokio::spawn(async move {
let first = checked_upload_step(&worker_cancel, || async {
worker_attempts.fetch_add(1, Ordering::AcqRel);
Err::<(), _>(AuthApiError::Other("network failure".into()))
})
.await;
assert!(first.is_err());
checked_upload_step(&worker_cancel, || async {
waiting.send(()).unwrap();
released.await.unwrap();
Ok(())
})
.await?;
checked_upload_step(&worker_cancel, || async {
worker_attempts.fetch_add(1, Ordering::AcqRel);
Ok(())
})
.await
});
waiting_rx.await.unwrap();
cancel.store(true, Ordering::Release);
release.send(()).unwrap();
assert!(worker.await.unwrap().is_err());
assert_eq!(attempts.load(Ordering::Acquire), 1);
}
#[tokio::test]
async fn instant_camera_only_export_observes_the_same_revocation_token() {
let authorization = CompletionAuthorization::new();
let control = authorization.control.clone();
let upload = InstantUpload {
video: VideoUploadInfo {
id: "camera-only".into(),
link: "https://example.invalid/s/camera-only".into(),
config: S3UploadMeta {
id: "camera-only".into(),
},
},
segment_upload: None,
cancel: control.cancel.clone(),
metadata_lock: Arc::new(Mutex::new(())),
completion_permit: Some(authorization.permit),
completion_control: Some(authorization.control),
bridge: None,
ownership: None,
prior_attempts: 0,
request_context: None,
reads: Arc::new(UploadReads::default()),
};
let token = upload.cancellation_token();
assert!(Arc::ptr_eq(&token, &control.cancel));
control.deny();
assert!(
upload_exported_video(PathBuf::new(), None, |_| {}, token)
.await
.unwrap_err()
.contains("Export cancelled")
);
}
#[tokio::test]
async fn optional_legacy_step_and_uncancelled_export_step_keep_results() {
assert_eq!(
optional_upload_step(None, || async { Ok(7) })
.await
.unwrap(),
7
);
assert_eq!(
checked_upload_step(&AtomicBool::new(false), || async { Ok(9) })
.await
.unwrap(),
9
);
let result: Result<(), _> = checked_upload_step(&AtomicBool::new(true), || async {
panic!("No new request may be submitted")
})
.await;
assert!(result.is_err());
}
}