Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

40.5 KB
Raw Blame
use cap_enc_ffmpeg::segmented_stream::{SegmentCompletedEvent, SegmentMediaType};
use serde::Deserialize;
use std::{
    collections::HashSet,
    fs, io,
    path::{Path, PathBuf},
};

#[derive(Debug)]
pub enum UploadLockError {
    Busy,
    Io(io::Error),
}

impl std::fmt::Display for UploadLockError {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Busy => formatter.write_str("Another upload owns this recording"),
            Self::Io(error) => error.fmt(formatter),
        }
    }
}

impl std::error::Error for UploadLockError {}

impl From<io::Error> for UploadLockError {
    fn from(error: io::Error) -> Self {
        Self::Io(error)
    }
}

pub struct UploadLock {
    _file: fs::File,
    project: PathBuf,
    #[cfg(unix)]
    owner_pid: libc::pid_t,
}

impl UploadLock {
    pub fn acquire(project: &Path) -> Result<Self, UploadLockError> {
        metadata(project, true).map_err(io::Error::other)?;
        let project = project.canonicalize()?;
        let parent = project
            .parent()
            .ok_or_else(|| io::Error::other("Recording has no parent directory"))?;
        let directory = parent.join(".upload-locks");
        let builder = fs::DirBuilder::new();
        #[cfg(unix)]
        let builder = {
            use std::os::unix::fs::DirBuilderExt;
            let mut builder = builder;
            builder.mode(0o700);
            builder
        };
        match builder.create(&directory) {
            Ok(()) => {}
            Err(error) if error.kind() == io::ErrorKind::AlreadyExists => {}
            Err(error) => return Err(error.into()),
        }
        let directory_meta = metadata(&directory, true).map_err(io::Error::other)?;
        #[cfg(unix)]
        {
            use std::os::unix::fs::{MetadataExt, PermissionsExt};
            if directory_meta.uid() != unsafe { libc::geteuid() }
                || directory_meta.permissions().mode() & 0o077 != 0
            {
                return Err(io::Error::other("Upload lock directory is not private").into());
            }
        }
        #[cfg(not(unix))]
        let _ = directory_meta;
        #[cfg(windows)]
        let identity = project.to_string_lossy().to_lowercase().into_bytes();
        #[cfg(not(windows))]
        let identity = project.as_os_str().as_encoded_bytes().to_vec();
        let path = directory.join(format!("{}.lock", blake3::hash(&identity).to_hex()));
        let mut options = fs::OpenOptions::new();
        options.read(true).write(true).create(true).truncate(false);
        #[cfg(unix)]
        {
            use std::os::unix::fs::OpenOptionsExt;
            options
                .mode(0o600)
                .custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC);
        }
        #[cfg(windows)]
        {
            use std::os::windows::fs::OpenOptionsExt;
            options.share_mode(0).custom_flags(0x0020_0000);
        }
        let file = options.open(&path).map_err(|error| {
            if cfg!(windows) && matches!(error.raw_os_error(), Some(32 | 33)) {
                UploadLockError::Busy
            } else {
                UploadLockError::Io(error)
            }
        })?;
        let file_meta = file.metadata()?;
        if !file_meta.is_file() || file_meta.len() != 0 {
            return Err(io::Error::other("Invalid upload lock file").into());
        }
        #[cfg(windows)]
        {
            use std::os::windows::fs::MetadataExt;
            if file_meta.file_attributes() & 0x400 != 0 {
                return Err(io::Error::other("Upload lock is a reparse point").into());
            }
        }
        #[cfg(unix)]
        {
            use std::os::{fd::AsRawFd, unix::fs::MetadataExt};
            if file_meta.nlink() != 1 || file_meta.uid() != unsafe { libc::geteuid() } {
                return Err(io::Error::other("Upload lock is not exclusively owned").into());
            }
            if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
                let error = io::Error::last_os_error();
                return Err(if error.kind() == io::ErrorKind::WouldBlock {
                    UploadLockError::Busy
                } else {
                    UploadLockError::Io(error)
                });
            }
        }
        let lock = Self {
            _file: file,
            project,
            #[cfg(unix)]
            owner_pid: unsafe { libc::getpid() },
        };
        metadata(&lock.project, true).map_err(io::Error::other)?;
        if lock.project.canonicalize()? != lock.project {
            return Err(
                io::Error::other("Recording identity changed while acquiring upload").into(),
            );
        }
        Ok(lock)
    }

    pub fn project_path(&self) -> &Path {
        &self.project
    }
}

#[cfg(unix)]
impl Drop for UploadLock {
    fn drop(&mut self) {
        use std::os::fd::AsRawFd;

        if self.owner_pid == unsafe { libc::getpid() }
            && unsafe { libc::flock(self._file.as_raw_fd(), libc::LOCK_UN) } != 0
        {
            tracing::warn!(error = %io::Error::last_os_error(), "Failed to release upload lock");
        }
    }
}

