mabi_modbus/lib.rs
1//! # trap-sim-modbus
2//!
3//! Modbus TCP/RTU simulator for the TRAP protocol simulator.
4//!
5//! This crate provides:
6//! - Modbus TCP server implementation
7//! - Modbus RTU simulation (serial)
8//! - Register storage (coils, discrete inputs, holding registers, input registers)
9//! - Multiple device simulation
10//! - Extensible handler architecture
11//! - Connection pooling and metrics
12//!
13//! ## Architecture
14//!
15//! ### TCP Server Architecture
16//!
17//! ```text
18//! ┌─────────────────────────────────────────────────────────────┐
19//! │ ModbusTcpServerV2 │
20//! │ ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐ │
21//! │ │ TcpListener │──│ConnectionPool│──│ HandlerRegistry │ │
22//! │ └──────────────┘ └──────────────┘ └──────────────────┘ │
23//! │ │ │
24//! │ ┌─────────────────────┴───────────┐ │
25//! │ │ FunctionHandler Trait │ │
26//! │ │ FC01 FC02 FC03 ... Custom │ │
27//! │ └─────────────────────────────────┘ │
28//! └─────────────────────────────────────────────────────────────┘
29//! ```
30//!
31//! ### RTU Server Architecture
32//!
33//! ```text
34//! ┌─────────────────────────────────────────────────────────────┐
35//! │ ModbusRtuServer │
36//! │ ┌──────────────────┐ ┌────────────────┐ │
37//! │ │ TransportManager │──│ HandlerRegistry│ │
38//! │ └────────┬─────────┘ └────────────────┘ │
39//! │ │ │
40//! │ ┌────────┴─────────────────────────────────┐ │
41//! │ │ Transport Trait │ │
42//! │ │ VirtualSerial │ TcpBridge │ Channel │ │
43//! │ └──────────────────────────────────────────┘ │
44//! │ │ │
45//! │ ┌───────────────┴───────────────────┐ │
46//! │ │ RtuCodec │ │
47//! │ │ Frame Detection │ CRC Validation │ │
48//! │ └────────────────────────────────────┘ │
49//! └─────────────────────────────────────────────────────────────┘
50//! ```
51//!
52//! ## TCP Server Example
53//!
54//! ```rust,no_run
55//! use mabi_modbus::{ModbusTcpServerV2, tcp::ServerConfigV2};
56//!
57//! #[tokio::main]
58//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
59//! let config = ServerConfigV2::default();
60//! let server = ModbusTcpServerV2::new(config);
61//! server.run().await?;
62//! Ok(())
63//! }
64//! ```
65//!
66//! ## RTU Server Example
67//!
68//! ```rust,no_run
69//! use mabi_modbus::rtu::{ModbusRtuServer, RtuServerConfig};
70//!
71//! #[tokio::main]
72//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
73//! let config = RtuServerConfig::default()
74//! .with_unit_ids(vec![1, 2, 3])
75//! .with_broadcast(true);
76//!
77//! let server = ModbusRtuServer::new(config);
78//! server.run().await?;
79//! Ok(())
80//! }
81//! ```
82//!
83//! ## Custom Handlers
84//!
85//! You can implement custom function handlers by implementing the
86//! `FunctionHandler` trait:
87//!
88//! ```rust,ignore
89//! use mabi_modbus::handler::{FunctionHandler, HandlerContext, ExceptionCode};
90//!
91//! pub struct MyCustomHandler;
92//!
93//! impl FunctionHandler for MyCustomHandler {
94//! fn function_code(&self) -> u8 { 0x42 }
95//!
96//! fn handle(&self, pdu: &[u8], ctx: &HandlerContext) -> Result<Vec<u8>, ExceptionCode> {
97//! // Custom implementation
98//! Ok(vec![0x42, 0x00])
99//! }
100//!
101//! fn name(&self) -> &'static str { "My Custom Handler" }
102//! }
103//! ```
104
105pub mod config;
106pub mod device;
107pub mod error;
108pub mod fault_injection;
109pub mod handler;
110pub mod register;
111pub mod registers;
112pub mod rtu;
113pub mod runtime;
114pub mod scalability;
115pub mod server;
116pub mod tcp;
117pub mod testing;
118pub mod types;
119pub mod unit;
120
121// Re-exports for TCP
122pub use config::{ModbusDeviceConfig, ModbusServerConfig};
123pub use device::ModbusDevice;
124pub use error::{ModbusError, ModbusResult};
125pub use register::{RegisterStore, RegisterType};
126pub use server::ModbusTcpServer;
127pub use tcp::ModbusTcpServerV2;
128
129// Re-exports for new sparse register store (Task 2.3)
130pub use registers::{
131 // Config types
132 AddressRange, DefaultValue, InitializationMode, RegisterRangeConfig, RegisterStoreConfig,
133 // Store implementation
134 SparseRegisterStore,
135 // Callback system
136 CallbackManager, CallbackPriority, ReadCallback, ReadCallbackFn, WriteCallback,
137 WriteCallbackFn,
138 // Value types
139 RegisterValue,
140};
141
142// Re-exports for RTU
143pub use rtu::{
144 ModbusRtuServer, RtuCodec, RtuFrame, RtuServerConfig, RtuTiming,
145 SerialConfig, VirtualSerial, VirtualSerialConfig,
146};
147
148// Re-exports for data types and conversion (Task 2.5)
149pub use types::{RegisterConverter, RegisterDataType, TypedValue, WordOrder};
150
151// Re-exports for multi-unit management (Task 2.5)
152pub use unit::{
153 BroadcastMode, MultiUnitManager, UnitConfig, UnitInfo, UnitManagerConfig,
154};
155
156// Re-exports for testing utilities
157pub use testing::{
158 // Performance validation
159 PerformanceValidator, PerformanceConfig, PerformanceTarget, ValidationResult,
160 // Memory profiling
161 MemoryProfiler, MemorySnapshot, MemoryReport, AllocationTracker,
162 // Load generation
163 LoadGenerator, LoadConfig, LoadPattern, ConnectionSimulator,
164 // Reporting
165 TestReport, TestMetrics, TestSummary,
166};
167
168// Re-exports for fault injection
169pub use fault_injection::{
170 FaultAction, FaultPipeline, ModbusFault, ModbusFaultContext, TransportKind,
171 FaultInjectionConfig, FaultConfig, FaultType, FaultTarget,
172 FaultStats, FaultStatsSnapshot,
173 CrcCorruptionFault, WrongUnitIdFault, WrongFunctionCodeFault,
174 WrongTransactionIdFault, TruncatedResponseFault, ExtraDataFault,
175 DelayedResponseFault, NoResponseFault, ExceptionInjectionFault,
176 PartialFrameFault,
177};
178
179// Re-exports for connection disruption
180pub use fault_injection::connection_disruption::{
181 ConnectionDisruptionConfig, ConnectionDisruptionState, DisruptionAction,
182};
183
184// Re-exports for RTU timing faults
185pub use fault_injection::rtu_timing::{
186 RtuTimingFaultConfig, InterCharGapConfig, GapPosition,
187 BusCollisionConfig, CollisionMode,
188 ByteJitterConfig, TimingPlan, TimingSegment,
189};
190
191// Re-exports for runtime configuration
192pub use runtime::{
193 // Core types
194 RuntimeConfigManager, RuntimeState, ConfigUpdate, ConfigEvent, UpdateCategory,
195 // Config types
196 ConnectionLimits, TimeoutConfig, AccessControl, AddressRange as RuntimeAddressRange,
197 FeatureFlags,
198 // Update utilities
199 UpdateBuilder, UpdateRecord, UpdateAuditLog, StateDiff, FieldChange,
200};