quantrs2_device/cloud/
allocation.rs

1//! Resource Allocation and Optimization Configuration
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5use std::time::Duration;
6
7/// Resource allocation configuration
8#[derive(Debug, Clone, Serialize, Deserialize)]
9pub struct ResourceAllocationConfig {
10    /// Allocation algorithms
11    pub allocation_algorithms: Vec<AllocationAlgorithm>,
12    /// Resource optimization objectives
13    pub optimization_objectives: Vec<ResourceOptimizationObjective>,
14    /// Allocation constraints
15    pub allocation_constraints: AllocationConstraints,
16    /// Dynamic reallocation settings
17    pub dynamic_reallocation: DynamicReallocationConfig,
18    /// Predictive allocation
19    pub predictive_allocation: PredictiveAllocationConfig,
20    /// Multi-objective optimization
21    pub multi_objective_config: MultiObjectiveAllocationConfig,
22}
23
24/// Allocation algorithms
25#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
26pub enum AllocationAlgorithm {
27    FirstFit,
28    BestFit,
29    WorstFit,
30    NextFit,
31    RoundRobin,
32    LoadBalanced,
33    CostOptimized,
34    PerformanceOptimized,
35    HybridOptimized,
36    MachineLearningBased,
37    GeneticAlgorithm,
38    SimulatedAnnealing,
39}
40
41/// Resource optimization objectives
42#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
43pub enum ResourceOptimizationObjective {
44    MinimizeCost,
45    MaximizePerformance,
46    MinimizeLatency,
47    MaximizeUtilization,
48    MinimizeEnergyConsumption,
49    BalanceLoadDistribution,
50    OptimizeQueueTime,
51    CustomObjective(String),
52}
53
54/// Allocation constraints
55#[derive(Debug, Clone, Serialize, Deserialize, Default)]
56pub struct AllocationConstraints {
57    pub max_memory: Option<usize>,
58    pub max_cpu: Option<usize>,
59    pub max_gpus: Option<usize>,
60    pub required_features: Vec<String>,
61    /// Geographic constraints
62    pub geographic: GeographicConstraints,
63    /// Security constraints
64    pub security: SecurityConstraints,
65    /// Performance constraints
66    pub performance: PerformanceConstraints,
67    /// Cost constraints
68    pub cost: CostConstraints,
69}
70
71/// Geographic constraints
72#[derive(Debug, Clone, Serialize, Deserialize, Default)]
73pub struct GeographicConstraints {
74    /// Allowed regions
75    pub allowed_regions: Vec<String>,
76    /// Prohibited regions
77    pub prohibited_regions: Vec<String>,
78    /// Data residency requirements
79    pub data_residency: DataResidencyRequirements,
80    /// Latency constraints
81    pub latency_constraints: LatencyConstraints,
82}
83
84/// Data residency requirements
85#[derive(Debug, Clone, Serialize, Deserialize, Default)]
86pub struct DataResidencyRequirements {
87    /// Required countries
88    pub required_countries: Vec<String>,
89    /// Prohibited countries
90    pub prohibited_countries: Vec<String>,
91    /// Compliance frameworks
92    pub compliance_frameworks: Vec<ComplianceFramework>,
93}
94
95/// Compliance frameworks
96#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
97pub enum ComplianceFramework {
98    GDPR,
99    HIPAA,
100    SOC2,
101    ISO27001,
102    FedRAMP,
103    Custom(String),
104}
105
106/// Latency constraints
107#[derive(Debug, Clone, Serialize, Deserialize)]
108pub struct LatencyConstraints {
109    /// Maximum latency
110    pub max_latency: Duration,
111    /// Target latency
112    pub target_latency: Duration,
113    /// Latency percentile requirements
114    pub percentile_requirements: HashMap<String, Duration>,
115}
116
117/// Security constraints
118#[derive(Debug, Clone, Serialize, Deserialize)]
119pub struct SecurityConstraints {
120    /// Required security features
121    pub required_features: Vec<SecurityFeature>,
122    /// Encryption requirements
123    pub encryption: EncryptionRequirements,
124    /// Access control requirements
125    pub access_control: AccessControlRequirements,
126    /// Audit requirements
127    pub audit: AuditRequirements,
128}
129
130/// Security features
131#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
132pub enum SecurityFeature {
133    EncryptionAtRest,
134    EncryptionInTransit,
135    MultiFactorAuthentication,
136    RoleBasedAccess,
137    NetworkIsolation,
138    VPN,
139    PrivateNetworking,
140    Custom(String),
141}
142
143/// Encryption requirements
144#[derive(Debug, Clone, Serialize, Deserialize)]
145pub struct EncryptionRequirements {
146    /// Minimum encryption strength
147    pub min_key_length: usize,
148    /// Allowed algorithms
149    pub allowed_algorithms: Vec<String>,
150    /// Key management requirements
151    pub key_management: KeyManagementRequirements,
152}
153
154/// Key management requirements
155#[derive(Debug, Clone, Serialize, Deserialize)]
156pub struct KeyManagementRequirements {
157    /// Hardware security modules required
158    pub hsm_required: bool,
159    /// Key rotation period
160    pub rotation_period: Duration,
161    /// Backup requirements
162    pub backup_requirements: BackupRequirements,
163}
164
165/// Backup requirements
166#[derive(Debug, Clone, Serialize, Deserialize)]
167pub struct BackupRequirements {
168    /// Backup frequency
169    pub frequency: Duration,
170    /// Retention period
171    pub retention_period: Duration,
172    /// Geographic distribution
173    pub geo_distribution: bool,
174}
175
176/// Access control requirements
177#[derive(Debug, Clone, Serialize, Deserialize)]
178pub struct AccessControlRequirements {
179    /// Authentication methods
180    pub auth_methods: Vec<AuthenticationMethod>,
181    /// Authorization model
182    pub authz_model: AuthorizationModel,
183    /// Session management
184    pub session_management: SessionManagement,
185}
186
187/// Authentication methods
188#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
189pub enum AuthenticationMethod {
190    Password,
191    TwoFactor,
192    Biometric,
193    Certificate,
194    SAML,
195    OAuth,
196    Custom(String),
197}
198
199/// Authorization models
200#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
201pub enum AuthorizationModel {
202    RBAC,
203    ABAC,
204    DAC,
205    MAC,
206    Custom(String),
207}
208
209/// Session management requirements
210#[derive(Debug, Clone, Serialize, Deserialize)]
211pub struct SessionManagement {
212    /// Session timeout
213    pub timeout: Duration,
214    /// Concurrent session limit
215    pub concurrent_limit: usize,
216    /// Idle timeout
217    pub idle_timeout: Duration,
218}
219
220/// Audit requirements
221#[derive(Debug, Clone, Serialize, Deserialize)]
222pub struct AuditRequirements {
223    /// Audit events
224    pub events: Vec<AuditEvent>,
225    /// Retention period
226    pub retention_period: Duration,
227    /// Integrity protection
228    pub integrity_protection: bool,
229}
230
231/// Audit events
232#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
233pub enum AuditEvent {
234    Login,
235    Logout,
236    DataAccess,
237    DataModification,
238    ConfigurationChange,
239    PrivilegeEscalation,
240    Custom(String),
241}
242
243/// Performance constraints
244#[derive(Debug, Clone, Serialize, Deserialize)]
245pub struct PerformanceConstraints {
246    /// Minimum performance requirements
247    pub min_performance: PerformanceRequirements,
248    /// Maximum acceptable degradation
249    pub max_degradation: f64,
250    /// SLA requirements
251    pub sla_requirements: SLARequirements,
252}
253
254/// Performance requirements
255#[derive(Debug, Clone, Serialize, Deserialize)]
256pub struct PerformanceRequirements {
257    /// Minimum throughput
258    pub min_throughput: f64,
259    /// Maximum latency
260    pub max_latency: Duration,
261    /// Minimum availability
262    pub min_availability: f64,
263    /// Custom metrics
264    pub custom_metrics: HashMap<String, f64>,
265}
266
267/// SLA requirements
268#[derive(Debug, Clone, Serialize, Deserialize)]
269pub struct SLARequirements {
270    /// Uptime SLA
271    pub uptime_sla: f64,
272    /// Performance SLA
273    pub performance_sla: HashMap<String, f64>,
274    /// Support response time
275    pub support_response_time: Duration,
276}
277
278/// Cost constraints
279#[derive(Debug, Clone, Serialize, Deserialize)]
280pub struct CostConstraints {
281    /// Maximum hourly cost
282    pub max_hourly_cost: Option<f64>,
283    /// Maximum daily cost
284    pub max_daily_cost: Option<f64>,
285    /// Maximum monthly cost
286    pub max_monthly_cost: Option<f64>,
287    /// Cost optimization strategy
288    pub optimization_strategy: CostOptimizationStrategy,
289}
290
291/// Cost optimization strategies
292#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
293pub enum CostOptimizationStrategy {
294    MinimizeTotal,
295    OptimizePerformancePerDollar,
296    BalanceCostPerformance,
297    PreferSpotInstances,
298    PreferReservedInstances,
299    Custom(String),
300}
301
302/// Dynamic reallocation configuration
303#[derive(Debug, Clone, Serialize, Deserialize)]
304pub struct DynamicReallocationConfig {
305    pub enable_dynamic_reallocation: bool,
306    pub reallocation_threshold: f64,
307    pub reallocation_strategies: Vec<String>,
308    /// Reallocation triggers
309    pub triggers: Vec<ReallocationTrigger>,
310    /// Reallocation policies
311    pub policies: Vec<ReallocationPolicy>,
312    /// Migration settings
313    pub migration: MigrationSettings,
314}
315
316/// Reallocation triggers
317#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
318pub enum ReallocationTrigger {
319    ResourceUtilization,
320    PerformanceDegradation,
321    CostThreshold,
322    LoadImbalance,
323    MaintenanceWindow,
324    Custom(String),
325}
326
327/// Reallocation policies
328#[derive(Debug, Clone, Serialize, Deserialize)]
329pub struct ReallocationPolicy {
330    /// Policy name
331    pub name: String,
332    /// Conditions
333    pub conditions: Vec<PolicyCondition>,
334    /// Actions
335    pub actions: Vec<PolicyAction>,
336    /// Priority
337    pub priority: u8,
338}
339
340/// Policy conditions
341#[derive(Debug, Clone, Serialize, Deserialize)]
342pub struct PolicyCondition {
343    /// Metric name
344    pub metric: String,
345    /// Operator
346    pub operator: ComparisonOperator,
347    /// Threshold value
348    pub threshold: f64,
349    /// Duration
350    pub duration: Duration,
351}
352
353/// Comparison operators
354#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
355pub enum ComparisonOperator {
356    GreaterThan,
357    LessThan,
358    Equal,
359    GreaterThanOrEqual,
360    LessThanOrEqual,
361    NotEqual,
362}
363
364/// Policy actions
365#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
366pub enum PolicyAction {
367    ScaleUp,
368    ScaleDown,
369    Migrate,
370    Rebalance,
371    Alert,
372    Custom(String),
373}
374
375/// Migration settings
376#[derive(Debug, Clone, Serialize, Deserialize)]
377pub struct MigrationSettings {
378    /// Migration strategy
379    pub strategy: MigrationStrategy,
380    /// Downtime tolerance
381    pub downtime_tolerance: Duration,
382    /// Data transfer settings
383    pub data_transfer: DataTransferSettings,
384    /// Rollback settings
385    pub rollback: RollbackSettings,
386}
387
388/// Migration strategies
389#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
390pub enum MigrationStrategy {
391    LiveMigration,
392    ColdMigration,
393    HybridMigration,
394    IncrementalMigration,
395}
396
397/// Data transfer settings
398#[derive(Debug, Clone, Serialize, Deserialize)]
399pub struct DataTransferSettings {
400    /// Transfer method
401    pub method: DataTransferMethod,
402    /// Bandwidth limit
403    pub bandwidth_limit: Option<u64>,
404    /// Compression
405    pub compression: bool,
406    /// Encryption
407    pub encryption: bool,
408}
409
410/// Data transfer methods
411#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
412pub enum DataTransferMethod {
413    NetworkCopy,
414    PhysicalTransfer,
415    SnapshotReplication,
416    IncrementalSync,
417}
418
419/// Rollback settings
420#[derive(Debug, Clone, Serialize, Deserialize)]
421pub struct RollbackSettings {
422    /// Enable automatic rollback
423    pub auto_rollback: bool,
424    /// Rollback conditions
425    pub conditions: Vec<RollbackCondition>,
426    /// Rollback timeout
427    pub timeout: Duration,
428}
429
430/// Rollback conditions
431#[derive(Debug, Clone, Serialize, Deserialize)]
432pub struct RollbackCondition {
433    /// Condition type
434    pub condition_type: RollbackConditionType,
435    /// Threshold
436    pub threshold: f64,
437    /// Duration
438    pub duration: Duration,
439}
440
441/// Rollback condition types
442#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
443pub enum RollbackConditionType {
444    PerformanceDegradation,
445    ErrorRateIncrease,
446    ServiceFailure,
447    UserDefined(String),
448}
449
450/// Predictive allocation configuration
451#[derive(Debug, Clone, Serialize, Deserialize)]
452pub struct PredictiveAllocationConfig {
453    pub enable_prediction: bool,
454    pub prediction_models: Vec<String>,
455    pub prediction_window: u64,
456    /// Prediction algorithms
457    pub algorithms: Vec<PredictionAlgorithm>,
458    /// Training configuration
459    pub training: PredictionTrainingConfig,
460    /// Validation settings
461    pub validation: PredictionValidationConfig,
462}
463
464/// Prediction algorithms
465#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
466pub enum PredictionAlgorithm {
467    LinearRegression,
468    ARIMA,
469    LSTM,
470    RandomForest,
471    SVM,
472    EnsembleMethod,
473    Custom(String),
474}
475
476/// Prediction training configuration
477#[derive(Debug, Clone, Serialize, Deserialize)]
478pub struct PredictionTrainingConfig {
479    /// Training data size
480    pub data_size: usize,
481    /// Update frequency
482    pub update_frequency: Duration,
483    /// Feature selection
484    pub feature_selection: FeatureSelectionConfig,
485    /// Model validation
486    pub validation: ModelValidationConfig,
487}
488
489/// Feature selection configuration
490#[derive(Debug, Clone, Serialize, Deserialize)]
491pub struct FeatureSelectionConfig {
492    /// Selection method
493    pub method: FeatureSelectionMethod,
494    /// Number of features
495    pub num_features: Option<usize>,
496    /// Importance threshold
497    pub importance_threshold: Option<f64>,
498}
499
500/// Feature selection methods
501#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
502pub enum FeatureSelectionMethod {
503    VarianceThreshold,
504    UnivariateSelection,
505    RecursiveElimination,
506    FeatureImportance,
507    Custom(String),
508}
509
510/// Model validation configuration
511#[derive(Debug, Clone, Serialize, Deserialize)]
512pub struct ModelValidationConfig {
513    /// Validation method
514    pub method: ValidationMethod,
515    /// Test size
516    pub test_size: f64,
517    /// Cross-validation folds
518    pub cv_folds: usize,
519}
520
521/// Validation methods
522#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
523pub enum ValidationMethod {
524    HoldOut,
525    CrossValidation,
526    TimeSeriesSplit,
527    Custom(String),
528}
529
530/// Prediction validation configuration
531#[derive(Debug, Clone, Serialize, Deserialize)]
532pub struct PredictionValidationConfig {
533    /// Accuracy threshold
534    pub accuracy_threshold: f64,
535    /// Confidence interval
536    pub confidence_interval: f64,
537    /// Validation frequency
538    pub validation_frequency: Duration,
539}
540
541/// Multi-objective allocation configuration
542#[derive(Debug, Clone, Serialize, Deserialize)]
543pub struct MultiObjectiveAllocationConfig {
544    pub objectives: Vec<String>,
545    pub objective_weights: Vec<f64>,
546    pub optimization_method: String,
547    /// Pareto optimization
548    pub pareto_optimization: ParetoOptimizationConfig,
549    /// Constraint handling
550    pub constraint_handling: ConstraintHandlingConfig,
551    /// Solution selection
552    pub solution_selection: SolutionSelectionConfig,
553}
554
555/// Pareto optimization configuration
556#[derive(Debug, Clone, Serialize, Deserialize)]
557pub struct ParetoOptimizationConfig {
558    /// Population size
559    pub population_size: usize,
560    /// Number of generations
561    pub generations: usize,
562    /// Crossover probability
563    pub crossover_prob: f64,
564    /// Mutation probability
565    pub mutation_prob: f64,
566}
567
568/// Constraint handling configuration
569#[derive(Debug, Clone, Serialize, Deserialize)]
570pub struct ConstraintHandlingConfig {
571    /// Handling method
572    pub method: ConstraintHandlingMethod,
573    /// Penalty parameters
574    pub penalty_params: HashMap<String, f64>,
575    /// Repair mechanisms
576    pub repair_mechanisms: Vec<RepairMechanism>,
577}
578
579/// Constraint handling methods
580#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
581pub enum ConstraintHandlingMethod {
582    PenaltyMethod,
583    BarrierMethod,
584    AugmentedLagrangian,
585    DeathPenalty,
586    RepairMethod,
587}
588
589/// Repair mechanisms
590#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
591pub enum RepairMechanism {
592    RandomRepair,
593    GreedyRepair,
594    LocalSearchRepair,
595    Custom(String),
596}
597
598/// Solution selection configuration
599#[derive(Debug, Clone, Serialize, Deserialize)]
600pub struct SolutionSelectionConfig {
601    /// Selection method
602    pub method: SolutionSelectionMethod,
603    /// Selection criteria
604    pub criteria: Vec<SelectionCriterion>,
605    /// User preferences
606    pub preferences: UserPreferences,
607}
608
609/// Solution selection methods
610#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
611pub enum SolutionSelectionMethod {
612    WeightedSum,
613    TOPSIS,
614    ELECTRE,
615    PROMETHEE,
616    UserInteractive,
617}
618
619/// Selection criteria
620#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
621pub enum SelectionCriterion {
622    MinDistance,
623    MaxUtility,
624    UserPreference,
625    Custom(String),
626}
627
628/// User preferences
629#[derive(Debug, Clone, Serialize, Deserialize, Default)]
630pub struct UserPreferences {
631    /// Preference weights
632    pub weights: HashMap<String, f64>,
633    /// Preference constraints
634    pub constraints: Vec<PreferenceConstraint>,
635    /// Interactive feedback
636    pub interactive_feedback: bool,
637}
638
639/// Preference constraints
640#[derive(Debug, Clone, Serialize, Deserialize)]
641pub struct PreferenceConstraint {
642    /// Objective name
643    pub objective: String,
644    /// Minimum acceptable value
645    pub min_value: Option<f64>,
646    /// Maximum acceptable value
647    pub max_value: Option<f64>,
648    /// Target value
649    pub target_value: Option<f64>,
650}
651
652impl Default for ResourceAllocationConfig {
653    fn default() -> Self {
654        Self {
655            allocation_algorithms: vec![
656                AllocationAlgorithm::BestFit,
657                AllocationAlgorithm::LoadBalanced,
658            ],
659            optimization_objectives: vec![
660                ResourceOptimizationObjective::BalanceLoadDistribution,
661                ResourceOptimizationObjective::MinimizeCost,
662            ],
663            allocation_constraints: AllocationConstraints::default(),
664            dynamic_reallocation: DynamicReallocationConfig::default(),
665            predictive_allocation: PredictiveAllocationConfig::default(),
666            multi_objective_config: MultiObjectiveAllocationConfig::default(),
667        }
668    }
669}
670
671impl Default for LatencyConstraints {
672    fn default() -> Self {
673        Self {
674            max_latency: Duration::from_secs(5),
675            target_latency: Duration::from_secs(1),
676            percentile_requirements: HashMap::new(),
677        }
678    }
679}
680
681impl Default for SecurityConstraints {
682    fn default() -> Self {
683        Self {
684            required_features: vec![
685                SecurityFeature::EncryptionAtRest,
686                SecurityFeature::EncryptionInTransit,
687            ],
688            encryption: EncryptionRequirements::default(),
689            access_control: AccessControlRequirements::default(),
690            audit: AuditRequirements::default(),
691        }
692    }
693}
694
695impl Default for EncryptionRequirements {
696    fn default() -> Self {
697        Self {
698            min_key_length: 256,
699            allowed_algorithms: vec!["AES-256".to_string()],
700            key_management: KeyManagementRequirements::default(),
701        }
702    }
703}
704
705impl Default for KeyManagementRequirements {
706    fn default() -> Self {
707        Self {
708            hsm_required: false,
709            rotation_period: Duration::from_secs(86400 * 90), // 90 days
710            backup_requirements: BackupRequirements::default(),
711        }
712    }
713}
714
715impl Default for BackupRequirements {
716    fn default() -> Self {
717        Self {
718            frequency: Duration::from_secs(86400),              // daily
719            retention_period: Duration::from_secs(86400 * 365), // 1 year
720            geo_distribution: false,
721        }
722    }
723}
724
725impl Default for AccessControlRequirements {
726    fn default() -> Self {
727        Self {
728            auth_methods: vec![AuthenticationMethod::Password],
729            authz_model: AuthorizationModel::RBAC,
730            session_management: SessionManagement::default(),
731        }
732    }
733}
734
735impl Default for SessionManagement {
736    fn default() -> Self {
737        Self {
738            timeout: Duration::from_secs(3600), // 1 hour
739            concurrent_limit: 5,
740            idle_timeout: Duration::from_secs(900), // 15 minutes
741        }
742    }
743}
744
745impl Default for AuditRequirements {
746    fn default() -> Self {
747        Self {
748            events: vec![
749                AuditEvent::Login,
750                AuditEvent::DataAccess,
751                AuditEvent::ConfigurationChange,
752            ],
753            retention_period: Duration::from_secs(86400 * 365), // 1 year
754            integrity_protection: true,
755        }
756    }
757}
758
759impl Default for PerformanceConstraints {
760    fn default() -> Self {
761        Self {
762            min_performance: PerformanceRequirements::default(),
763            max_degradation: 0.1, // 10%
764            sla_requirements: SLARequirements::default(),
765        }
766    }
767}
768
769impl Default for PerformanceRequirements {
770    fn default() -> Self {
771        Self {
772            min_throughput: 1.0,
773            max_latency: Duration::from_secs(5),
774            min_availability: 0.99,
775            custom_metrics: HashMap::new(),
776        }
777    }
778}
779
780impl Default for SLARequirements {
781    fn default() -> Self {
782        Self {
783            uptime_sla: 0.99,
784            performance_sla: HashMap::new(),
785            support_response_time: Duration::from_secs(3600), // 1 hour
786        }
787    }
788}
789
790impl Default for CostConstraints {
791    fn default() -> Self {
792        Self {
793            max_hourly_cost: None,
794            max_daily_cost: None,
795            max_monthly_cost: None,
796            optimization_strategy: CostOptimizationStrategy::BalanceCostPerformance,
797        }
798    }
799}
800
801impl Default for DynamicReallocationConfig {
802    fn default() -> Self {
803        Self {
804            enable_dynamic_reallocation: true,
805            reallocation_threshold: 0.8,
806            reallocation_strategies: vec![],
807            triggers: vec![
808                ReallocationTrigger::ResourceUtilization,
809                ReallocationTrigger::PerformanceDegradation,
810            ],
811            policies: vec![],
812            migration: MigrationSettings::default(),
813        }
814    }
815}
816
817impl Default for MigrationSettings {
818    fn default() -> Self {
819        Self {
820            strategy: MigrationStrategy::LiveMigration,
821            downtime_tolerance: Duration::from_secs(30),
822            data_transfer: DataTransferSettings::default(),
823            rollback: RollbackSettings::default(),
824        }
825    }
826}
827
828impl Default for DataTransferSettings {
829    fn default() -> Self {
830        Self {
831            method: DataTransferMethod::NetworkCopy,
832            bandwidth_limit: None,
833            compression: true,
834            encryption: true,
835        }
836    }
837}
838
839impl Default for RollbackSettings {
840    fn default() -> Self {
841        Self {
842            auto_rollback: true,
843            conditions: vec![],
844            timeout: Duration::from_secs(600), // 10 minutes
845        }
846    }
847}
848
849impl Default for PredictiveAllocationConfig {
850    fn default() -> Self {
851        Self {
852            enable_prediction: false,
853            prediction_models: vec![],
854            prediction_window: 3600, // 1 hour
855            algorithms: vec![PredictionAlgorithm::LinearRegression],
856            training: PredictionTrainingConfig::default(),
857            validation: PredictionValidationConfig::default(),
858        }
859    }
860}
861
862impl Default for PredictionTrainingConfig {
863    fn default() -> Self {
864        Self {
865            data_size: 1000,
866            update_frequency: Duration::from_secs(3600), // 1 hour
867            feature_selection: FeatureSelectionConfig::default(),
868            validation: ModelValidationConfig::default(),
869        }
870    }
871}
872
873impl Default for FeatureSelectionConfig {
874    fn default() -> Self {
875        Self {
876            method: FeatureSelectionMethod::VarianceThreshold,
877            num_features: None,
878            importance_threshold: None,
879        }
880    }
881}
882
883impl Default for ModelValidationConfig {
884    fn default() -> Self {
885        Self {
886            method: ValidationMethod::CrossValidation,
887            test_size: 0.2,
888            cv_folds: 5,
889        }
890    }
891}
892
893impl Default for PredictionValidationConfig {
894    fn default() -> Self {
895        Self {
896            accuracy_threshold: 0.8,
897            confidence_interval: 0.95,
898            validation_frequency: Duration::from_secs(86400), // daily
899        }
900    }
901}
902
903impl Default for MultiObjectiveAllocationConfig {
904    fn default() -> Self {
905        Self {
906            objectives: vec!["cost".to_string(), "performance".to_string()],
907            objective_weights: vec![0.5, 0.5],
908            optimization_method: "NSGA-II".to_string(),
909            pareto_optimization: ParetoOptimizationConfig::default(),
910            constraint_handling: ConstraintHandlingConfig::default(),
911            solution_selection: SolutionSelectionConfig::default(),
912        }
913    }
914}
915
916impl Default for ParetoOptimizationConfig {
917    fn default() -> Self {
918        Self {
919            population_size: 100,
920            generations: 50,
921            crossover_prob: 0.9,
922            mutation_prob: 0.1,
923        }
924    }
925}
926
927impl Default for ConstraintHandlingConfig {
928    fn default() -> Self {
929        Self {
930            method: ConstraintHandlingMethod::PenaltyMethod,
931            penalty_params: HashMap::new(),
932            repair_mechanisms: vec![],
933        }
934    }
935}
936
937impl Default for SolutionSelectionConfig {
938    fn default() -> Self {
939        Self {
940            method: SolutionSelectionMethod::TOPSIS,
941            criteria: vec![SelectionCriterion::MinDistance],
942            preferences: UserPreferences::default(),
943        }
944    }
945}
quantrs2_device/cloud/allocation.rs

quantrs2_device/cloud/
allocation.rs