#[derive(Deserialize)]
struct Manifest {
    version: u32,
    #[serde(rename = "type")]
    kind: String,
    init_segment: String,
    segments: Vec<Segment>,
    is_complete: bool,
}

#[derive(Deserialize)]
struct Segment {
    path: String,
    index: u32,
    duration: f64,
    is_complete: bool,
    file_size: Option<u64>,
}

fn metadata(path: &Path, directory: bool) -> Result<fs::Metadata, String> {
    let metadata =
        fs::symlink_metadata(path).map_err(|error| format!("{}: {error}", path.display()))?;
    #[cfg(windows)]
    {
        use std::os::windows::fs::MetadataExt;
        if metadata.file_attributes() & 0x400 != 0 {
            return Err(format!(
                "{}: reparse points cannot be resumed",
                path.display()
            ));
        }
    }
    if metadata.file_type().is_symlink()
        || (directory && !metadata.is_dir())
        || (!directory && (!metadata.is_file() || metadata.len() == 0))
    {
        return Err(format!(
            "{}: invalid recording file or directory",
            path.display()
        ));
    }
    Ok(metadata)
}

pub fn collect_segment_events(
    recording_dir: &Path,
    required_audio: bool,
) -> Result<Vec<SegmentCompletedEvent>, String> {
    metadata(recording_dir, true)?;
    let content = recording_dir.join("content");
    metadata(&content, true)?;
    let mut events = collect_track(&content.join("display"), SegmentMediaType::Video)?;
    let audio = content.join("audio");
    match fs::symlink_metadata(&audio) {
        Ok(_) => {
            metadata(&audio, true)?;
            let empty = fs::read_dir(&audio)
                .map_err(|error| error.to_string())?
                .next()
                .is_none();
            if required_audio || !empty {
                events.extend(collect_track(&audio, SegmentMediaType::Audio)?);
            }
        }
        Err(error) if error.kind() == std::io::ErrorKind::NotFound && !required_audio => {}
        Err(error) => return Err(format!("Required audio cannot be resumed: {error}")),
    }
    Ok(events)
}

fn collect_track(
    directory: &Path,
    media_type: SegmentMediaType,
) -> Result<Vec<SegmentCompletedEvent>, String> {
    metadata(directory, true)?;
    let manifest_path = directory.join("manifest.json");
    metadata(&manifest_path, false)?;
    let mut manifest: Manifest =
        serde_json::from_slice(&fs::read(&manifest_path).map_err(|error| error.to_string())?)
            .map_err(|error| format!("{}: {error}", manifest_path.display()))?;
    let (version, kind, stream_kind) = match media_type {
        SegmentMediaType::Video => (5, "m4s_segments", ffmpeg::media::Type::Video),
        SegmentMediaType::Audio => (2, "m4s_audio_segments", ffmpeg::media::Type::Audio),
    };
    if manifest.version != version
        || manifest.kind != kind
        || !manifest.is_complete
        || manifest.init_segment != "init.mp4"
        || manifest.segments.is_empty()
    {
        return Err(format!(
            "{}: recording manifest is not complete or supported",
            manifest_path.display()
        ));
    }
    let init = directory.join(&manifest.init_segment);
    let init_size = metadata(&init, false)?.len();
    let input =
        ffmpeg::format::input(&init).map_err(|error| format!("{}: {error}", init.display()))?;
    if input.streams().best(stream_kind).is_none() {
        return Err(format!(
            "{}: required initialization stream is missing",
            init.display()
        ));
    }
    drop(input);
    let mut events = vec![SegmentCompletedEvent {
        path: init,
        index: 0,
        duration: 0.0,
        file_size: init_size,
        is_init: true,
        media_type,
    }];
    let mut listed = HashSet::new();
    manifest.segments.sort_by_key(|segment| segment.index);
    for (position, segment) in manifest.segments.into_iter().enumerate() {
        if u64::from(segment.index) != position as u64 + 1
            || segment.path != format!("segment_{:03}.m4s", segment.index)
            || !segment.is_complete
            || !segment.duration.is_finite()
            || segment.duration <= 0.0
            || !listed.insert(segment.path.clone())
        {
            return Err(format!(
                "{}: invalid or incomplete segment entry",
                manifest_path.display()
            ));
        }
        let file_size = segment.file_size.filter(|size| *size > 0).ok_or_else(|| {
            format!(
                "{}: completed segment has no recorded byte count",
                manifest_path.display()
            )
        })?;
        let path = directory.join(&segment.path);
        if metadata(&path, false)?.len() != file_size {
            return Err(format!(
                "{}: recorded segment size does not match",
                path.display()
            ));
        }
        if !cap_enc_ffmpeg::fragmented_mp4::tail_is_complete(&path)
            .map_err(|error| error.to_string())?
        {
            return Err(format!("{}: fragment is incomplete", path.display()));
        }
        events.push(SegmentCompletedEvent {
            path,
            index: segment.index,
            duration: segment.duration,
            file_size,
            is_init: false,
            media_type,
        });
    }
    for entry in fs::read_dir(directory).map_err(|error| error.to_string())? {
        let entry = entry.map_err(|error| error.to_string())?;
        let name = entry.file_name();
        let name = name.to_string_lossy();
        if (name.ends_with(".m4s") && !listed.contains(name.as_ref())) || name.ends_with(".m4s.tmp")
        {
            return Err(format!(
                "{}: unlisted or unfinished recording media",
                entry.path().display()
            ));
        }
        let attributes = entry.file_type().map_err(|error| error.to_string())?;
        if attributes.is_symlink() {
            return Err(format!(
                "{}: linked recording input",
                entry.path().display()
            ));
        }
    }
    Ok(events)
}

