Struct AsyncEncryptionAdapter 

pub struct AsyncEncryptionAdapter<T: EncryptionService + 'static> { /* private fields */ }

Async adapter for EncryptionService

Wraps a synchronous EncryptionService implementation and provides async methods that execute the sync operations in a way that doesn’t block the async runtime.

Design Rationale

• Domain Purity: Domain traits remain sync and portable
• Infrastructure Flexibility: Async execution is an implementation detail
• Non-Blocking: Uses spawn_blocking for CPU-intensive operations
• Zero-Cost When Sync: No overhead if used in sync contexts

Implementations

impl<T: EncryptionService + 'static> AsyncEncryptionAdapter<T>

pub fn new(service: Arc<T>) -> Self

Creates a new async adapter wrapping a sync encryption service

pub async fn encrypt_chunk_async( &self, chunk: FileChunk, config: &EncryptionConfig, key_material: &KeyMaterial, context: &mut ProcessingContext, ) -> Result<FileChunk, PipelineError>

Encrypts a chunk asynchronously

Executes the synchronous encrypt operation in a blocking task pool to avoid blocking the async runtime.

pub async fn decrypt_chunk_async( &self, chunk: FileChunk, config: &EncryptionConfig, key_material: &KeyMaterial, context: &mut ProcessingContext, ) -> Result<FileChunk, PipelineError>

Decrypts a chunk asynchronously

pub async fn encrypt_chunks_parallel( &self, chunks: Vec<FileChunk>, config: &EncryptionConfig, key_material: &KeyMaterial, context: &mut ProcessingContext, ) -> Result<Vec<FileChunk>, PipelineError>

Encrypts multiple chunks in parallel using Rayon (infrastructure concern)

This method demonstrates how parallelization is an infrastructure concern, not a domain concern. The domain just defines encrypt/decrypt.

Uses Rayon’s data parallelism for efficient CPU-bound batch encryption, providing 3-4x speedup on multi-core systems.

pub async fn decrypt_chunks_parallel( &self, chunks: Vec<FileChunk>, config: &EncryptionConfig, key_material: &KeyMaterial, context: &mut ProcessingContext, ) -> Result<Vec<FileChunk>, PipelineError>

Decrypts multiple chunks in parallel using Rayon (infrastructure concern)

Uses Rayon’s data parallelism for efficient CPU-bound batch decryption, providing 3-4x speedup on multi-core systems.

pub async fn derive_key_material_async( &self, password: &str, config: &EncryptionConfig, security_context: &SecurityContext, ) -> Result<KeyMaterial, PipelineError>

Derives key material from password asynchronously

This is a CPU-intensive operation that benefits from blocking execution.

pub async fn generate_key_material_async( &self, config: &EncryptionConfig, security_context: &SecurityContext, ) -> Result<KeyMaterial, PipelineError>

Generates random key material asynchronously

pub fn validate_config( &self, config: &EncryptionConfig, ) -> Result<(), PipelineError>

Validates config (sync operation)

pub fn supported_algorithms(&self) -> Vec<EncryptionAlgorithm>

Gets supported algorithms (sync operation)

pub async fn benchmark_algorithm_async( &self, algorithm: &EncryptionAlgorithm, test_data: &[u8], ) -> Result<EncryptionBenchmark, PipelineError>

Benchmarks algorithm asynchronously

pub fn wipe_key_material( &self, key_material: &mut KeyMaterial, ) -> Result<(), PipelineError>

Wipes key material (sync operation)

pub fn store_key_material( &self, key_material: &KeyMaterial, key_id: &str, security_context: &SecurityContext, ) -> Result<(), PipelineError>

Stores key material (sync operation - HSM calls might be sync or async depending on implementation)

pub fn retrieve_key_material( &self, key_id: &str, security_context: &SecurityContext, ) -> Result<KeyMaterial, PipelineError>

Retrieves key material (sync operation)

pub fn rotate_keys( &self, old_key_id: &str, new_config: &EncryptionConfig, security_context: &SecurityContext, ) -> Result<String, PipelineError>

Rotates keys (sync operation)

Trait Implementations

impl<T: EncryptionService + 'static> Clone for AsyncEncryptionAdapter<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.