Crate ipfrs_transport 

IPFRS Transport - TensorSwap and data exchange protocols

This crate implements the transport layer for IPFRS including:

• TensorSwap protocol for efficient tensor streaming
• Bitswap-compatible block exchange
• GraphSync for DAG traversal
• Enhanced want list management with priority queues
• Peer scoring and selection strategies
• QUIC transport with connection pooling
• Content routing with DHT integration
• CDN edge node caching
• Comprehensive diagnostics and health monitoring
• Automatic configuration tuning
• Performance statistics aggregation
• Observability with structured logging
• Prometheus metrics export
• Load testing utilities

Re-exports

pub use graphsync::AggregationStrategy;

pub use graphsync::DagTraversal;

pub use graphsync::GradientAggregator;

pub use graphsync::GradientAggregatorStats;

pub use graphsync::GradientMessage;

pub use graphsync::GradientStream;

pub use graphsync::GraphSync;

pub use graphsync::Selector;

pub use graphsync::TraversalCheckpoint;

pub use graphsync::TraversalMode;

pub use graphsync::TraversalState;

pub use graphsync::TraversalStats;

pub use bitswap::BitswapConfig;

pub use bitswap::BitswapExchange;

pub use bitswap::BitswapStats;

pub use cdn_edge::EdgeConfig;

pub use cdn_edge::EdgeNode;

pub use cdn_edge::EdgeStats;

pub use cdn_edge::EvictionPolicy;

pub use cdn_edge::InvalidationReason;

pub use cdn_edge::InvalidationRequest;

pub use cdn_edge::OriginServer;

pub use content_routing::ContentRouter;

pub use content_routing::ContentRoutingConfig;

pub use content_routing::ContentRoutingStats;

pub use content_routing::ProviderRecord;

pub use erasure::ErasureConfig;

pub use erasure::ErasureError;

pub use erasure::ErasureManager;

pub use erasure::ErasureMetadata;

pub use erasure::Shard;

pub use erasure::SimpleErasureEncoder;

pub use messages::BlockMessage;

pub use messages::CancelMessage;

pub use messages::DontHaveMessage;

pub use messages::HaveMessage;

pub use messages::Message;

pub use messages::WantEntry as MessageWantEntry;

pub use messages::WantList as MessageWantList;

pub use metrics::LatencyStats;

pub use metrics::LatencyTracker;

pub use metrics::MemoryStats;

pub use metrics::MemoryTracker;

pub use metrics::MetricsConfig;

pub use metrics::ThroughputTracker;

pub use metrics::Timer;

pub use multi_transport::ConnectionAttempt;

pub use multi_transport::MultiTransportConfig;

pub use multi_transport::MultiTransportManager;

pub use multi_transport::MultiTransportManagerBuilder;

pub use multicast::BlockAnnouncement;

pub use multicast::MulticastConfig;

pub use multicast::MulticastError;

pub use multicast::MulticastManager;

pub use multicast::MulticastStats;

pub use multicast::Subscription;

pub use multicast::SubscriptionFilter;

pub use multicast::Topic;

pub use nat_traversal::CandidatePair;

pub use nat_traversal::CandidateType;

pub use nat_traversal::ConnectivityEvent;

pub use nat_traversal::IceCandidate;

pub use nat_traversal::NatTraversalConfig;

pub use nat_traversal::NatTraversalError;

pub use nat_traversal::NatTraversalManager;

pub use nat_traversal::NatTraversalStats;

pub use nat_traversal::NatType;

pub use nat_traversal::PairState;

pub use nat_traversal::StunConfig;

pub use nat_traversal::TurnConfig;

pub use partition::PartitionConfig;

pub use partition::PartitionDetector;

pub use partition::PartitionError;

pub use partition::PartitionState;

pub use partition::PartitionStats;

pub use peer_manager::BlacklistReason;

pub use peer_manager::CircuitBreaker;

pub use peer_manager::CircuitBreakerConfig;

pub use peer_manager::CircuitBreakerStats;

pub use peer_manager::CircuitState;

pub use peer_manager::ConcurrentPeerManager;

pub use peer_manager::PeerId;

pub use peer_manager::PeerManager;

pub use peer_manager::PeerManagerStats;

pub use peer_manager::PeerMetrics;

pub use peer_manager::PeerScoringConfig;

pub use peer_manager::PeerState;

pub use peer_manager::RetryConfig;

pub use peer_manager::RetryPolicy;

pub use peer_manager::SelectionStrategy;

pub use prefetch::Prediction;

pub use prefetch::PredictionReason;

pub use prefetch::PrefetchConfig;

pub use prefetch::PrefetchPredictor;

pub use prefetch::PrefetchStats;

pub use prefetch::PrefetchStrategy;

pub use quic::AdaptiveBatchTuner;

pub use quic::BlockStream;

pub use quic::ParallelRequester;

pub use quic::PipelineConfig;

pub use quic::QuicConfig;