/// Seals the manifest of a track whose recording was interrupted, so its
/// upload can resume from what was saved. Keeps the run of segments from
/// `segment_001` that every check in `collect_track` accepts, renames the
/// unfinished tail and any other media the sealed manifest does not list to
/// `<name>.unsealed` (never deleting it), and marks the manifest complete.
/// Returns how many segments it kept. A manifest that is already complete is
/// left as it is, so sealing twice changes nothing.
pub fn seal_interrupted_track(
    directory: &Path,
    media_type: SegmentMediaType,
) -> Result<usize, String> {
    metadata(directory, true)?;
    let manifest_path = directory.join("manifest.json");
    metadata(&manifest_path, false)?;
    let bytes = fs::read(&manifest_path).map_err(|error| error.to_string())?;
    let manifest: Manifest = serde_json::from_slice(&bytes)
        .map_err(|error| format!("{}: {error}", manifest_path.display()))?;
    let (version, kind, stream_kind) = match media_type {
        SegmentMediaType::Video => (5, "m4s_segments", ffmpeg::media::Type::Video),
        SegmentMediaType::Audio => (2, "m4s_audio_segments", ffmpeg::media::Type::Audio),
    };
    if manifest.version != version || manifest.kind != kind || manifest.init_segment != "init.mp4" {
        return Err(format!(
            "{}: recording manifest is not supported",
            manifest_path.display()
        ));
    }
    if manifest.is_complete {
        return Ok(manifest.segments.len());
    }
    let init = directory.join(&manifest.init_segment);
    metadata(&init, false)?;
    let input =
        ffmpeg::format::input(&init).map_err(|error| format!("{}: {error}", init.display()))?;
    if input.streams().best(stream_kind).is_none() {
        return Err(format!(
            "{}: required initialization stream is missing",
            init.display()
        ));
    }
    drop(input);

    let mut raw: serde_json::Value = serde_json::from_slice(&bytes)
        .map_err(|error| format!("{}: {error}", manifest_path.display()))?;
    let mut entries: Vec<(Segment, serde_json::Value)> = manifest
        .segments
        .into_iter()
        .zip(
            raw["segments"]
                .as_array()
                .cloned()
                .ok_or_else(|| format!("{}: segments missing", manifest_path.display()))?,
        )
        .collect();
    entries.sort_by_key(|(segment, _)| segment.index);
    let mut kept = Vec::new();
    let mut total_duration = 0.0;
    for (position, (segment, entry)) in entries.into_iter().enumerate() {
        let path = directory.join(&segment.path);
        let usable = u64::from(segment.index) == position as u64 + 1
            && segment.path == format!("segment_{:03}.m4s", segment.index)
            && segment.is_complete
            && segment.duration.is_finite()
            && segment.duration > 0.0
            && segment.file_size.is_some_and(|size| size > 0)
            && metadata(&path, false).is_ok_and(|actual| Some(actual.len()) == segment.file_size)
            && cap_enc_ffmpeg::fragmented_mp4::tail_is_complete(&path).unwrap_or(false);
        if !usable {
            break;
        }
        total_duration += segment.duration;
        kept.push((segment.path, entry));
    }
    if kept.is_empty() {
        return Err(format!(
            "{}: no complete segments to resume",
            manifest_path.display()
        ));
    }

    let listed: HashSet<&str> = kept.iter().map(|(path, _)| path.as_str()).collect();
    let mut set_aside = Vec::new();
    for entry in fs::read_dir(directory).map_err(|error| error.to_string())? {
        let entry = entry.map_err(|error| error.to_string())?;
        let name = entry.file_name().to_string_lossy().into_owned();
        let media = name.ends_with(".m4s") || name.ends_with(".m4s.tmp");
        if !media || listed.contains(name.as_str()) {
            continue;
        }
        if entry
            .file_type()
            .map_err(|error| error.to_string())?
            .is_symlink()
        {
            return Err(format!(
                "{}: linked recording input",
                entry.path().display()
            ));
        }
        set_aside.push(entry.path());
    }
    for path in set_aside {
        let target = path.with_file_name(format!(
            "{}.unsealed",
            path.file_name().unwrap_or_default().to_string_lossy()
        ));
        if target.exists() {
            return Err(format!("{}: already set aside", target.display()));
        }
        fs::rename(&path, &target).map_err(|error| format!("{}: {error}", path.display()))?;
    }

    let count = kept.len();
    raw["segments"] = serde_json::Value::Array(kept.into_iter().map(|(_, entry)| entry).collect());
    raw["total_duration"] = serde_json::json!(total_duration);
    raw["is_complete"] = serde_json::Value::Bool(true);
    let sealed = serde_json::to_vec(&raw).map_err(|error| error.to_string())?;
    let temporary = directory.join(format!(".manifest-{}.sealing", uuid::Uuid::new_v4()));
    fs::write(&temporary, sealed).map_err(|error| error.to_string())?;
    if let Err(error) = fs::rename(&temporary, &manifest_path) {
        let _ = fs::remove_file(&temporary);
        return Err(format!("{}: {error}", manifest_path.display()));
    }
    Ok(count)
}

