Struct ProcessingContext 

pub struct ProcessingContext { /* private fields */ }

Processing context entity that maintains runtime state during pipeline execution.

The ProcessingContext serves as a central state container that travels through the pipeline, collecting information and tracking progress as each stage processes the data. It provides a unified interface for accessing and updating processing state across all pipeline stages.

Entity Purpose

• State Coordination: Centralizes processing state across pipeline stages
• Progress Tracking: Monitors processing progress and completion status
• Configuration Management: Maintains processing parameters and settings
• Metrics Collection: Aggregates performance and operational metrics
• Security Enforcement: Preserves security context throughout processing

Usage Examples

Creating a Processing Context

Tracking Processing Progress

Managing Stage Results

Adding Custom Metadata

Updating Processing Metrics

State Lifecycle

The processing context follows a predictable lifecycle:

1. Initialization

2. Processing Updates

3. Completion

Thread Safety and Concurrency

While the context itself is not thread-safe, it’s designed for safe concurrent patterns:

Serialization and Persistence

The context supports serialization for checkpointing and recovery:

Performance Considerations

• Context updates are lightweight and fast
• Metadata and stage results use efficient HashMap storage
• Progress calculations are performed on-demand
• Timestamps are updated only when state changes
• Memory usage scales with the amount of stored metadata

Error Handling

The context provides safe access to all state with appropriate defaults:

• Missing metadata returns None rather than panicking
• Progress calculations handle edge cases (zero file size)
• All numeric operations are checked for overflow
• Timestamp operations are guaranteed to succeed

Implementations

impl ProcessingContext

pub fn new(file_size: u64, security_context: SecurityContext) -> Self

Creates a new processing context for pipeline execution

Initializes a chunk-scoped context with default configuration values and empty state. The context starts with zero processed bytes and will track progress and metadata as the chunk flows through pipeline stages.

Design Note

This context is chunk-scoped, not file-scoped. File paths are managed by the pipeline worker (via CpuWorkerContext) using dependency injection. This separation ensures the context focuses on chunk processing metadata without coupling to file I/O concerns.

Arguments

• file_size - Total size of the file being processed (for progress tracking)
• security_context - Security context for authorization and access control

Returns

A new ProcessingContext with initialized state

Examples

pub fn id(&self) -> &ProcessingContextId

Gets the unique identifier for this processing context

Returns

Reference to the context’s unique identifier

pub fn file_size(&self) -> u64

Gets the total size of the file being processed

Returns

Total file size in bytes

pub fn processed_bytes(&self) -> u64

Gets the number of bytes processed so far

Returns

Number of bytes processed

pub fn security_context(&self) -> &SecurityContext

Gets the security context for authorization and access control

Returns

Reference to the security context

pub fn metrics(&self) -> &ProcessingMetrics

Gets the current processing metrics

Returns

Reference to the processing metrics

pub fn chunk_size(&self) -> &ChunkSize

Gets the chunk size configuration for processing

Returns

Reference to the chunk size configuration

pub fn worker_count(&self) -> &WorkerCount

Gets the number of worker threads for parallel processing

Returns

Reference to the worker count configuration

pub fn metadata(&self) -> &HashMap<String, String>

Gets all custom metadata associated with this context

Returns

Reference to the metadata HashMap

pub fn stage_results(&self) -> &HashMap<String, String>

Gets all stage processing results

Returns

Reference to the stage results HashMap

pub fn update_processed_bytes(&mut self, bytes: u64)

Sets the total number of bytes processed

Replaces the current processed byte count with a new absolute value.

Arguments

• bytes - New total byte count

Side Effects

Updates the updated_at timestamp

pub fn add_processed_bytes(&mut self, bytes: u64)

Increments the processed byte count

Adds the specified number of bytes to the current processed total.

Arguments

• bytes - Number of additional bytes to add

Side Effects

Updates the updated_at timestamp

pub fn update_metrics(&mut self, metrics: ProcessingMetrics)

Updates the processing metrics with new values

Arguments

• metrics - New metrics to replace current metrics

Side Effects

Updates the updated_at timestamp

pub fn add_metadata(&mut self, key: String, value: String)

Adds or updates a metadata key-value pair

Arguments

• key - Metadata key
• value - Metadata value

Side Effects

Updates the updated_at timestamp

pub fn get_metadata(&self, key: &str) -> Option<&String>

Retrieves a metadata value by key

Arguments

• key - Metadata key to look up

Returns

• Some(&String) - Value if key exists
• None - If key not found

pub fn add_stage_result(&mut self, stage_name: String, result: String)

Records the result of a processing stage

Arguments

• stage_name - Name of the stage
• result - Processing result or status

Side Effects

Updates the updated_at timestamp

pub fn update_security_context(&mut self, security_context: SecurityContext)

Updates the security context

Arguments

• security_context - New security context

Side Effects

Updates the updated_at timestamp

pub fn progress_percentage(&self) -> f64

Calculates processing progress as a percentage

Returns

Progress as a percentage (0.0 to 100.0)

Examples

pub fn is_complete(&self) -> bool

Checks if processing is complete

Returns

true if all bytes have been processed, false otherwise

pub fn created_at(&self) -> DateTime<Utc>

Gets the timestamp when this context was created

Returns

UTC creation timestamp

pub fn updated_at(&self) -> DateTime<Utc>

Gets the timestamp of the last update to this context

Returns

UTC timestamp of last modification

Trait Implementations

impl Clone for ProcessingContext

fn clone(&self) -> ProcessingContext

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessingContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProcessingContext

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ProcessingContext

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.