Struct P2mApiService

pub struct P2mApiService<S, P, C, M> { /* private fields */ }

P2M (Process-to-Middleware) API Service.

Central orchestrator for process-initiated traceability operations. This service manages the complete lifecycle of tracked I/O operations from initial resource enrollment through final completion reporting.

Core Responsibilities

Resource Enrollment: Maintains registry of process file descriptors and their associated resources (files or network streams) for traceability tracking.

Flow Authorization: Coordinates with compliance and sequencer services to evaluate whether requested I/O operations should be permitted based on current policies.

Distributed Coordination: Communicates with remote middleware instances for cross-node flows, ensuring consistent policy enforcement across the network.

Provenance Tracking: Updates provenance records following successful operations to maintain complete audit trails for compliance and governance.

Concurrency and State Management

Uses concurrent data structures (DashMap) to handle multiple simultaneous requests from different processes while maintaining consistency. Resource and flow maps are shared across service instances using Arc for efficient cloning.

Generic Type Parameters

• S: Sequencer service for flow coordination and resource reservations
• P: Provenance service for provenance tracking
• C: Compliance service for policy evaluation and authorization decisions
• M: M2M client service for communication with remote middleware instances

Implementations

impl<S, P, C, M> P2mApiService<S, P, C, M>

pub fn new(sequencer: S, provenance: P, compliance: C, m2m: M) -> Self

Creates a new P2M API service with the provided component services.

Initializes empty resource and flow maps and stores references to the core services needed for traceability operations. The service is ready to handle process requests immediately after construction.

Arguments

• sequencer - Service for flow coordination and resource reservations
• provenance - Service for provenance tracking
• compliance - Service for policy evaluation and authorization decisions
• m2m - Client for communication with remote middleware instances

pub fn with_resource_validation(self, enable: bool) -> Self

Enables or disables resource validation for incoming P2M requests.

When validation is enabled, all incoming requests are validated for:

• Valid process IDs (must correspond to running processes)
• Valid stream addresses (must be well-formed and compatible)

This method uses the same ResourceValidator logic as the Tower filter but integrates it directly into the service to avoid complex Send/Sync constraints with async runtimes.

Arguments

• enable - Whether to enable resource validation

Returns

Self with validation setting applied

Trait Implementations

impl<S: Clone, P: Clone, C: Clone, M: Clone> Clone for P2mApiService<S, P, C, M>

fn clone(&self) -> P2mApiService<S, P, C, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug, P: Debug, C: Debug, M: Debug> Debug for P2mApiService<S, P, C, M>

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

Formats the value using the given formatter.

impl<S, P, C, M> Service<P2mRequest> for P2mApiService<S, P, C, M>

where S: Service<SequencerRequest, Response = SequencerResponse, Error = TraceabilityError> + Clone + Send + 'static, S::Future: Send, P: Service<ProvenanceRequest, Response = ProvenanceResponse, Error = TraceabilityError> + Clone + Send + NodeId + 'static, P::Future: Send, C: Service<ComplianceRequest, Response = ComplianceResponse, Error = TraceabilityError> + Clone + Send + 'static, C::Future: Send, M: Service<M2mRequest, Response = M2mResponse, Error = TraceabilityError> + Clone + Send + 'static, M::Future: Send,

type Response = P2mResponse

Responses given by the service.

type Error = TraceabilityError

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<P2mApiService<S, P, C, M> as Service<P2mRequest>>::Response, <P2mApiService<S, P, C, M> as Service<P2mRequest>>::Error>> + Send>>

The future response value.

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, request: P2mRequest) -> Self::Future

Process the request and return the response asynchronously.