#[cfg(test)]
mod tests {
    use super::*;
    use cap_enc_ffmpeg::{
        dash_audio::{DashAudioSegmentEncoder, DashAudioSegmentEncoderConfig},
        segmented_stream::{SegmentedVideoEncoder, SegmentedVideoEncoderConfig},
    };
    use std::{path::PathBuf, sync::OnceLock, time::Duration};

    const ROUND_TRIP_DURATIONS: [(u64, &str, u64); 4] = [
        (2_017_793_167, "2.0177931669999998", 0x4000_2470_be72_dbae),
        (2_014_456_625, "2.0144566250000002", 0x4000_1d9b_6f5c_af2e),
        (2_013_162_750, "2.0131627500000002", 0x4000_1af5_1266_3412),
        (2_015_835_292, "2.0158352920000002", 0x4000_206e_40ea_19d4),
    ];

    #[test]
    fn legacy_manifest_durations_round_trip_without_changing_bits() {
        for (nanos, json, expected_bits) in ROUND_TRIP_DURATIONS {
            let live_duration = Duration::from_nanos(nanos).as_secs_f64();
            assert_eq!(live_duration.to_bits(), expected_bits);
            assert_eq!(serde_json::to_string(&live_duration).unwrap(), json);
            for (version, kind) in [(5, "m4s_segments"), (2, "m4s_audio_segments")] {
                let manifest_json = format!(
                    r#"{{"version":{version},"type":"{kind}","init_segment":"init.mp4","segments":[{{"path":"segment_001.m4s","index":1,"duration":{json},"is_complete":true,"file_size":1}}],"is_complete":true}}"#
                );
                let manifest: Manifest = serde_json::from_str(&manifest_json).unwrap();
                let mut duration = manifest.segments[0].duration;
                for _ in 0..16 {
                    assert_eq!(duration.to_bits(), expected_bits);
                    let serialized = serde_json::to_string(&duration).unwrap();
                    assert_eq!(serialized, json);
                    duration = serde_json::from_str(&serialized).unwrap();
                }
            }
        }
    }

    #[test]
    fn upload_lock_defers_other_owners_and_survives_bundle_deletion() {
        let directory = tempfile::tempdir().unwrap();
        let project = directory.path().join("recording.cap");
        fs::create_dir(&project).unwrap();
        fs::write(project.join("original-media"), b"retained").unwrap();
        let first = UploadLock::acquire(&project).unwrap();
        assert!(matches!(
            UploadLock::acquire(&project),
            Err(UploadLockError::Busy)
        ));
        assert_eq!(
            fs::read(project.join("original-media")).unwrap(),
            b"retained"
        );
        fs::remove_dir_all(&project).unwrap();
        fs::create_dir(&project).unwrap();
        assert!(matches!(
            UploadLock::acquire(&project),
            Err(UploadLockError::Busy)
        ));
        drop(first);
        drop(UploadLock::acquire(&project).unwrap());
        assert_eq!(
            fs::read_dir(directory.path().join(".upload-locks"))
                .unwrap()
                .count(),
            1
        );
    }

    #[cfg(unix)]
    #[test]
    fn upload_lock_releases_despite_an_inherited_descriptor() {
        let directory = tempfile::tempdir().unwrap();
        let project = directory.path().join("recording.cap");
        fs::create_dir(&project).unwrap();
        let first = UploadLock::acquire(&project).unwrap();
        let inherited = first._file.try_clone().unwrap();
        drop(first);
        let second = UploadLock::acquire(&project).unwrap();
        drop(inherited);
        assert!(matches!(
            UploadLock::acquire(&project),
            Err(UploadLockError::Busy)
        ));
        drop(second);
    }

