Method archive_to_directory

atomic-repository/src/repository/archive.rs:142–188

Archive to a directory (internal helper).

(
        &self,
        dest: &Path,
        manifest: &ArchiveManifest,
        options: &ArchiveOptions,
    )

    /// Archive to a directory (internal helper).
    fn archive_to_directory(
        &self,
        dest: &Path,
        manifest: &ArchiveManifest,
        options: &ArchiveOptions,
    ) -> Result<u64, RepositoryError> {
        let mut archive = DirectoryArchive::new(dest).map_err(RepositoryError::Io)?;

        let mut total_size = 0u64;

        // First create directories
        for entry in manifest.directories() {
            archive
                .create_directory(&entry.path, entry.mode, 0)
                .map_err(RepositoryError::Io)?;
        }

        // Then copy files
        for entry in manifest.files() {
            // Determine source path - strip prefix if it was added
            let source_rel_path = if let Some(ref prefix) = options.prefix {
                if entry.path.starts_with(prefix) {
                    entry.path[prefix.len()..].to_string()
                } else {
                    entry.path.clone()
                }
            } else {
                entry.path.clone()
            };
            let source_path = self.root.join(&source_rel_path);

            let mut writer = archive
                .create_file(&entry.path, entry.size, entry.mode, 0)
                .map_err(RepositoryError::Io)?;

            // Copy file contents
            let mut source = std::fs::File::open(&source_path).map_err(RepositoryError::Io)?;
            let copied = std::io::copy(&mut source, &mut writer).map_err(RepositoryError::Io)?;
            total_size += copied;

            archive.close_file(writer).map_err(RepositoryError::Io)?;
        }

        archive.finish().map_err(RepositoryError::Io)?;

        Ok(total_size)
    }
}