pub use quic::QuicPoolStats;

pub use quic::QuicTransport;

pub use quic::SequentialPipeline;

pub use range_request::ByteRange;

pub use range_request::RangeAssembler;

pub use range_request::RangeError;

pub use range_request::RangeRequest;

pub use range_request::RangeResponse;

pub use recovery::RecoveryConfig;

pub use recovery::RecoveryError;

pub use recovery::RecoveryManager;

pub use recovery::RecoveryMode;

pub use recovery::RecoveryStats;

pub use recovery::RecoveryStrategy;

pub use session::Session;

pub use session::SessionConfig;

pub use session::SessionError;

pub use session::SessionEvent;

pub use session::SessionId;

pub use session::SessionManager;

pub use session::SessionState;

pub use session::SessionStats;

pub use tcp::TcpConfig;

pub use tcp::TcpConnection;

pub use tcp::TcpTransport;

pub use tensorswap::BackpressureConfig;

pub use tensorswap::BackpressureController;

pub use tensorswap::ChunkInfo;

pub use tensorswap::EinsumExpression;

pub use tensorswap::EinsumGraph;

pub use tensorswap::SafetensorEntry;

pub use tensorswap::SafetensorsHeader;

pub use tensorswap::StreamProgress;

pub use tensorswap::StreamRequest;

pub use tensorswap::StreamRequestQueue;

pub use tensorswap::TensorMetadata;

pub use tensorswap::TensorStream;

pub use tensorswap::TensorSwap;

pub use tensorswap::TensorSwapConfig;

pub use tensorswap::TensorSwapStats;

pub use throttle::BandwidthConfig;

pub use throttle::BandwidthThrottle;

pub use throttle::QosPriority;

pub use throttle::ThrottleError;

pub use throttle::ThrottleStats;

pub use throttle::TokenBucket;

pub use transport::Connection;

pub use transport::ConnectionMetrics;

pub use transport::Transport;

pub use transport::TransportCapabilities;

pub use transport::TransportError;

pub use transport::TransportSelectionStrategy;

pub use transport::TransportSelector;

pub use transport::TransportStats;

pub use transport::TransportType;

pub use want_list::ConcurrentWantList;

pub use want_list::Priority;

pub use want_list::WantEntry;

pub use want_list::WantList;

pub use want_list::WantListConfig;

pub use websocket::WebSocketConfig;

pub use websocket::WebSocketConnection;

pub use websocket::WebSocketServerConnection;

pub use websocket::WebSocketTransport;

pub use auto_tuner::AutoTuner;

pub use auto_tuner::AutoTunerConfig;

pub use auto_tuner::NetworkCondition;

pub use auto_tuner::NetworkMetrics;

pub use auto_tuner::TuningProfile;

pub use diagnostics::DiagnosticConfig;

pub use diagnostics::DiagnosticEngine;

pub use diagnostics::DiagnosticIssue;

pub use diagnostics::DiagnosticReport;

pub use diagnostics::HealthStatus;

pub use diagnostics::IssueCategory;

pub use diagnostics::IssueSeverity;

pub use diagnostics::PeerManagerDiagnostics;

pub use diagnostics::SessionDiagnostics;

pub use diagnostics::WantListDiagnostics;

pub use health_monitor::AlertCallback;

pub use health_monitor::ComponentHealth;

pub use health_monitor::ComponentStats;

pub use health_monitor::ComponentType;

pub use health_monitor::HealthAlert;

pub use health_monitor::HealthCheck;

pub use health_monitor::HealthCheckBuilder;

pub use health_monitor::HealthMonitor;

pub use health_monitor::HealthMonitorConfig;

pub use stats_aggregator::AggregatedSessionStats;

pub use stats_aggregator::AggregatedStats;

pub use stats_aggregator::AggregatedStatsBuilder;

pub use stats_aggregator::AggregatedTransportStats;

pub use stats_aggregator::DataPoint;

pub use stats_aggregator::PerformanceMetrics;

pub use stats_aggregator::StatsCollector;

pub use utils::adjust_priority_for_deadline;

pub use utils::all_wants_present;

pub use utils::any_want_present;

pub use utils::bulk_add_wants;

pub use utils::bulk_remove_wants;

pub use utils::bulk_update_priorities;

pub use utils::calculate_expected_throughput;

pub use utils::calculate_optimal_chunk_size;

pub use utils::calculate_optimal_concurrency;

pub use utils::calculate_recommended_buffer_size;

pub use utils::create_balanced_peer_scoring;

pub use utils::create_bandwidth_optimized_peer_manager;

pub use utils::create_bulk_transfer_session;

pub use utils::create_datacenter_want_list;

pub use utils::create_edge_device_peer_manager;

pub use utils::create_edge_device_want_list;

pub use utils::create_high_throughput_want_list;

pub use utils::create_interactive_session;

pub use utils::create_latency_optimized_peer_manager;