    #[cfg(unix)]
    #[test]
    fn upload_lock_rejects_a_linked_lock_directory() {
        let directory = tempfile::tempdir().unwrap();
        let outside = tempfile::tempdir().unwrap();
        let project = directory.path().join("recording.cap");
        fs::create_dir(&project).unwrap();
        std::os::unix::fs::symlink(outside.path(), directory.path().join(".upload-locks")).unwrap();
        assert!(matches!(
            UploadLock::acquire(&project),
            Err(UploadLockError::Io(_))
        ));
        assert_eq!(fs::read_dir(outside.path()).unwrap().count(), 0);
    }

    #[cfg(windows)]
    #[test]
    fn upload_lock_normalizes_windows_path_case() {
        let directory = tempfile::tempdir().unwrap();
        let project = directory.path().join("Recording.cap");
        fs::create_dir(&project).unwrap();
        let _first = UploadLock::acquire(&project).unwrap();
        let uppercase = PathBuf::from(project.to_string_lossy().to_uppercase());
        assert!(matches!(
            UploadLock::acquire(&uppercase),
            Err(UploadLockError::Busy)
        ));
    }

    fn fixture() -> tempfile::TempDir {
        static FILES: OnceLock<Vec<(PathBuf, Vec<u8>)>> = OnceLock::new();
        let files = FILES.get_or_init(|| {
            ffmpeg::init().unwrap();
            let project = tempfile::tempdir().unwrap();
            let display = project.path().join("content/display");
            let audio = project.path().join("content/audio");
            let video_info = cap_media_info::VideoInfo {
                pixel_format: cap_media_info::Pixel::NV12,
                width: 32,
                height: 32,
                time_base: ffmpeg::Rational(1, 1_000_000),
                frame_rate: ffmpeg::Rational(30, 1),
            };
            let mut video = SegmentedVideoEncoder::init(
                display.clone(),
                video_info,
                SegmentedVideoEncoderConfig::default(),
            )
            .unwrap();
            for index in 0..6 {
                let mut frame = ffmpeg::frame::Video::new(ffmpeg::format::Pixel::NV12, 32, 32);
                for plane in 0..frame.planes() {
                    frame.data_mut(plane).fill(128);
                }
                video
                    .queue_frame(frame, Duration::from_nanos(index * 1_000_000_000 / 30))
                    .unwrap();
            }
            video.finish().unwrap();
            drop(video);
            let audio_info = cap_media_info::AudioInfo {
                sample_format: ffmpeg::format::Sample::F32(ffmpeg::format::sample::Type::Planar),
                sample_rate: 48_000,
                channels: 1,
                time_base: ffmpeg::Rational(1, 48_000),
                buffer_size: 1024,
                is_wireless_transport: false,
            };
            let mut encoder = DashAudioSegmentEncoder::init(
                audio.clone(),
                audio_info,
                DashAudioSegmentEncoderConfig {
                    segment_duration: Duration::from_secs(3),
                },
            )
            .unwrap();
            for index in 0..6 {
                let mut frame = ffmpeg::frame::Audio::new(
                    audio_info.sample_format,
                    1024,
                    ffmpeg::ChannelLayout::MONO,
                );
                frame.set_rate(48_000);
                frame.data_mut(0).fill(0);
                encoder
                    .queue_frame(
                        frame,
                        Duration::from_nanos(index * 1024 * 1_000_000_000 / 48_000),
                    )
                    .unwrap();
            }
            encoder.finish().unwrap();
            drop(encoder);
            [display, audio]
                .into_iter()
                .flat_map(|directory| {
                    fs::read_dir(directory)
                        .unwrap()
                        .map(|entry| {
                            let path = entry.unwrap().path();
                            (
                                path.strip_prefix(project.path()).unwrap().to_path_buf(),
                                fs::read(path).unwrap(),
                            )
                        })
                        .collect::<Vec<_>>()
                })
                .collect()
        });
        let project = tempfile::tempdir().unwrap();
        for (relative, bytes) in files {
            let path = project.path().join(relative);
            fs::create_dir_all(path.parent().unwrap()).unwrap();
            fs::write(path, bytes).unwrap();
        }
        project
    }

    fn edit_manifest(project: &Path, edit: impl FnOnce(&mut serde_json::Value)) {
        let path = project.join("content/display/manifest.json");
        let mut manifest = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap();
        edit(&mut manifest);
        fs::write(path, serde_json::to_vec(&manifest).unwrap()).unwrap();
    }

