quantrs2_device/distributed/
config.rs

1//! Configuration structures for distributed quantum orchestration
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::net::SocketAddr;
6use std::time::Duration;
7
8#[derive(Debug, Clone, Serialize, Deserialize, Default)]
9pub struct DistributedOrchestratorConfig {
10    pub network_config: NetworkConfig,
11    pub computing_config: DistributedComputingConfig,
12    pub load_balancing_config: LoadBalancingConfig,
13    pub fault_tolerance_config: FaultToleranceConfig,
14    pub security_config: SecurityConfig,
15    pub optimization_config: DistributedOptimizationConfig,
16    pub monitoring_config: DistributedMonitoringConfig,
17    pub resource_config: DistributedResourceConfig,
18}
19
20#[derive(Debug, Clone, Serialize, Deserialize)]
21pub struct NetworkConfig {
22    pub topology: NetworkTopology,
23    pub communication_protocol: CommunicationProtocol,
24    pub max_connections: u32,
25    pub connection_timeout: Duration,
26    pub heartbeat_interval: Duration,
27}
28
29impl Default for NetworkConfig {
30    fn default() -> Self {
31        Self {
32            topology: NetworkTopology::Mesh,
33            communication_protocol: CommunicationProtocol::TCP,
34            max_connections: 100,
35            connection_timeout: Duration::from_secs(30),
36            heartbeat_interval: Duration::from_secs(10),
37        }
38    }
39}
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
42pub enum NetworkTopology {
43    Star,
44    Mesh,
45    Ring,
46    Tree,
47    Hybrid,
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
51pub enum CommunicationProtocol {
52    TCP,
53    UDP,
54    QUIC,
55    WebSocket,
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
59pub struct DistributedComputingConfig {
60    pub workload_distribution_strategy: WorkloadDistributionStrategy,
61    pub circuit_decomposition: bool,
62    pub parallel_execution: bool,
63    pub resource_estimation: bool,
64}
65
66impl Default for DistributedComputingConfig {
67    fn default() -> Self {
68        Self {
69            workload_distribution_strategy: WorkloadDistributionStrategy::LoadBased,
70            circuit_decomposition: true,
71            parallel_execution: true,
72            resource_estimation: true,
73        }
74    }
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize)]
78pub enum WorkloadDistributionStrategy {
79    RoundRobin,
80    LoadBased,
81    CapabilityBased,
82    Geographic,
83    CostOptimized,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize)]
87pub struct LoadBalancingConfig {
88    pub algorithm: LoadBalancingAlgorithm,
89    pub rebalancing_threshold: f64,
90    pub monitoring_interval: Duration,
91}
92
93impl Default for LoadBalancingConfig {
94    fn default() -> Self {
95        Self {
96            algorithm: LoadBalancingAlgorithm::WeightedRoundRobin,
97            rebalancing_threshold: 0.8,
98            monitoring_interval: Duration::from_secs(5),
99        }
100    }
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
104pub enum LoadBalancingAlgorithm {
105    RoundRobin,
106    WeightedRoundRobin,
107    LeastConnections,
108    ResourceBased,
109    AdaptiveWeighted,
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct FaultToleranceConfig {
114    pub failure_detection: FailureDetectionConfig,
115    pub replication_strategy: ReplicationStrategy,
116    pub checkpoint_config: CheckpointConfig,
117    pub recovery_timeout: Duration,
118}
119
120impl Default for FaultToleranceConfig {
121    fn default() -> Self {
122        Self {
123            failure_detection: FailureDetectionConfig::default(),
124            replication_strategy: ReplicationStrategy::ActivePassive,
125            checkpoint_config: CheckpointConfig::default(),
126            recovery_timeout: Duration::from_secs(60),
127        }
128    }
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
132pub struct FailureDetectionConfig {
133    pub heartbeat_timeout: Duration,
134    pub max_retries: u32,
135    pub detection_interval: Duration,
136}
137
138impl Default for FailureDetectionConfig {
139    fn default() -> Self {
140        Self {
141            heartbeat_timeout: Duration::from_secs(30),
142            max_retries: 3,
143            detection_interval: Duration::from_secs(5),
144        }
145    }
146}
147
148#[derive(Debug, Clone, Serialize, Deserialize)]
149pub enum ReplicationStrategy {
150    NoReplication,
151    ActivePassive,
152    ActiveActive,
153    ChainReplication,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157pub struct CheckpointConfig {
158    pub checkpoint_interval: Duration,
159    pub checkpoint_storage: String,
160    pub max_checkpoints: u32,
161}
162
163impl Default for CheckpointConfig {
164    fn default() -> Self {
165        Self {
166            checkpoint_interval: Duration::from_secs(300),
167            checkpoint_storage: "local".to_string(),
168            max_checkpoints: 10,
169        }
170    }
171}
172
173#[derive(Debug, Clone, Serialize, Deserialize)]
174pub struct SecurityConfig {
175    pub authentication_method: AuthenticationMethod,
176    pub authorization_model: AuthorizationModel,
177    pub encryption_algorithm: EncryptionAlgorithm,
178    pub key_rotation_interval: Duration,
179}
180
181impl Default for SecurityConfig {
182    fn default() -> Self {
183        Self {
184            authentication_method: AuthenticationMethod::TokenBased,
185            authorization_model: AuthorizationModel::RBAC,
186            encryption_algorithm: EncryptionAlgorithm::AES256,
187            key_rotation_interval: Duration::from_secs(3600),
188        }
189    }
190}
191
192#[derive(Debug, Clone, Serialize, Deserialize)]
193pub enum AuthenticationMethod {
194    TokenBased,
195    CertificateBased,
196    Biometric,
197    MultiFactorAuthentication,
198}
199
200#[derive(Debug, Clone, Serialize, Deserialize)]
201pub enum AuthorizationModel {
202    RBAC,
203    ABAC,
204    DAC,
205    MAC,
206}
207
208#[derive(Debug, Clone, Serialize, Deserialize)]
209pub enum EncryptionAlgorithm {
210    AES256,
211    ChaCha20,
212    PostQuantumKyber,
213    HybridClassicalQuantum,
214}
215
216#[derive(Debug, Clone, Serialize, Deserialize)]
217pub struct DistributedOptimizationConfig {
218    pub objective: OptimizationObjective,
219    pub algorithm: String,
220    pub convergence_threshold: f64,
221    pub max_iterations: u32,
222}
223
224impl Default for DistributedOptimizationConfig {
225    fn default() -> Self {
226        Self {
227            objective: OptimizationObjective::Latency,
228            algorithm: "genetic".to_string(),
229            convergence_threshold: 0.01,
230            max_iterations: 100,
231        }
232    }
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
236pub enum OptimizationObjective {
237    Latency,
238    Throughput,
239    Cost,
240    EnergyEfficiency,
241    MultiObjective,
242}
243
244#[derive(Debug, Clone, Serialize, Deserialize)]
245pub struct DistributedMonitoringConfig {
246    pub performance_monitoring: bool,
247    pub resource_monitoring: bool,
248    pub security_monitoring: bool,
249    pub monitoring_interval: Duration,
250}
251
252impl Default for DistributedMonitoringConfig {
253    fn default() -> Self {
254        Self {
255            performance_monitoring: true,
256            resource_monitoring: true,
257            security_monitoring: true,
258            monitoring_interval: Duration::from_secs(10),
259        }
260    }
261}
262
263#[derive(Debug, Clone, Serialize, Deserialize)]
264pub struct DistributedResourceConfig {
265    pub cpu_allocation: f64,
266    pub memory_allocation: f64,
267    pub network_bandwidth: f64,
268    pub quantum_resource_allocation: f64,
269}
270
271impl Default for DistributedResourceConfig {
272    fn default() -> Self {
273        Self {
274            cpu_allocation: 0.8,
275            memory_allocation: 0.8,
276            network_bandwidth: 0.8,
277            quantum_resource_allocation: 0.9,
278        }
279    }
280}
quantrs2_device/distributed/config.rs

quantrs2_device/distributed/
config.rs
