quantrs2_device/cloud/
providers.rs

1//! Multi-Provider Configuration and Management
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5
6/// Supported cloud providers
7#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
8pub enum CloudProvider {
9    /// IBM Quantum
10    IBM,
11    /// AWS Braket
12    AWS,
13    /// Azure Quantum
14    Azure,
15    /// Google Quantum AI
16    Google,
17    /// IonQ
18    IonQ,
19    /// Rigetti
20    Rigetti,
21    /// Xanadu
22    Xanadu,
23    /// D-Wave
24    DWave,
25    /// Custom provider
26    Custom(String),
27}
28
29/// Multi-provider configuration
30#[derive(Debug, Clone, Serialize, Deserialize)]
31pub struct MultiProviderConfig {
32    /// Enabled cloud providers
33    pub enabled_providers: Vec<CloudProvider>,
34    /// Provider-specific configurations
35    pub provider_configs: HashMap<CloudProvider, ProviderConfig>,
36    /// Provider selection strategy
37    pub selection_strategy: ProviderSelectionStrategy,
38    /// Failover configuration
39    pub failover_config: FailoverConfig,
40    /// Cross-provider synchronization
41    pub sync_config: CrossProviderSyncConfig,
42    /// Provider health monitoring
43    pub health_monitoring: ProviderHealthConfig,
44}
45
46/// Provider configuration
47#[derive(Debug, Clone, Serialize, Deserialize, Default)]
48pub struct ProviderConfig {
49    pub api_endpoint: String,
50    pub credentials: HashMap<String, String>,
51    pub resource_limits: HashMap<String, usize>,
52    /// Provider-specific features
53    pub features: ProviderFeatures,
54    /// Connection settings
55    pub connection: ConnectionSettings,
56    /// Rate limiting
57    pub rate_limits: RateLimits,
58}
59
60/// Provider-specific features
61#[derive(Debug, Clone, Serialize, Deserialize)]
62pub struct ProviderFeatures {
63    /// Supported gate sets
64    pub gate_sets: Vec<String>,
65    /// Maximum qubits
66    pub max_qubits: usize,
67    /// Coherence times
68    pub coherence_times: CoherenceMetrics,
69    /// Error rates
70    pub error_rates: ErrorMetrics,
71    /// Special capabilities
72    pub special_capabilities: Vec<SpecialCapability>,
73}
74
75/// Coherence time metrics
76#[derive(Debug, Clone, Serialize, Deserialize)]
77pub struct CoherenceMetrics {
78    /// T1 relaxation time
79    pub t1_avg: f64,
80    /// T2 dephasing time
81    pub t2_avg: f64,
82    /// Gate time
83    pub gate_time_avg: f64,
84}
85
86/// Error rate metrics
87#[derive(Debug, Clone, Serialize, Deserialize)]
88pub struct ErrorMetrics {
89    /// Single qubit gate error
90    pub single_qubit_error: f64,
91    /// Two qubit gate error
92    pub two_qubit_error: f64,
93    /// Readout error
94    pub readout_error: f64,
95}
96
97/// Special capabilities
98#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
99pub enum SpecialCapability {
100    MiddleCircuitMeasurement,
101    DynamicCircuits,
102    ErrorMitigation,
103    PulseControl,
104    ParametricGates,
105    Transpilation,
106    CustomGates,
107}
108
109/// Connection settings
110#[derive(Debug, Clone, Serialize, Deserialize)]
111pub struct ConnectionSettings {
112    /// Connection timeout
113    pub timeout: std::time::Duration,
114    /// Retry attempts
115    pub retry_attempts: usize,
116    /// Keep-alive settings
117    pub keep_alive: bool,
118    /// SSL/TLS configuration
119    pub ssl_config: SSLConfig,
120}
121
122/// SSL/TLS configuration
123#[derive(Debug, Clone, Serialize, Deserialize)]
124pub struct SSLConfig {
125    /// Enable SSL/TLS
126    pub enabled: bool,
127    /// Certificate verification
128    pub verify_certificates: bool,
129    /// Certificate path
130    pub certificate_path: Option<String>,
131}
132
133/// Rate limiting configuration
134#[derive(Debug, Clone, Serialize, Deserialize)]
135pub struct RateLimits {
136    /// Requests per second
137    pub requests_per_second: usize,
138    /// Requests per minute
139    pub requests_per_minute: usize,
140    /// Requests per hour
141    pub requests_per_hour: usize,
142    /// Burst allowance
143    pub burst_allowance: usize,
144}
145
146/// Provider selection strategies
147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
148pub enum ProviderSelectionStrategy {
149    /// Round-robin selection
150    RoundRobin,
151    /// Load-based selection
152    LoadBased,
153    /// Cost-based selection
154    CostBased,
155    /// Performance-based selection
156    PerformanceBased,
157    /// Latency-based selection
158    LatencyBased,
159    /// Availability-based selection
160    AvailabilityBased,
161    /// Multi-criteria selection
162    MultiCriteria(MultiCriteriaConfig),
163    /// Custom selection algorithm
164    Custom(String),
165}
166
167/// Multi-criteria selection configuration
168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
169pub struct MultiCriteriaConfig {
170    /// Criteria weights
171    pub weights: HashMap<SelectionCriterion, f64>,
172    /// Aggregation method
173    pub aggregation_method: AggregationMethod,
174    /// Normalization method
175    pub normalization: NormalizationMethod,
176}
177
178/// Selection criteria
179#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
180pub enum SelectionCriterion {
181    Cost,
182    Performance,
183    Latency,
184    Availability,
185    QueueTime,
186    ErrorRate,
187    ResourceUtilization,
188}
189
190/// Aggregation methods
191#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
192pub enum AggregationMethod {
193    WeightedSum,
194    WeightedProduct,
195    TOPSIS,
196    ELECTRE,
197    AHP,
198}
199
200/// Normalization methods
201#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
202pub enum NormalizationMethod {
203    MinMax,
204    ZScore,
205    Robust,
206    None,
207}
208
209/// Failover configuration
210#[derive(Debug, Clone, Serialize, Deserialize)]
211pub struct FailoverConfig {
212    pub enable_failover: bool,
213    pub failover_threshold: f64,
214    pub failover_providers: Vec<String>,
215    /// Failover strategy
216    pub strategy: FailoverStrategy,
217    /// Detection settings
218    pub detection: FailureDetectionConfig,
219    /// Recovery settings
220    pub recovery: FailoverRecoveryConfig,
221}
222
223/// Failover strategies
224#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
225pub enum FailoverStrategy {
226    Immediate,
227    Graceful,
228    Conditional,
229    Hybrid,
230}
231
232/// Failure detection configuration
233#[derive(Debug, Clone, Serialize, Deserialize)]
234pub struct FailureDetectionConfig {
235    /// Health check interval
236    pub health_check_interval: std::time::Duration,
237    /// Failure threshold
238    pub failure_threshold: usize,
239    /// Detection methods
240    pub detection_methods: Vec<FailureDetectionMethod>,
241}
242
243/// Failure detection methods
244#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
245pub enum FailureDetectionMethod {
246    HealthEndpoint,
247    ResponseTime,
248    ErrorRate,
249    CustomMetric(String),
250}
251
252/// Failover recovery configuration
253#[derive(Debug, Clone, Serialize, Deserialize)]
254pub struct FailoverRecoveryConfig {
255    /// Recovery timeout
256    pub recovery_timeout: std::time::Duration,
257    /// Recovery strategy
258    pub recovery_strategy: RecoveryStrategy,
259    /// Backoff strategy
260    pub backoff: BackoffStrategy,
261}
262
263/// Recovery strategies
264#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
265pub enum RecoveryStrategy {
266    Automatic,
267    Manual,
268    Hybrid,
269}
270
271/// Backoff strategies
272#[derive(Debug, Clone, Serialize, Deserialize)]
273pub struct BackoffStrategy {
274    /// Initial delay
275    pub initial_delay: std::time::Duration,
276    /// Maximum delay
277    pub max_delay: std::time::Duration,
278    /// Backoff multiplier
279    pub multiplier: f64,
280    /// Jitter
281    pub jitter: bool,
282}
283
284/// Cross-provider sync configuration
285#[derive(Debug, Clone, Serialize, Deserialize)]
286pub struct CrossProviderSyncConfig {
287    pub sync_enabled: bool,
288    pub sync_interval: u64,
289    pub sync_strategies: Vec<String>,
290    /// Sync scope
291    pub sync_scope: SyncScope,
292    /// Conflict resolution
293    pub conflict_resolution: ConflictResolution,
294    /// Data consistency
295    pub consistency: ConsistencyConfig,
296}
297
298/// Synchronization scope
299#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
300pub enum SyncScope {
301    JobStatus,
302    ResourceUsage,
303    Configurations,
304    All,
305}
306
307/// Conflict resolution strategies
308#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
309pub enum ConflictResolution {
310    LastWriteWins,
311    FirstWriteWins,
312    MergeStrategy,
313    ManualResolution,
314}
315
316/// Consistency configuration
317#[derive(Debug, Clone, Serialize, Deserialize)]
318pub struct ConsistencyConfig {
319    /// Consistency level
320    pub level: ConsistencyLevel,
321    /// Timeout
322    pub timeout: std::time::Duration,
323    /// Retry policy
324    pub retry_policy: RetryPolicy,
325}
326
327/// Consistency levels
328#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
329pub enum ConsistencyLevel {
330    Strong,
331    Eventual,
332    Session,
333    Bounded,
334}
335
336/// Retry policy
337#[derive(Debug, Clone, Serialize, Deserialize)]
338pub struct RetryPolicy {
339    /// Maximum retries
340    pub max_retries: usize,
341    /// Retry delay
342    pub retry_delay: std::time::Duration,
343    /// Exponential backoff
344    pub exponential_backoff: bool,
345}
346
347/// Provider health configuration
348#[derive(Debug, Clone, Serialize, Deserialize)]
349pub struct ProviderHealthConfig {
350    pub health_check_interval: u64,
351    pub health_thresholds: HashMap<String, f64>,
352    /// Health metrics
353    pub metrics: Vec<HealthMetric>,
354    /// Alerting configuration
355    pub alerting: HealthAlertingConfig,
356}
357
358/// Health metrics
359#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
360pub enum HealthMetric {
361    ResponseTime,
362    ErrorRate,
363    Availability,
364    QueueLength,
365    ResourceUtilization,
366    CustomMetric(String),
367}
368
369/// Health alerting configuration
370#[derive(Debug, Clone, Serialize, Deserialize)]
371pub struct HealthAlertingConfig {
372    /// Enable alerting
373    pub enabled: bool,
374    /// Alert thresholds
375    pub thresholds: HashMap<HealthMetric, f64>,
376    /// Notification channels
377    pub channels: Vec<NotificationChannel>,
378    /// Escalation rules
379    pub escalation: EscalationConfig,
380}
381
382/// Notification channels
383#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
384pub enum NotificationChannel {
385    Email,
386    SMS,
387    Slack,
388    Webhook,
389    Dashboard,
390}
391
392/// Escalation configuration
393#[derive(Debug, Clone, Serialize, Deserialize, Default)]
394pub struct EscalationConfig {
395    /// Escalation levels
396    pub levels: Vec<EscalationLevel>,
397    /// Escalation timeouts
398    pub timeouts: HashMap<String, std::time::Duration>,
399}
400
401/// Escalation level
402#[derive(Debug, Clone, Serialize, Deserialize)]
403pub struct EscalationLevel {
404    /// Level name
405    pub name: String,
406    /// Threshold
407    pub threshold: f64,
408    /// Actions
409    pub actions: Vec<EscalationAction>,
410}
411
412/// Escalation actions
413#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
414pub enum EscalationAction {
415    Notify,
416    Failover,
417    Throttle,
418    Shutdown,
419}
420
421impl Default for MultiProviderConfig {
422    fn default() -> Self {
423        Self {
424            enabled_providers: vec![CloudProvider::IBM, CloudProvider::AWS],
425            provider_configs: HashMap::new(),
426            selection_strategy: ProviderSelectionStrategy::PerformanceBased,
427            failover_config: FailoverConfig::default(),
428            sync_config: CrossProviderSyncConfig::default(),
429            health_monitoring: ProviderHealthConfig::default(),
430        }
431    }
432}
433
434impl Default for ProviderFeatures {
435    fn default() -> Self {
436        Self {
437            gate_sets: vec!["clifford".to_string(), "universal".to_string()],
438            max_qubits: 100,
439            coherence_times: CoherenceMetrics::default(),
440            error_rates: ErrorMetrics::default(),
441            special_capabilities: vec![],
442        }
443    }
444}
445
446impl Default for CoherenceMetrics {
447    fn default() -> Self {
448        Self {
449            t1_avg: 100.0,      // microseconds
450            t2_avg: 50.0,       // microseconds
451            gate_time_avg: 0.1, // microseconds
452        }
453    }
454}
455
456impl Default for ErrorMetrics {
457    fn default() -> Self {
458        Self {
459            single_qubit_error: 0.001,
460            two_qubit_error: 0.01,
461            readout_error: 0.02,
462        }
463    }
464}
465
466impl Default for ConnectionSettings {
467    fn default() -> Self {
468        Self {
469            timeout: std::time::Duration::from_secs(30),
470            retry_attempts: 3,
471            keep_alive: true,
472            ssl_config: SSLConfig::default(),
473        }
474    }
475}
476
477impl Default for SSLConfig {
478    fn default() -> Self {
479        Self {
480            enabled: true,
481            verify_certificates: true,
482            certificate_path: None,
483        }
484    }
485}
486
487impl Default for RateLimits {
488    fn default() -> Self {
489        Self {
490            requests_per_second: 10,
491            requests_per_minute: 100,
492            requests_per_hour: 1000,
493            burst_allowance: 20,
494        }
495    }
496}
497
498impl Default for FailoverConfig {
499    fn default() -> Self {
500        Self {
501            enable_failover: true,
502            failover_threshold: 0.8,
503            failover_providers: vec![],
504            strategy: FailoverStrategy::Graceful,
505            detection: FailureDetectionConfig::default(),
506            recovery: FailoverRecoveryConfig::default(),
507        }
508    }
509}
510
511impl Default for FailureDetectionConfig {
512    fn default() -> Self {
513        Self {
514            health_check_interval: std::time::Duration::from_secs(60),
515            failure_threshold: 3,
516            detection_methods: vec![
517                FailureDetectionMethod::HealthEndpoint,
518                FailureDetectionMethod::ResponseTime,
519            ],
520        }
521    }
522}
523
524impl Default for FailoverRecoveryConfig {
525    fn default() -> Self {
526        Self {
527            recovery_timeout: std::time::Duration::from_secs(300),
528            recovery_strategy: RecoveryStrategy::Automatic,
529            backoff: BackoffStrategy::default(),
530        }
531    }
532}
533
534impl Default for BackoffStrategy {
535    fn default() -> Self {
536        Self {
537            initial_delay: std::time::Duration::from_secs(1),
538            max_delay: std::time::Duration::from_secs(60),
539            multiplier: 2.0,
540            jitter: true,
541        }
542    }
543}
544
545impl Default for CrossProviderSyncConfig {
546    fn default() -> Self {
547        Self {
548            sync_enabled: false,
549            sync_interval: 300, // 5 minutes
550            sync_strategies: vec![],
551            sync_scope: SyncScope::JobStatus,
552            conflict_resolution: ConflictResolution::LastWriteWins,
553            consistency: ConsistencyConfig::default(),
554        }
555    }
556}
557
558impl Default for ConsistencyConfig {
559    fn default() -> Self {
560        Self {
561            level: ConsistencyLevel::Eventual,
562            timeout: std::time::Duration::from_secs(30),
563            retry_policy: RetryPolicy::default(),
564        }
565    }
566}
567
568impl Default for RetryPolicy {
569    fn default() -> Self {
570        Self {
571            max_retries: 3,
572            retry_delay: std::time::Duration::from_secs(1),
573            exponential_backoff: true,
574        }
575    }
576}
577
578impl Default for ProviderHealthConfig {
579    fn default() -> Self {
580        Self {
581            health_check_interval: 60,
582            health_thresholds: HashMap::new(),
583            metrics: vec![
584                HealthMetric::ResponseTime,
585                HealthMetric::ErrorRate,
586                HealthMetric::Availability,
587            ],
588            alerting: HealthAlertingConfig::default(),
589        }
590    }
591}
592
593impl Default for HealthAlertingConfig {
594    fn default() -> Self {
595        Self {
596            enabled: true,
597            thresholds: HashMap::new(),
598            channels: vec![NotificationChannel::Dashboard],
599            escalation: EscalationConfig::default(),
600        }
601    }
602}
quantrs2_device/cloud/providers.rs

quantrs2_device/cloud/
providers.rs