    #[test]
    fn complete_059_manifest_shapes_keep_recorded_sizes_and_durations() {
        let project = fixture();
        let events = collect_segment_events(project.path(), true).unwrap();
        assert!(events.len() >= 4);
        for event in events.iter().filter(|event| !event.is_init) {
            let directory = event.path.parent().unwrap();
            let manifest: serde_json::Value =
                serde_json::from_slice(&fs::read(directory.join("manifest.json")).unwrap())
                    .unwrap();
            let entry = manifest["segments"]
                .as_array()
                .unwrap()
                .iter()
                .find(|entry| entry["index"].as_u64() == Some(u64::from(event.index)))
                .unwrap();
            assert_eq!(entry["file_size"].as_u64(), Some(event.file_size));
            assert_eq!(entry["duration"].as_f64(), Some(event.duration));
        }
    }

    #[test]
    fn repeated_resume_preserves_live_durations_and_manifest_bytes() {
        for (nanos, json, expected_bits) in ROUND_TRIP_DURATIONS {
            let project = fixture();
            let mut manifests = Vec::new();
            for track in ["display", "audio"] {
                let path = project
                    .path()
                    .join("content")
                    .join(track)
                    .join("manifest.json");
                let mut manifest: serde_json::Value =
                    serde_json::from_slice(&fs::read(&path).unwrap()).unwrap();
                manifest["segments"][0]["duration"] =
                    serde_json::json!(Duration::from_nanos(nanos).as_secs_f64());
                let bytes = serde_json::to_vec(&manifest).unwrap();
                fs::write(&path, &bytes).unwrap();
                manifests.push((path, bytes));
            }
            for _ in 0..3 {
                let events = collect_segment_events(project.path(), true).unwrap();
                for media_type in [SegmentMediaType::Video, SegmentMediaType::Audio] {
                    let segment = events
                        .iter()
                        .find(|event| {
                            !event.is_init && event.index == 1 && event.media_type == media_type
                        })
                        .unwrap();
                    assert_eq!(segment.duration.to_bits(), expected_bits);
                    assert_eq!(serde_json::to_string(&segment.duration).unwrap(), json);
                }
                for (path, bytes) in &manifests {
                    assert_eq!(&fs::read(path).unwrap(), bytes);
                }
            }
        }
    }

    #[test]
    fn changed_actual_length_cannot_replace_the_recorded_length() {
        for longer in [false, true] {
            let project = fixture();
            let path = project.path().join("content/display/segment_001.m4s");
            let mut bytes = fs::read(&path).unwrap();
            if longer {
                bytes.push(0);
            } else {
                let _ = bytes.pop();
            }
            fs::write(&path, &bytes).unwrap();
            assert!(collect_segment_events(project.path(), true).is_err());
            assert_eq!(fs::read(path).unwrap(), bytes);
        }
    }

    #[test]
    fn missing_init_media_or_required_audio_returns_no_events() {
        for relative in [
            "content/display/init.mp4",
            "content/display/segment_001.m4s",
            "content/audio/init.mp4",
            "content/audio/segment_001.m4s",
        ] {
            let project = fixture();
            fs::remove_file(project.path().join(relative)).unwrap();
            assert!(collect_segment_events(project.path(), true).is_err());
        }
        let project = fixture();
        fs::remove_dir_all(project.path().join("content/audio")).unwrap();
        assert!(collect_segment_events(project.path(), true).is_err());
        assert!(collect_segment_events(project.path(), false).is_ok());
        fs::create_dir(project.path().join("content/audio")).unwrap();
        assert!(collect_segment_events(project.path(), false).is_ok());
        assert!(collect_segment_events(project.path(), true).is_err());
    }

    #[test]
    fn incomplete_escaping_and_size_less_entries_are_withheld() {
        for (pointer, value) in [
            ("/is_complete", serde_json::json!(false)),
            ("/segments/0/is_complete", serde_json::json!(false)),
            ("/segments/0/path", serde_json::json!("../segment_001.m4s")),
            ("/segments/0/path", serde_json::json!("/segment_001.m4s")),
            ("/segments/0/path", serde_json::json!("segment_1.m4s")),
            ("/segments/0/index", serde_json::json!(2)),
            ("/segments/0/duration", serde_json::json!(0)),
            ("/segments/0/file_size", serde_json::Value::Null),
            ("/segments/0/file_size", serde_json::json!(0)),
            ("/init_segment", serde_json::json!("../init.mp4")),
        ] {
            let project = fixture();
            edit_manifest(project.path(), |manifest| {
                *manifest.pointer_mut(pointer).unwrap() = value
            });
            assert!(
                collect_segment_events(project.path(), true).is_err(),
                "{pointer}"
            );
        }
    }