pub use utils::create_low_latency_want_list;

pub use utils::create_realtime_session;

pub use utils::create_reliability_focused_scoring;

pub use utils::create_scientific_session;

pub use utils::debug_peer_scoring_config;

pub use utils::debug_session_config;

pub use utils::debug_want_list_config;

pub use utils::estimate_required_peers;

pub use utils::estimate_transfer_time;

pub use utils::estimate_want_list_memory;

pub use utils::format_bandwidth;

pub use utils::format_bytes;

pub use utils::format_duration;

pub use utils::is_high_throughput_config;

pub use utils::is_low_latency_config;

pub use utils::validate_peer_scoring_config;

pub use utils::validate_session_config;

pub use utils::validate_want_list_config;

pub use facade::TransportFacade;

pub use facade::TransportFacadeBuilder;

pub use facade::TransportFacadeConfig;

pub use facade::TransportPreset;

pub use test_utils::add_test_peers;

pub use test_utils::add_varied_test_peers;

pub use test_utils::assert_approx_eq;

pub use test_utils::assert_in_range;

pub use test_utils::minimal_peer_scoring_config;

pub use test_utils::minimal_session_config;

pub use test_utils::minimal_want_list_config;

pub use test_utils::test_cid;

pub use test_utils::test_cids;

pub use test_utils::test_peer_ids;

pub use test_utils::test_peer_manager;

pub use test_utils::test_peer_manager_with_config;

pub use test_utils::test_session;

pub use test_utils::test_session_with_blocks;

pub use test_utils::test_want_list;

pub use test_utils::test_want_list_with_cids;

pub use advanced_scheduling::AdvancedScheduler;

pub use advanced_scheduling::SchedulePriority;

pub use advanced_scheduling::ScheduledRequest;

pub use advanced_scheduling::SchedulerStats;

pub use advanced_scheduling::SchedulingPolicy;

pub use connection_migration::ConnectionMigration;

pub use connection_migration::MigrationConfig;

pub use connection_migration::MigrationEvent;

pub use connection_migration::MigrationState;

pub use connection_migration::MigrationStats;

pub use request_coalescing::CoalescerConfig;

pub use request_coalescing::CoalescerStats;

pub use request_coalescing::RequestCoalescer;

pub use observability::EventLogger;

pub use observability::LogEntry;

pub use observability::LogLevel;

pub use observability::LoggerConfig;

pub use observability::TransportEvent;

pub use prometheus_exporter::MetricType;

pub use prometheus_exporter::PrometheusExporter;

pub use load_tester::LoadPattern;

pub use load_tester::LoadTestConfig;

pub use load_tester::LoadTestConfigBuilder;

pub use load_tester::LoadTestStats;

pub use load_tester::LoadTester;

pub use config_advisor::ConfigAdvisor;

pub use config_advisor::ConfigRequirements;

pub use config_advisor::NetworkQuality;

pub use config_advisor::PerformanceProfile;

pub use config_advisor::RecommendedConfig;

pub use config_advisor::ResourceLevel;

pub use config_advisor::UseCase;

Modules

advanced_scheduling

Advanced request scheduling algorithms

auto_tuner

Automatic configuration tuning based on network conditions

bitswap

Bitswap-compatible block exchange protocol

cdn_edge

CDN Edge Node Integration

config_advisor

Configuration recommendation engine for transport layer optimization

connection_migration

Connection migration for handling network changes

content_routing

Content Routing Integration

diagnostics

Diagnostic utilities for troubleshooting transport issues

erasure

Erasure coding for data resilience

facade

High-level facade for easy transport system setup

graphsync

GraphSync protocol for DAG traversal

health_monitor

Comprehensive health monitoring for transport components

load_tester

Load testing utilities for transport layer

messages

Protocol message definitions for TensorSwap/Bitswap

metrics

Performance Metrics and Latency Distribution Tracking

multi_transport

Multi-transport manager with automatic transport selection

multicast

Multicast block announcements

nat_traversal

observability

Observability module for structured logging and event tracking

partition

Network partition detection and handling

peer_manager

Peer management with scoring, selection, and blacklisting

prefetch

Predictive Prefetching

prometheus_exporter

Prometheus metrics exporter for transport layer

quic

QUIC transport for efficient block exchange

range_request

Partial block requests (range queries)

recovery

Error recovery strategies for resilient operation

request_coalescing

Request coalescing for deduplicating concurrent block requests

session

Session management for grouping related block requests

stats_aggregator

Statistics aggregation and analysis utilities

tcp

TCP fallback transport for universal compatibility

tensorswap

TensorSwap protocol for efficient tensor streaming

test_utils

Testing utilities for ipfrs-transport

throttle

Bandwidth throttling for rate limiting

transport

Transport abstraction for multi-transport support

utils

Utility functions and helpers for common transport operations

want_list

Enhanced want list management with priority queue

websocket

WebSocket transport for gateway compatibility