quantrs2-device 0.1.3

Quantum device connectors for the QuantRS2 framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Session management configurations

use serde::{Deserialize, Serialize};
use std::time::Duration;

/// Session management configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionManagementConfig {
    /// Session affinity
    pub affinity: SessionAffinityConfig,
    /// Session persistence
    pub persistence: SessionPersistenceConfig,
    /// Session replication
    pub replication: SessionReplicationConfig,
}

/// Session affinity configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionAffinityConfig {
    /// Enable session affinity
    pub enabled: bool,
    /// Affinity method
    pub method: AffinityMethod,
    /// Timeout
    pub timeout: Duration,
}

/// Affinity methods
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum AffinityMethod {
    CookieBased,
    IPBased,
    SessionID,
    Custom(String),
}

/// Session persistence configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionPersistenceConfig {
    /// Persistence type
    pub persistence_type: PersistenceType,
    /// Storage backend
    pub storage: SessionStorageConfig,
    /// Encryption
    pub encryption: SessionEncryptionConfig,
}

/// Persistence types
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum PersistenceType {
    InMemory,
    Database,
    Redis,
    File,
    Custom(String),
}

/// Session storage configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionStorageConfig {
    /// Storage type
    pub storage_type: String,
    /// Connection string
    pub connection_string: String,
    /// Pool size
    pub pool_size: usize,
}

/// Session encryption configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionEncryptionConfig {
    /// Enable encryption
    pub enabled: bool,
    /// Encryption algorithm
    pub algorithm: String,
    /// Key management
    pub key_management: KeyManagementConfig,
}

/// Key management configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeyManagementConfig {
    /// Key source
    pub key_source: KeySource,
    /// Key rotation
    pub rotation: KeyRotationConfig,
    /// Key backup
    pub backup: KeyBackupConfig,
}

/// Key sources
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum KeySource {
    Static,
    Environment,
    KeyVault,
    HSM,
    Custom(String),
}

/// Key rotation configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeyRotationConfig {
    /// Enable rotation
    pub enabled: bool,
    /// Rotation interval
    pub interval: Duration,
    /// Overlap period
    pub overlap_period: Duration,
}

/// Key backup configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KeyBackupConfig {
    /// Enable backup
    pub enabled: bool,
    /// Backup frequency
    pub frequency: Duration,
    /// Backup location
    pub location: String,
}

/// Session replication configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SessionReplicationConfig {
    /// Enable replication
    pub enabled: bool,
    /// Replication strategy
    pub strategy: ReplicationStrategy,
    /// Replication factor
    pub factor: usize,
    /// Consistency level
    pub consistency: ConsistencyLevel,
}

/// Replication strategies
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ReplicationStrategy {
    Synchronous,
    Asynchronous,
    SemiSynchronous,
    EventualConsistency,
}

/// Consistency levels
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ConsistencyLevel {
    Strong,
    Eventual,
    Session,
    Bounded,
}