    #[test]
    fn unlisted_and_unfinished_media_are_withheld_but_sidecars_are_allowed() {
        for name in ["segment_999.m4s", "segment_999.m4s.tmp"] {
            let project = fixture();
            fs::write(
                project.path().join("content/display").join(name),
                b"retained",
            )
            .unwrap();
            assert!(collect_segment_events(project.path(), true).is_err());
        }
        let project = fixture();
        fs::write(
            project.path().join("content/display/diagnostic.log"),
            b"diagnostic",
        )
        .unwrap();
        assert!(collect_segment_events(project.path(), true).is_ok());
    }

    #[test]
    fn duplicate_indices_and_corrupt_init_are_withheld() {
        let project = fixture();
        edit_manifest(project.path(), |manifest| {
            let duplicate = manifest["segments"][0].clone();
            manifest["segments"].as_array_mut().unwrap().push(duplicate);
        });
        assert!(collect_segment_events(project.path(), true).is_err());
        let project = fixture();
        fs::write(
            project.path().join("content/display/init.mp4"),
            b"corrupt init",
        )
        .unwrap();
        assert!(collect_segment_events(project.path(), true).is_err());
    }

    fn track_manifest(project: &Path, track: &str) -> PathBuf {
        project.join("content").join(track).join("manifest.json")
    }

    /// Lists copies of `segment_001` as further segments, so a track holds
    /// `total` complete segments.
    fn extend_track(project: &Path, track: &str, total: u32) {
        let directory = project.join("content").join(track);
        let path = track_manifest(project, track);
        let mut manifest: serde_json::Value =
            serde_json::from_slice(&fs::read(&path).unwrap()).unwrap();
        let first = manifest["segments"][0].clone();
        let bytes = fs::read(directory.join("segment_001.m4s")).unwrap();
        let segments = manifest["segments"].as_array_mut().unwrap();
        segments.truncate(1);
        for index in 2..=total {
            let name = format!("segment_{index:03}.m4s");
            fs::write(directory.join(&name), &bytes).unwrap();
            let mut entry = first.clone();
            entry["index"] = serde_json::json!(index);
            entry["path"] = serde_json::json!(name);
            segments.push(entry);
        }
        fs::write(path, serde_json::to_vec(&manifest).unwrap()).unwrap();
    }

    /// Leaves a finished track the way a crash does: an in-progress manifest
    /// whose next segment is unfinished, with that segment's partial bytes on
    /// disk. Returns how many complete segments it lists, and the partial bytes.
    fn interrupt_track(project: &Path, track: &str) -> (usize, Vec<u8>) {
        let path = track_manifest(project, track);
        let mut manifest: serde_json::Value =
            serde_json::from_slice(&fs::read(&path).unwrap()).unwrap();
        let count = manifest["segments"].as_array().unwrap().len();
        let next = count + 1;
        manifest["is_complete"] = serde_json::json!(false);
        manifest["total_duration"] = serde_json::Value::Null;
        manifest["segments"]
            .as_array_mut()
            .unwrap()
            .push(serde_json::json!({
                "path": format!("segment_{next:03}.m4s"),
                "index": next,
                "duration": 0.0,
                "is_complete": false,
                "file_size": null,
            }));
        fs::write(&path, serde_json::to_vec(&manifest).unwrap()).unwrap();
        let partial = b"partial fragment".to_vec();
        fs::write(
            path.with_file_name(format!("segment_{next:03}.m4s.tmp")),
            &partial,
        )
        .unwrap();
        (count, partial)
    }

    fn snapshot(directory: &Path) -> Vec<(String, Vec<u8>)> {
        let mut files: Vec<_> = fs::read_dir(directory)
            .unwrap()
            .map(|entry| {
                let path = entry.unwrap().path();
                (
                    path.file_name().unwrap().to_string_lossy().into_owned(),
                    fs::read(path).unwrap(),
                )
            })
            .collect();
        files.sort();
        files
    }

    #[test]
    fn an_interrupted_recording_resumes_from_its_saved_segments_once_sealed() {
        let project = fixture();
        let mut tracks = Vec::new();
        for (track, media_type) in [
            ("display", SegmentMediaType::Video),
            ("audio", SegmentMediaType::Audio),
        ] {
            extend_track(project.path(), track, 3);
            tracks.push((track, media_type, interrupt_track(project.path(), track)));
        }
        assert!(collect_segment_events(project.path(), true).is_err());
        for (track, media_type, (count, partial)) in &tracks {
            let directory = project.path().join("content").join(track);
            assert_eq!(seal_interrupted_track(&directory, *media_type), Ok(*count));
            let next = count + 1;
            assert_eq!(
                &fs::read(directory.join(format!("segment_{next:03}.m4s.tmp.unsealed"))).unwrap(),
                partial
            );
        }
        let events = collect_segment_events(project.path(), true).unwrap();
        for (_, media_type, (count, _)) in &tracks {
            let segments = events
                .iter()
                .filter(|event| !event.is_init && event.media_type == *media_type)
                .count();
            assert_eq!(segments, *count);
        }
        for (track, media_type, (count, _)) in &tracks {
            let directory = project.path().join("content").join(track);
            let before = snapshot(&directory);
            assert_eq!(seal_interrupted_track(&directory, *media_type), Ok(*count));
            assert_eq!(snapshot(&directory), before);
        }
    }

