Struct ArchiveProcessor 

pub struct ArchiveProcessor { /* private fields */ }

Processes archives by sanitizing each contained file and rebuilding the archive with the same format and preserved metadata.

Usage

use rust_sanitize::processor::archive::{ArchiveProcessor, ArchiveFormat};
use rust_sanitize::processor::registry::ProcessorRegistry;
use rust_sanitize::scanner::{StreamScanner, ScanPattern, ScanConfig};
use rust_sanitize::generator::HmacGenerator;
use rust_sanitize::store::MappingStore;
use rust_sanitize::category::Category;
use std::sync::Arc;

let gen = Arc::new(HmacGenerator::new([42u8; 32]));
let store = Arc::new(MappingStore::new(gen, None));
let patterns = vec![
    ScanPattern::from_regex(r"secret\w+", Category::Custom("secret".into()), "secrets").unwrap(),
];
let scanner = Arc::new(
    StreamScanner::new(patterns, Arc::clone(&store), ScanConfig::default()).unwrap(),
);
let registry = Arc::new(ProcessorRegistry::with_builtins());

let archive_proc = ArchiveProcessor::new(registry, scanner, store, vec![]);

Implementations

impl ArchiveProcessor

pub fn new( registry: Arc<ProcessorRegistry>, scanner: Arc<StreamScanner>, store: Arc<MappingStore>, profiles: Vec<FileTypeProfile>, ) -> Self

Create a new archive processor.

Arguments

• registry — structured processor registry.
• scanner — streaming scanner for fallback.
• store — shared mapping store for one-way dedup replacements.
• profiles — file-type profiles for structured matching.

pub fn with_max_depth(self, depth: u32) -> Self

Override the maximum nesting depth for recursive archive processing.

The default is DEFAULT_ARCHIVE_DEPTH (5). Values above 10 are clamped.

pub fn with_parallel_threshold(self, threshold: usize) -> Self

Override the minimum entry count required to enable parallel entry sanitization. Set to usize::MAX to disable parallelism entirely for this processor instance (e.g. when outer file-level parallelism is already saturating the thread budget).

pub fn with_progress_callback( self, callback: Arc<dyn Fn(&ArchiveProgress) + Send + Sync>, ) -> Self

Register a per-entry archive progress callback.

pub fn with_filter(self, filter: ArchiveFilter) -> Self

Apply an ArchiveFilter that controls which file entries are included in the output archive.

Entries that do not pass the filter are removed from the output entirely. Directory / symlink entries are never filtered.

pub fn with_force_text(self, force_text: bool) -> Self

When set, bypass all structured processors and use only the streaming scanner for every archive entry.

Trades format preservation for maximum sanitization coverage. Useful when the user is uncertain about field rules or wants a belt-and-suspenders guarantee that every byte is scanned.

pub fn with_entry_callback(self, callback: EntryCallback) -> Self

Register a callback that is invoked with (entry_name, sanitized_bytes) after each regular file entry is fully processed.

pub fn discover_profiles_tar<R: Read>(&self, reader: R) -> Result<()>

Run the structured processor on every profile-matched entry in a .tar archive, recording replacements into the store. Output is discarded; the archive is not modified.

Errors

Returns an error if the archive cannot be read or an entry cannot be processed.

pub fn discover_profiles_tar_gz<R: Read>(&self, reader: R) -> Result<()>

Run the structured processor on every profile-matched entry in a .tar.gz archive, recording replacements into the store. Output is discarded; the archive is not modified.

Errors

Returns an error if the archive cannot be read or an entry cannot be processed.

pub fn discover_profiles_zip<R: Read + Seek>(&self, reader: R) -> Result<()>

Run the structured processor on every profile-matched entry in a .zip archive, recording replacements into the store. Output is discarded; the archive is not modified.

Errors

Returns an error if the archive cannot be read or an entry cannot be processed.

pub fn process_tar<R: Read, W: Write>( &self, reader: R, writer: W, ) -> Result<ArchiveStats>

Process a .tar archive, sanitizing each file entry and rebuilding the archive with preserved metadata.

Entries that are not regular files (directories, symlinks, etc.) are copied through unchanged.

Errors

Returns SanitizeError::ArchiveError on I/O failures or SanitizeError::RecursionDepthExceeded for nested archives.

pub fn process_tar_gz<R: Read, W: Write>( &self, reader: R, writer: W, ) -> Result<ArchiveStats>

Process a .tar.gz archive (gzip-compressed tar).

Decompresses on the fly, processes each entry, and recompresses the output.

Errors

Returns SanitizeError::ArchiveError on I/O failures or SanitizeError::RecursionDepthExceeded for nested archives.

pub fn process_zip<R: Read + Seek, W: Write + Seek>( &self, reader: R, writer: W, ) -> Result<ArchiveStats>

Process a .zip archive, sanitizing each file entry and rebuilding the archive with preserved metadata.

Type Bounds

Zip requires seekable I/O for both reading and writing.

Errors

Returns SanitizeError::ArchiveError on I/O failures or SanitizeError::RecursionDepthExceeded for nested archives.

pub fn process<R: Read + Seek, W: Write + Seek>( &self, reader: R, writer: W, format: ArchiveFormat, ) -> Result<ArchiveStats>

Auto-detect the archive format and process accordingly.

For zip archives the reader must additionally implement Seek. This method accepts Read + Seek to cover all formats uniformly. Tar and tar.gz do not require seeking, but the bound is imposed for a single entry point.

Errors

Returns SanitizeError::ArchiveError on I/O failures or SanitizeError::RecursionDepthExceeded for nested archives.