    #[test]
    fn sealing_keeps_only_segments_before_the_first_failed_check() {
        for (damage, kept) in [
            ("truncate", 1),
            ("incomplete", 1),
            ("gap", 1),
            ("missing", 1),
        ] {
            let project = fixture();
            extend_track(project.path(), "display", 4);
            interrupt_track(project.path(), "display");
            let directory = project.path().join("content/display");
            match damage {
                "truncate" => {
                    let path = directory.join("segment_002.m4s");
                    let mut bytes = fs::read(&path).unwrap();
                    bytes.pop();
                    fs::write(path, bytes).unwrap();
                }
                "incomplete" => edit_manifest(project.path(), |manifest| {
                    manifest["segments"][1]["is_complete"] = serde_json::json!(false)
                }),
                "gap" => edit_manifest(project.path(), |manifest| {
                    manifest["segments"].as_array_mut().unwrap().remove(1);
                }),
                _ => fs::remove_file(directory.join("segment_002.m4s")).unwrap(),
            }
            assert_eq!(
                seal_interrupted_track(&directory, SegmentMediaType::Video),
                Ok(kept),
                "{damage}"
            );
            for index in 2..=4 {
                let original = directory.join(format!("segment_{index:03}.m4s"));
                assert!(!original.exists(), "{damage}: {index}");
                let aside = original.with_file_name(format!("segment_{index:03}.m4s.unsealed"));
                assert_eq!(
                    aside.exists(),
                    damage != "missing" || index != 2,
                    "{damage}: {index}"
                );
            }
            let events = collect_segment_events(project.path(), false).unwrap();
            let video = events
                .iter()
                .filter(|event| !event.is_init && event.media_type == SegmentMediaType::Video)
                .count();
            assert_eq!(video, kept, "{damage}");
        }
    }

    #[test]
    fn sealing_changes_nothing_when_it_cannot_keep_a_segment() {
        type Edit = fn(&mut serde_json::Value);
        let cases: [(&str, Edit); 4] = [
            ("no complete segment", |manifest| {
                manifest["segments"][0]["is_complete"] = serde_json::json!(false)
            }),
            ("unsupported version", |manifest| {
                manifest["version"] = serde_json::json!(4)
            }),
            ("unsupported kind", |manifest| {
                manifest["type"] = serde_json::json!("m4s_audio_segments")
            }),
            ("escaping init", |manifest| {
                manifest["init_segment"] = serde_json::json!("../init.mp4")
            }),
        ];
        for (case, edit) in cases {
            let project = fixture();
            interrupt_track(project.path(), "display");
            edit_manifest(project.path(), edit);
            let directory = project.path().join("content/display");
            let before = snapshot(&directory);
            assert!(
                seal_interrupted_track(&directory, SegmentMediaType::Video).is_err(),
                "{case}"
            );
            assert_eq!(snapshot(&directory), before, "{case}");
        }
    }

    #[cfg(unix)]
    #[test]
    fn sealing_refuses_linked_media_without_moving_anything() {
        let project = fixture();
        extend_track(project.path(), "display", 2);
        interrupt_track(project.path(), "display");
        let directory = project.path().join("content/display");
        let outside = project.path().join("outside.m4s");
        fs::write(&outside, b"outside").unwrap();
        std::os::unix::fs::symlink(&outside, directory.join("segment_009.m4s")).unwrap();
        let before = snapshot(&directory);
        assert!(seal_interrupted_track(&directory, SegmentMediaType::Video).is_err());
        assert_eq!(snapshot(&directory), before);
        assert_eq!(fs::read(outside).unwrap(), b"outside");
    }

    #[cfg(unix)]
    #[test]
    fn linked_manifest_init_fragment_and_track_are_withheld() {
        for relative in [
            "content/display/manifest.json",
            "content/display/init.mp4",
            "content/display/segment_001.m4s",
            "content/audio",
        ] {
            let project = fixture();
            let original = project.path().join(relative);
            let target = project.path().join("retained-original");
            fs::rename(&original, &target).unwrap();
            std::os::unix::fs::symlink(&target, &original).unwrap();
            assert!(collect_segment_events(project.path(), true).is_err());
            assert!(target.exists());
            assert!(
                fs::symlink_metadata(original)
                    .unwrap()
                    .file_type()
                    .is_symlink()
            );
        }
    }
}