sklears_compose/
execution_types.rs

1//! Core Execution Type Definitions
2//!
3//! This module provides the fundamental type definitions used throughout the
4//! composable execution engine, including task definitions, result types,
5//! metadata structures, and execution parameters.
6
7use sklears_core::error::Result as SklResult;
8use std::any::Any;
9use std::collections::HashMap;
10use std::fmt;
11use std::time::{Duration, SystemTime};
12
13/// Core execution task definition
14///
15/// Represents a single unit of work that can be executed by the
16/// composable execution engine with configurable requirements and constraints.
17pub struct ExecutionTask {
18    /// Unique task identifier
19    pub id: String,
20
21    /// Task type classification
22    pub task_type: TaskType,
23
24    /// Task function to execute (boxed closure)
25    pub task_fn: Box<dyn Fn() -> SklResult<()> + Send + Sync>,
26
27    /// Task metadata and configuration
28    pub metadata: TaskMetadata,
29
30    /// Resource requirements for execution
31    pub requirements: TaskRequirements,
32
33    /// Execution constraints and limits
34    pub constraints: TaskConstraints,
35}
36
37impl fmt::Debug for ExecutionTask {
38    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
39        f.debug_struct("ExecutionTask")
40            .field("id", &self.id)
41            .field("task_type", &self.task_type)
42            .field("task_fn", &"<function>")
43            .field("metadata", &self.metadata)
44            .field("requirements", &self.requirements)
45            .field("constraints", &self.constraints)
46            .finish()
47    }
48}
49
50impl Clone for ExecutionTask {
51    fn clone(&self) -> Self {
52        // Note: task_fn cannot be cloned, so we create a new placeholder
53        Self {
54            id: self.id.clone(),
55            task_type: self.task_type.clone(),
56            task_fn: Box::new(|| Ok(())), // Placeholder function
57            metadata: self.metadata.clone(),
58            requirements: self.requirements.clone(),
59            constraints: self.constraints.clone(),
60        }
61    }
62}
63
64/// Task type classification for execution strategies
65///
66/// Categorizes tasks to help the execution engine select appropriate
67/// strategies and optimizations based on task characteristics.
68#[derive(Debug, Clone, PartialEq, Eq, Hash)]
69pub enum TaskType {
70    /// Data transformation task
71    Transform,
72
73    /// Model training task
74    Fit,
75
76    /// Prediction/inference task
77    Predict,
78
79    /// Data preprocessing task
80    Preprocess,
81
82    /// Result postprocessing task
83    Postprocess,
84
85    /// Data validation task
86    Validate,
87
88    /// Feature engineering task
89    FeatureEngineering,
90
91    /// Model evaluation task
92    Evaluate,
93
94    /// Hyperparameter optimization task
95    HyperparameterOptimization,
96
97    /// Cross-validation task
98    CrossValidation,
99
100    /// Ensemble learning task
101    Ensemble,
102
103    /// Data loading/saving task
104    DataIO,
105
106    /// Visualization task
107    Visualization,
108
109    /// Custom task type
110    Custom(String),
111}
112
113/// Task execution status enumeration
114///
115/// Tracks the current state of task execution throughout its lifecycle.
116#[derive(Debug, Clone, PartialEq, Eq)]
117pub enum TaskStatus {
118    /// Task is queued and waiting to start
119    Pending,
120
121    /// Task is currently running
122    Running,
123
124    /// Task completed successfully
125    Completed,
126
127    /// Task failed during execution
128    Failed,
129
130    /// Task was cancelled before completion
131    Cancelled,
132
133    /// Task execution timed out
134    Timeout,
135
136    /// Task is being retried after failure
137    Retrying,
138
139    /// Task is paused/suspended
140    Paused,
141
142    /// Task is being rolled back
143    RollingBack,
144}
145
146/// Task priority levels for scheduling
147///
148/// Defines the relative importance of tasks for scheduling decisions
149/// and resource allocation prioritization.
150#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
151pub enum TaskPriority {
152    /// Lowest priority (background tasks)
153    Low,
154
155    /// Normal priority (default)
156    Normal,
157
158    /// High priority (important tasks)
159    High,
160
161    /// Critical priority (time-sensitive tasks)
162    Critical,
163
164    /// System priority (infrastructure tasks)
165    System,
166}
167
168/// Comprehensive task metadata
169///
170/// Contains descriptive information, timing details, and organizational
171/// data for tasks to support tracking, debugging, and optimization.
172#[derive(Debug, Clone)]
173pub struct TaskMetadata {
174    /// Human-readable task name
175    pub name: String,
176
177    /// Optional task description
178    pub description: Option<String>,
179
180    /// Organizational tags for grouping
181    pub tags: Vec<String>,
182
183    /// Task creation timestamp
184    pub created_at: SystemTime,
185
186    /// Estimated execution duration
187    pub estimated_duration: Option<Duration>,
188
189    /// Task priority level
190    pub priority: TaskPriority,
191
192    /// Task dependencies (IDs of tasks that must complete first)
193    pub dependencies: Vec<String>,
194
195    /// Task group identifier for batch operations
196    pub group_id: Option<String>,
197
198    /// User who submitted the task
199    pub submitted_by: Option<String>,
200
201    /// Additional custom metadata
202    pub custom_metadata: HashMap<String, MetadataValue>,
203
204    /// Task retry configuration
205    pub retry_config: Option<TaskRetryConfig>,
206
207    /// Task timeout configuration
208    pub timeout_config: Option<TaskTimeoutConfig>,
209}
210
211/// Flexible metadata value types
212#[derive(Debug, Clone)]
213pub enum MetadataValue {
214    /// String
215    String(String),
216    /// Integer
217    Integer(i64),
218    /// Float
219    Float(f64),
220    /// Boolean
221    Boolean(bool),
222    /// Timestamp
223    Timestamp(SystemTime),
224    /// Duration
225    Duration(Duration),
226    /// Array
227    Array(Vec<MetadataValue>),
228    /// Object
229    Object(HashMap<String, MetadataValue>),
230}
231
232/// Task retry configuration
233#[derive(Debug, Clone)]
234pub struct TaskRetryConfig {
235    /// Maximum number of retry attempts
236    pub max_retries: usize,
237
238    /// Delay between retry attempts
239    pub retry_delay: Duration,
240
241    /// Backoff strategy for retry delays
242    pub backoff_strategy: RetryBackoffStrategy,
243
244    /// Conditions that trigger retries
245    pub retry_conditions: Vec<RetryCondition>,
246
247    /// Maximum total retry time
248    pub max_retry_time: Option<Duration>,
249}
250
251/// Retry backoff strategies
252#[derive(Debug, Clone)]
253pub enum RetryBackoffStrategy {
254    /// Fixed delay between retries
255    Fixed,
256
257    /// Linear increase in delay
258    Linear { increment: Duration },
259
260    /// Exponential backoff
261    Exponential { multiplier: f64 },
262
263    /// Jittered exponential backoff
264    JitteredExponential { multiplier: f64, jitter: f64 },
265
266    /// Custom backoff function
267    Custom { strategy_name: String },
268}
269
270/// Conditions that trigger task retries
271#[derive(Debug, Clone)]
272pub enum RetryCondition {
273    /// Retry on any failure
274    AnyFailure,
275
276    /// Retry on specific error types
277    ErrorType(String),
278
279    /// Retry on resource unavailability
280    ResourceUnavailable,
281
282    /// Retry on timeout
283    Timeout,
284
285    /// Retry on transient failures only
286    TransientFailure,
287
288    /// Custom retry condition
289    Custom(String),
290}
291
292/// Task timeout configuration
293#[derive(Debug, Clone)]
294pub struct TaskTimeoutConfig {
295    /// Overall task timeout
296    pub total_timeout: Duration,
297
298    /// Timeout for resource allocation
299    pub allocation_timeout: Option<Duration>,
300
301    /// Timeout for task initialization
302    pub initialization_timeout: Option<Duration>,
303
304    /// Timeout for task execution
305    pub execution_timeout: Option<Duration>,
306
307    /// Timeout for task cleanup
308    pub cleanup_timeout: Option<Duration>,
309
310    /// Action to take on timeout
311    pub timeout_action: TimeoutAction,
312}
313
314/// Actions to take when tasks timeout
315#[derive(Debug, Clone)]
316pub enum TimeoutAction {
317    /// Cancel the task immediately
318    Cancel,
319
320    /// Attempt graceful shutdown
321    GracefulShutdown { grace_period: Duration },
322
323    /// Force kill the task
324    ForceKill,
325
326    /// Move to different execution strategy
327    Migrate { target_strategy: String },
328
329    /// Custom timeout handling
330    Custom { handler_name: String },
331}
332
333/// Task resource requirements specification
334///
335/// Defines the system resources needed for successful task execution,
336/// enabling optimal resource allocation and scheduling decisions.
337#[derive(Debug, Clone, Default)]
338pub struct TaskRequirements {
339    /// Required CPU cores (None = any available)
340    pub cpu_cores: Option<usize>,
341
342    /// Required memory in bytes
343    pub memory_bytes: Option<u64>,
344
345    /// Required I/O bandwidth (bytes/sec)
346    pub io_bandwidth: Option<u64>,
347
348    /// Required GPU memory in bytes
349    pub gpu_memory: Option<u64>,
350
351    /// Required network bandwidth (bytes/sec)
352    pub network_bandwidth: Option<u64>,
353
354    /// Required storage space in bytes
355    pub storage_space: Option<u64>,
356
357    /// GPU-specific requirements
358    pub gpu_requirements: Option<GpuRequirements>,
359
360    /// CPU-specific requirements
361    pub cpu_requirements: Option<CpuRequirements>,
362
363    /// Memory-specific requirements
364    pub memory_requirements: Option<MemoryRequirements>,
365
366    /// I/O-specific requirements
367    pub io_requirements: Option<IoRequirements>,
368
369    /// Network-specific requirements
370    pub network_requirements: Option<NetworkRequirements>,
371
372    /// Custom resource requirements
373    pub custom_requirements: HashMap<String, ResourceRequirement>,
374}
375
376/// GPU-specific requirements
377#[derive(Debug, Clone)]
378pub struct GpuRequirements {
379    /// Minimum compute capability required
380    pub min_compute_capability: Option<(u32, u32)>,
381
382    /// Required GPU architecture
383    pub required_architecture: Option<String>,
384
385    /// Minimum GPU memory bandwidth
386    pub min_memory_bandwidth: Option<u64>,
387
388    /// Required GPU features
389    pub required_features: Vec<String>,
390
391    /// GPU affinity preferences
392    pub affinity_preferences: Vec<usize>,
393}
394
395/// CPU-specific requirements
396#[derive(Debug, Clone)]
397pub struct CpuRequirements {
398    /// Minimum CPU frequency in MHz
399    pub min_frequency: Option<f64>,
400
401    /// Required CPU instruction sets
402    pub required_instruction_sets: Vec<String>,
403
404    /// Required CPU features (e.g., AVX, SSE)
405    pub required_features: Vec<String>,
406
407    /// NUMA topology preferences
408    pub numa_preferences: Option<NumaPreferences>,
409
410    /// CPU cache requirements
411    pub cache_requirements: Option<CacheRequirements>,
412}
413
414/// NUMA topology preferences
415#[derive(Debug, Clone)]
416pub struct NumaPreferences {
417    /// Preferred NUMA nodes
418    pub preferred_nodes: Vec<usize>,
419
420    /// Local memory preference strength
421    pub local_memory_preference: f64,
422
423    /// Maximum NUMA distance allowed
424    pub max_numa_distance: Option<usize>,
425}
426
427/// CPU cache requirements
428#[derive(Debug, Clone)]
429pub struct CacheRequirements {
430    /// Minimum L1 cache size
431    pub min_l1_cache: Option<u64>,
432
433    /// Minimum L2 cache size
434    pub min_l2_cache: Option<u64>,
435
436    /// Minimum L3 cache size
437    pub min_l3_cache: Option<u64>,
438
439    /// Cache line size requirements
440    pub cache_line_size: Option<usize>,
441}
442
443/// Memory-specific requirements
444#[derive(Debug, Clone)]
445pub struct MemoryRequirements {
446    /// Memory type preference (DDR4, DDR5, etc.)
447    pub memory_type: Option<String>,
448
449    /// Minimum memory bandwidth
450    pub min_bandwidth: Option<u64>,
451
452    /// Memory latency requirements
453    pub max_latency: Option<Duration>,
454
455    /// Huge page requirements
456    pub huge_pages: Option<HugePageRequirements>,
457
458    /// Memory protection requirements
459    pub protection: Option<MemoryProtection>,
460}
461
462/// Huge page configuration
463#[derive(Debug, Clone)]
464pub struct HugePageRequirements {
465    /// Huge page size preference
466    pub page_size: HugePageSize,
467
468    /// Number of huge pages needed
469    pub page_count: usize,
470
471    /// Huge page pool preference
472    pub pool_preference: Option<String>,
473}
474
475/// Huge page size options
476#[derive(Debug, Clone)]
477pub enum HugePageSize {
478    /// 2MB pages
479    Size2MB,
480
481    /// 1GB pages
482    Size1GB,
483
484    /// Custom size in bytes
485    Custom(u64),
486}
487
488/// Memory protection requirements
489#[derive(Debug, Clone)]
490pub struct MemoryProtection {
491    /// Require memory encryption
492    pub encryption: bool,
493
494    /// Require memory isolation
495    pub isolation: bool,
496
497    /// Memory access permissions
498    pub permissions: MemoryPermissions,
499}
500
501/// Memory access permissions
502#[derive(Debug, Clone)]
503pub struct MemoryPermissions {
504    /// Read permission required
505    pub read: bool,
506
507    /// Write permission required
508    pub write: bool,
509
510    /// Execute permission required
511    pub execute: bool,
512}
513
514/// I/O-specific requirements
515#[derive(Debug, Clone)]
516pub struct IoRequirements {
517    /// Required storage type
518    pub storage_type: Option<StorageType>,
519
520    /// Minimum IOPS requirement
521    pub min_iops: Option<u64>,
522
523    /// Maximum acceptable latency
524    pub max_latency: Option<Duration>,
525
526    /// I/O pattern preferences
527    pub access_patterns: Vec<IoAccessPattern>,
528
529    /// Durability requirements
530    pub durability: Option<DurabilityLevel>,
531}
532
533/// Storage type preferences
534#[derive(Debug, Clone)]
535pub enum StorageType {
536    /// HDD
537    HDD,
538    /// SSD
539    SSD,
540    /// NVMe
541    NVMe,
542    /// Memory
543    Memory,
544    /// Network
545    Network,
546    /// Custom
547    Custom(String),
548}
549
550/// I/O access patterns
551#[derive(Debug, Clone)]
552pub enum IoAccessPattern {
553    /// Sequential
554    Sequential,
555    /// Random
556    Random,
557    /// Mixed
558    Mixed,
559    /// WriteHeavy
560    WriteHeavy,
561    /// ReadHeavy
562    ReadHeavy,
563    /// StreamingRead
564    StreamingRead,
565    /// StreamingWrite
566    StreamingWrite,
567}
568
569/// Data durability levels
570#[derive(Debug, Clone)]
571pub enum DurabilityLevel {
572    /// No durability guarantees
573    None,
574
575    /// Write to memory buffer
576    BufferWrite,
577
578    /// Force write to storage
579    SyncWrite,
580
581    /// Replicated writes
582    Replicated { replica_count: usize },
583
584    /// Custom durability strategy
585    Custom(String),
586}
587
588/// Network-specific requirements
589#[derive(Debug, Clone)]
590pub struct NetworkRequirements {
591    /// Maximum acceptable latency
592    pub max_latency: Option<Duration>,
593
594    /// Minimum bandwidth requirement
595    pub min_bandwidth: Option<u64>,
596
597    /// Maximum packet loss tolerance
598    pub max_packet_loss: Option<f64>,
599
600    /// Protocol requirements
601    pub required_protocols: Vec<String>,
602
603    /// Quality of Service requirements
604    pub qos_requirements: Option<QosRequirements>,
605}
606
607/// Quality of Service requirements
608#[derive(Debug, Clone)]
609pub struct QosRequirements {
610    /// Traffic class priority
611    pub traffic_class: TrafficClass,
612
613    /// Bandwidth guarantee
614    pub bandwidth_guarantee: Option<u64>,
615
616    /// Latency guarantee
617    pub latency_guarantee: Option<Duration>,
618
619    /// Jitter tolerance
620    pub jitter_tolerance: Option<Duration>,
621}
622
623/// Network traffic classes
624#[derive(Debug, Clone)]
625pub enum TrafficClass {
626    /// BestEffort
627    BestEffort,
628    /// Bronze
629    Bronze,
630    /// Silver
631    Silver,
632    /// Gold
633    Gold,
634    /// Platinum
635    Platinum,
636    /// RealTime
637    RealTime,
638    /// Custom
639    Custom(String),
640}
641
642/// Generic resource requirement
643#[derive(Debug, Clone)]
644pub struct ResourceRequirement {
645    /// Resource type identifier
646    pub resource_type: String,
647
648    /// Required amount/quantity
649    pub required_amount: f64,
650
651    /// Minimum acceptable amount
652    pub min_amount: Option<f64>,
653
654    /// Maximum acceptable amount
655    pub max_amount: Option<f64>,
656
657    /// Resource unit (e.g., "bytes", "cores", "connections")
658    pub unit: String,
659
660    /// Additional resource properties
661    pub properties: HashMap<String, String>,
662}
663
664/// Task execution constraints and limits
665///
666/// Defines boundaries and limits for task execution to ensure
667/// system stability and prevent resource exhaustion.
668#[derive(Debug, Clone, Default)]
669pub struct TaskConstraints {
670    /// Maximum total execution time
671    pub max_execution_time: Option<Duration>,
672
673    /// Task deadline (absolute time)
674    pub deadline: Option<SystemTime>,
675
676    /// Required execution location
677    pub location: Option<ExecutionLocation>,
678
679    /// Resource affinity requirements
680    pub affinity: Option<TaskAffinity>,
681
682    /// Execution isolation requirements
683    pub isolation: Option<IsolationRequirements>,
684
685    /// Security constraints
686    pub security: Option<SecurityConstraints>,
687
688    /// Compliance requirements
689    pub compliance: Option<ComplianceRequirements>,
690
691    /// Custom constraints
692    pub custom_constraints: HashMap<String, ConstraintValue>,
693}
694
695/// Execution location specification
696///
697/// Defines where the task should be executed, supporting
698/// local, remote, cloud, and edge execution environments.
699#[derive(Debug, Clone)]
700pub enum ExecutionLocation {
701    /// Execute on local machine
702    Local,
703
704    /// Execute on specific remote node
705    Remote { node_id: String },
706
707    /// Execute in cloud environment
708    Cloud {
709        provider: String,
710        region: String,
711        availability_zone: Option<String>,
712    },
713
714    /// Execute on edge device
715    Edge {
716        device_id: String,
717        device_type: String,
718    },
719
720    /// Execute in container environment
721    Container {
722        container_id: String,
723        orchestrator: String,
724    },
725
726    /// Execute in virtual machine
727    VirtualMachine { vm_id: String, hypervisor: String },
728
729    /// Custom execution location
730    Custom {
731        location_type: String,
732        parameters: HashMap<String, String>,
733    },
734}
735
736/// Task affinity requirements for resource binding
737#[derive(Debug, Clone)]
738pub struct TaskAffinity {
739    /// CPU core affinity
740    pub cpu_affinity: Option<Vec<usize>>,
741
742    /// Memory affinity (NUMA nodes)
743    pub memory_affinity: Option<Vec<usize>>,
744
745    /// Node affinity for distributed execution
746    pub node_affinity: Option<Vec<String>>,
747
748    /// GPU device affinity
749    pub gpu_affinity: Option<Vec<usize>>,
750
751    /// Storage device affinity
752    pub storage_affinity: Option<Vec<String>>,
753
754    /// Network interface affinity
755    pub network_affinity: Option<Vec<String>>,
756
757    /// Affinity strength (how strict the requirements are)
758    pub affinity_strength: AffinityStrength,
759}
760
761/// Affinity strength levels
762#[derive(Debug, Clone)]
763pub enum AffinityStrength {
764    /// Preferred but not required
765    Preferred,
766
767    /// Required (hard constraint)
768    Required,
769
770    /// Anti-affinity (avoid these resources)
771    AntiAffinity,
772
773    /// Custom affinity policy
774    Custom(String),
775}
776
777/// Execution isolation requirements
778#[derive(Debug, Clone)]
779pub struct IsolationRequirements {
780    /// Process isolation level
781    pub process_isolation: IsolationLevel,
782
783    /// Memory isolation requirements
784    pub memory_isolation: IsolationLevel,
785
786    /// Network isolation requirements
787    pub network_isolation: IsolationLevel,
788
789    /// Filesystem isolation requirements
790    pub filesystem_isolation: IsolationLevel,
791
792    /// Custom isolation requirements
793    pub custom_isolation: HashMap<String, IsolationLevel>,
794}
795
796/// Isolation level specification
797#[derive(Debug, Clone)]
798pub enum IsolationLevel {
799    /// No isolation required
800    None,
801
802    /// Basic isolation (process boundaries)
803    Basic,
804
805    /// Strong isolation (containers)
806    Strong,
807
808    /// Complete isolation (VMs, sandboxing)
809    Complete,
810
811    /// Custom isolation level
812    Custom(String),
813}
814
815/// Security constraint requirements
816#[derive(Debug, Clone)]
817pub struct SecurityConstraints {
818    /// Required security clearance level
819    pub clearance_level: Option<String>,
820
821    /// Encryption requirements
822    pub encryption_requirements: EncryptionRequirements,
823
824    /// Access control requirements
825    pub access_control: AccessControlRequirements,
826
827    /// Audit requirements
828    pub audit_requirements: AuditRequirements,
829
830    /// Data classification requirements
831    pub data_classification: Option<DataClassification>,
832}
833
834/// Encryption requirements
835#[derive(Debug, Clone)]
836pub struct EncryptionRequirements {
837    /// Data encryption at rest
838    pub at_rest: bool,
839
840    /// Data encryption in transit
841    pub in_transit: bool,
842
843    /// Data encryption in memory
844    pub in_memory: bool,
845
846    /// Required encryption algorithms
847    pub algorithms: Vec<String>,
848
849    /// Minimum key length
850    pub min_key_length: Option<usize>,
851}
852
853/// Access control requirements
854#[derive(Debug, Clone)]
855pub struct AccessControlRequirements {
856    /// Required authentication methods
857    pub authentication_methods: Vec<String>,
858
859    /// Required authorization levels
860    pub authorization_levels: Vec<String>,
861
862    /// Role-based access control
863    pub rbac_requirements: Option<RbacRequirements>,
864
865    /// Attribute-based access control
866    pub abac_requirements: Option<AbacRequirements>,
867}
868
869/// Role-Based Access Control requirements
870#[derive(Debug, Clone)]
871pub struct RbacRequirements {
872    /// Required roles
873    pub required_roles: Vec<String>,
874
875    /// Prohibited roles
876    pub prohibited_roles: Vec<String>,
877
878    /// Role hierarchy requirements
879    pub hierarchy_requirements: Option<String>,
880}
881
882/// Attribute-Based Access Control requirements
883#[derive(Debug, Clone)]
884pub struct AbacRequirements {
885    /// Required attributes
886    pub required_attributes: HashMap<String, String>,
887
888    /// Attribute policies
889    pub policies: Vec<String>,
890
891    /// Context requirements
892    pub context_requirements: HashMap<String, String>,
893}
894
895/// Audit requirements
896#[derive(Debug, Clone)]
897pub struct AuditRequirements {
898    /// Enable audit logging
899    pub enable_logging: bool,
900
901    /// Audit detail level
902    pub detail_level: AuditDetailLevel,
903
904    /// Required audit events
905    pub required_events: Vec<String>,
906
907    /// Audit retention period
908    pub retention_period: Duration,
909
910    /// Audit integrity requirements
911    pub integrity_requirements: AuditIntegrityRequirements,
912}
913
914/// Audit detail levels
915#[derive(Debug, Clone)]
916pub enum AuditDetailLevel {
917    /// Basic
918    Basic,
919    /// Detailed
920    Detailed,
921    /// Comprehensive
922    Comprehensive,
923    /// Custom
924    Custom(String),
925}
926
927/// Audit integrity requirements
928#[derive(Debug, Clone)]
929pub struct AuditIntegrityRequirements {
930    /// Digital signatures required
931    pub digital_signatures: bool,
932
933    /// Tamper detection required
934    pub tamper_detection: bool,
935
936    /// Audit log encryption
937    pub log_encryption: bool,
938
939    /// Immutable audit logs
940    pub immutable_logs: bool,
941}
942
943/// Data classification levels
944#[derive(Debug, Clone)]
945pub enum DataClassification {
946    /// Public
947    Public,
948    /// Internal
949    Internal,
950    /// Confidential
951    Confidential,
952    /// Restricted
953    Restricted,
954    /// TopSecret
955    TopSecret,
956    /// Custom
957    Custom(String),
958}
959
960/// Compliance requirements
961#[derive(Debug, Clone)]
962pub struct ComplianceRequirements {
963    /// Required compliance frameworks
964    pub frameworks: Vec<ComplianceFramework>,
965
966    /// Data residency requirements
967    pub data_residency: Option<DataResidencyRequirements>,
968
969    /// Privacy requirements
970    pub privacy_requirements: Option<PrivacyRequirements>,
971
972    /// Custom compliance requirements
973    pub custom_requirements: HashMap<String, String>,
974}
975
976/// Compliance frameworks
977#[derive(Debug, Clone)]
978pub enum ComplianceFramework {
979    /// GDPR
980    GDPR,
981    /// HIPAA
982    HIPAA,
983    /// SOX
984    SOX,
985    /// PciDss
986    PciDss,
987    /// ISO27001
988    ISO27001,
989    /// FedRAMP
990    FedRAMP,
991    /// SOC2
992    SOC2,
993    /// Custom
994    Custom(String),
995}
996
997/// Data residency requirements
998#[derive(Debug, Clone)]
999pub struct DataResidencyRequirements {
1000    /// Allowed countries
1001    pub allowed_countries: Vec<String>,
1002
1003    /// Prohibited countries
1004    pub prohibited_countries: Vec<String>,
1005
1006    /// Allowed regions
1007    pub allowed_regions: Vec<String>,
1008
1009    /// Data sovereignty requirements
1010    pub sovereignty_requirements: bool,
1011}
1012
1013/// Privacy requirements
1014#[derive(Debug, Clone)]
1015pub struct PrivacyRequirements {
1016    /// PII handling requirements
1017    pub pii_handling: PiiHandlingRequirements,
1018
1019    /// Data anonymization requirements
1020    pub anonymization: bool,
1021
1022    /// Consent requirements
1023    pub consent_requirements: ConsentRequirements,
1024
1025    /// Right to be forgotten compliance
1026    pub right_to_be_forgotten: bool,
1027}
1028
1029/// PII handling requirements
1030#[derive(Debug, Clone)]
1031pub struct PiiHandlingRequirements {
1032    /// PII encryption required
1033    pub encryption_required: bool,
1034
1035    /// PII access logging
1036    pub access_logging: bool,
1037
1038    /// PII retention limits
1039    pub retention_limits: Option<Duration>,
1040
1041    /// PII processing purposes
1042    pub processing_purposes: Vec<String>,
1043}
1044
1045/// Consent requirements
1046#[derive(Debug, Clone)]
1047pub struct ConsentRequirements {
1048    /// Explicit consent required
1049    pub explicit_consent: bool,
1050
1051    /// Consent verification required
1052    pub consent_verification: bool,
1053
1054    /// Consent withdrawal support
1055    pub withdrawal_support: bool,
1056
1057    /// Consent granularity level
1058    pub granularity_level: ConsentGranularity,
1059}
1060
1061/// Consent granularity levels
1062#[derive(Debug, Clone)]
1063pub enum ConsentGranularity {
1064    /// Global
1065    Global,
1066    /// PerPurpose
1067    PerPurpose,
1068    /// PerDataType
1069    PerDataType,
1070    /// PerOperation
1071    PerOperation,
1072    /// Custom
1073    Custom(String),
1074}
1075
1076/// Generic constraint value
1077#[derive(Debug, Clone)]
1078pub enum ConstraintValue {
1079    /// String
1080    String(String),
1081    /// Integer
1082    Integer(i64),
1083    /// Float
1084    Float(f64),
1085    /// Boolean
1086    Boolean(bool),
1087    /// Duration
1088    Duration(Duration),
1089    /// Timestamp
1090    Timestamp(SystemTime),
1091    /// Array
1092    Array(Vec<ConstraintValue>),
1093    /// Object
1094    Object(HashMap<String, ConstraintValue>),
1095}
1096
1097/// Task execution result containing output and metrics
1098///
1099/// Comprehensive result structure that captures all aspects of
1100/// task execution including output data, performance metrics, and error information.
1101#[derive(Debug)]
1102pub struct TaskResult {
1103    /// Task identifier
1104    pub task_id: String,
1105
1106    /// Final execution status
1107    pub status: TaskStatus,
1108
1109    /// Task output data (if any)
1110    pub data: Option<Box<dyn Any + Send>>,
1111
1112    /// Execution performance metrics
1113    pub metrics: TaskExecutionMetrics,
1114
1115    /// Error information (if task failed)
1116    pub error: Option<TaskError>,
1117}
1118
1119/// Detailed task execution metrics
1120///
1121/// Comprehensive performance and resource utilization metrics
1122/// collected during task execution for analysis and optimization.
1123#[derive(Debug, Clone)]
1124pub struct TaskExecutionMetrics {
1125    /// Task execution start time
1126    pub start_time: SystemTime,
1127
1128    /// Task execution end time
1129    pub end_time: Option<SystemTime>,
1130
1131    /// Total execution duration
1132    pub duration: Option<Duration>,
1133
1134    /// Resource usage during execution
1135    pub resource_usage: TaskResourceUsage,
1136
1137    /// Performance characteristics
1138    pub performance: TaskPerformanceMetrics,
1139}
1140
1141impl Default for TaskExecutionMetrics {
1142    fn default() -> Self {
1143        Self {
1144            start_time: SystemTime::UNIX_EPOCH,
1145            end_time: None,
1146            duration: None,
1147            resource_usage: TaskResourceUsage::default(),
1148            performance: TaskPerformanceMetrics::default(),
1149        }
1150    }
1151}
1152
1153/// Resource utilization metrics during task execution
1154#[derive(Debug, Clone, Default)]
1155pub struct TaskResourceUsage {
1156    /// CPU utilization percentage
1157    pub cpu_percent: f64,
1158
1159    /// Memory usage in bytes
1160    pub memory_bytes: u64,
1161
1162    /// I/O operations performed
1163    pub io_operations: u64,
1164
1165    /// Network bytes transferred
1166    pub network_bytes: u64,
1167
1168    /// GPU memory used (if applicable)
1169    pub gpu_memory_bytes: Option<u64>,
1170
1171    /// GPU utilization percentage
1172    pub gpu_utilization_percent: Option<f64>,
1173
1174    /// Storage space used
1175    pub storage_bytes: Option<u64>,
1176
1177    /// Energy consumption (if measurable)
1178    pub energy_consumption: Option<f64>,
1179}
1180
1181/// Task performance characteristics
1182#[derive(Debug, Clone, Default)]
1183pub struct TaskPerformanceMetrics {
1184    /// Task throughput (operations per second)
1185    pub throughput: f64,
1186
1187    /// Task latency in milliseconds
1188    pub latency: f64,
1189
1190    /// Cache hit rate (0.0 to 1.0)
1191    pub cache_hit_rate: f64,
1192
1193    /// Error rate during execution (0.0 to 1.0)
1194    pub error_rate: f64,
1195
1196    /// Quality metrics (task-specific)
1197    pub quality_metrics: HashMap<String, f64>,
1198
1199    /// Efficiency metrics
1200    pub efficiency_metrics: EfficiencyMetrics,
1201}
1202
1203/// Task efficiency metrics
1204#[derive(Debug, Clone, Default)]
1205pub struct EfficiencyMetrics {
1206    /// CPU efficiency (work done per CPU time)
1207    pub cpu_efficiency: f64,
1208
1209    /// Memory efficiency (work done per memory used)
1210    pub memory_efficiency: f64,
1211
1212    /// I/O efficiency (work done per I/O operation)
1213    pub io_efficiency: f64,
1214
1215    /// Energy efficiency (work done per energy consumed)
1216    pub energy_efficiency: Option<f64>,
1217
1218    /// Overall efficiency score
1219    pub overall_efficiency: f64,
1220}
1221
1222/// Task execution error information
1223///
1224/// Detailed error information to support debugging, recovery,
1225/// and failure analysis in the execution system.
1226#[derive(Debug, Clone)]
1227pub struct TaskError {
1228    /// Error category/type
1229    pub error_type: String,
1230
1231    /// Human-readable error message
1232    pub message: String,
1233
1234    /// Error code (if applicable)
1235    pub code: Option<i32>,
1236
1237    /// Stack trace information
1238    pub stack_trace: Option<String>,
1239
1240    /// Error context and metadata
1241    pub context: HashMap<String, String>,
1242
1243    /// Recovery suggestions
1244    pub recovery_suggestions: Vec<String>,
1245
1246    /// Related errors (for error chains)
1247    pub related_errors: Vec<RelatedError>,
1248
1249    /// Error severity level
1250    pub severity: ErrorSeverity,
1251
1252    /// Error category for classification
1253    pub category: ErrorCategory,
1254}
1255
1256/// Related error information for error chains
1257#[derive(Debug, Clone)]
1258pub struct RelatedError {
1259    /// Related error type
1260    pub error_type: String,
1261
1262    /// Related error message
1263    pub message: String,
1264
1265    /// Relationship to main error
1266    pub relationship: ErrorRelationship,
1267}
1268
1269/// Error relationship types
1270#[derive(Debug, Clone)]
1271pub enum ErrorRelationship {
1272    /// This error caused the main error
1273    Cause,
1274
1275    /// This error was caused by the main error
1276    Effect,
1277
1278    /// This error is related to the main error
1279    Related,
1280
1281    /// This error occurred at the same time
1282    Concurrent,
1283}
1284
1285/// Error severity levels
1286#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
1287pub enum ErrorSeverity {
1288    /// Informational (not really an error)
1289    Info,
1290
1291    /// Warning (potential issue)
1292    Warning,
1293
1294    /// Minor error (recoverable)
1295    Minor,
1296
1297    /// Major error (significant impact)
1298    Major,
1299
1300    /// Critical error (system-affecting)
1301    Critical,
1302
1303    /// Fatal error (system failure)
1304    Fatal,
1305}
1306
1307/// Error categories for classification
1308#[derive(Debug, Clone)]
1309pub enum ErrorCategory {
1310    /// Resource-related errors
1311    Resource,
1312
1313    /// Configuration errors
1314    Configuration,
1315
1316    /// Input validation errors
1317    Validation,
1318
1319    /// Network connectivity errors
1320    Network,
1321
1322    /// I/O operation errors
1323    IO,
1324
1325    /// Security-related errors
1326    Security,
1327
1328    /// Timeout errors
1329    Timeout,
1330
1331    /// Dependency errors
1332    Dependency,
1333
1334    /// Internal system errors
1335    System,
1336
1337    /// User-induced errors
1338    User,
1339
1340    /// External service errors
1341    External,
1342
1343    /// Custom error category
1344    Custom(String),
1345}
1346
1347// Default implementations and utility functions
1348
1349impl Default for TaskMetadata {
1350    fn default() -> Self {
1351        Self {
1352            name: "unnamed_task".to_string(),
1353            description: None,
1354            tags: Vec::new(),
1355            created_at: SystemTime::now(),
1356            estimated_duration: None,
1357            priority: TaskPriority::Normal,
1358            dependencies: Vec::new(),
1359            group_id: None,
1360            submitted_by: None,
1361            custom_metadata: HashMap::new(),
1362            retry_config: None,
1363            timeout_config: None,
1364        }
1365    }
1366}
1367
1368impl ExecutionTask {
1369    /// Create a new execution task with minimal configuration
1370    pub fn new<F>(id: String, name: String, task_fn: F) -> Self
1371    where
1372        F: Fn() -> SklResult<()> + Send + Sync + 'static,
1373    {
1374        Self {
1375            id,
1376            task_type: TaskType::Custom("generic".to_string()),
1377            task_fn: Box::new(task_fn),
1378            metadata: TaskMetadata {
1379                name,
1380                ..Default::default()
1381            },
1382            requirements: TaskRequirements::default(),
1383            constraints: TaskConstraints::default(),
1384        }
1385    }
1386
1387    /// Create a new execution task with full configuration
1388    pub fn with_config<F>(
1389        id: String,
1390        task_type: TaskType,
1391        task_fn: F,
1392        metadata: TaskMetadata,
1393        requirements: TaskRequirements,
1394        constraints: TaskConstraints,
1395    ) -> Self
1396    where
1397        F: Fn() -> SklResult<()> + Send + Sync + 'static,
1398    {
1399        Self {
1400            id,
1401            task_type,
1402            task_fn: Box::new(task_fn),
1403            metadata,
1404            requirements,
1405            constraints,
1406        }
1407    }
1408
1409    /// Get estimated execution time
1410    #[must_use]
1411    pub fn estimated_duration(&self) -> Duration {
1412        self.metadata
1413            .estimated_duration
1414            .unwrap_or(Duration::from_secs(60))
1415    }
1416
1417    /// Check if task has dependencies
1418    #[must_use]
1419    pub fn has_dependencies(&self) -> bool {
1420        !self.metadata.dependencies.is_empty()
1421    }
1422
1423    /// Get task priority
1424    #[must_use]
1425    pub fn priority(&self) -> TaskPriority {
1426        self.metadata.priority.clone()
1427    }
1428
1429    /// Check if task requires GPU
1430    #[must_use]
1431    pub fn requires_gpu(&self) -> bool {
1432        self.requirements.gpu_memory.is_some() || self.requirements.gpu_requirements.is_some()
1433    }
1434
1435    /// Check if task is CPU intensive
1436    #[must_use]
1437    pub fn is_cpu_intensive(&self) -> bool {
1438        self.requirements.cpu_cores.unwrap_or(1) > 1
1439    }
1440
1441    /// Check if task is memory intensive
1442    #[must_use]
1443    pub fn is_memory_intensive(&self) -> bool {
1444        self.requirements.memory_bytes.unwrap_or(0) > 1024 * 1024 * 1024 // > 1GB
1445    }
1446
1447    /// Check if task is I/O intensive
1448    #[must_use]
1449    pub fn is_io_intensive(&self) -> bool {
1450        self.requirements.io_bandwidth.is_some()
1451            || self.requirements.storage_space.unwrap_or(0) > 100 * 1024 * 1024 // > 100MB
1452    }
1453
1454    /// Check if task is network intensive
1455    #[must_use]
1456    pub fn is_network_intensive(&self) -> bool {
1457        self.requirements.network_bandwidth.is_some()
1458            || self.requirements.network_requirements.is_some()
1459    }
1460}
1461
1462impl TaskResult {
1463    /// Check if task completed successfully
1464    #[must_use]
1465    pub fn is_success(&self) -> bool {
1466        matches!(self.status, TaskStatus::Completed)
1467    }
1468
1469    /// Check if task failed
1470    #[must_use]
1471    pub fn is_failure(&self) -> bool {
1472        matches!(self.status, TaskStatus::Failed)
1473    }
1474
1475    /// Get execution duration if available
1476    #[must_use]
1477    pub fn execution_duration(&self) -> Option<Duration> {
1478        self.metrics.duration
1479    }
1480
1481    /// Get error message if task failed
1482    #[must_use]
1483    pub fn error_message(&self) -> Option<&str> {
1484        self.error.as_ref().map(|e| e.message.as_str())
1485    }
1486}
1487
1488#[allow(non_snake_case)]
1489#[cfg(test)]
1490mod tests {
1491    use super::*;
1492
1493    #[test]
1494    fn test_task_creation() {
1495        let task = ExecutionTask::new("test_task".to_string(), "Test Task".to_string(), || Ok(()));
1496
1497        assert_eq!(task.id, "test_task");
1498        assert_eq!(task.metadata.name, "Test Task");
1499        assert_eq!(task.metadata.priority, TaskPriority::Normal);
1500    }
1501
1502    #[test]
1503    fn test_task_priority_ordering() {
1504        assert!(TaskPriority::Critical > TaskPriority::High);
1505        assert!(TaskPriority::High > TaskPriority::Normal);
1506        assert!(TaskPriority::Normal > TaskPriority::Low);
1507        assert!(TaskPriority::System > TaskPriority::Critical);
1508    }
1509
1510    #[test]
1511    fn test_task_status_variants() {
1512        let statuses = vec![
1513            TaskStatus::Pending,
1514            TaskStatus::Running,
1515            TaskStatus::Completed,
1516            TaskStatus::Failed,
1517            TaskStatus::Cancelled,
1518            TaskStatus::Timeout,
1519            TaskStatus::Retrying,
1520            TaskStatus::Paused,
1521            TaskStatus::RollingBack,
1522        ];
1523
1524        for status in statuses {
1525            assert!(matches!(status, _)); // Accept any TaskStatus variant
1526        }
1527    }
1528
1529    #[test]
1530    fn test_task_type_variants() {
1531        let types = vec![
1532            TaskType::Transform,
1533            TaskType::Fit,
1534            TaskType::Predict,
1535            TaskType::Preprocess,
1536            TaskType::Postprocess,
1537            TaskType::Validate,
1538            TaskType::Custom("test".to_string()),
1539        ];
1540
1541        for task_type in types {
1542            assert!(matches!(task_type, _)); // Accept any TaskType variant
1543        }
1544    }
1545
1546    #[test]
1547    fn test_task_resource_checks() {
1548        let mut task =
1549            ExecutionTask::new("test_task".to_string(), "Test Task".to_string(), || Ok(()));
1550
1551        // Test GPU requirement
1552        task.requirements.gpu_memory = Some(1024 * 1024 * 1024); // 1GB
1553        assert!(task.requires_gpu());
1554
1555        // Test CPU intensive
1556        task.requirements.cpu_cores = Some(8);
1557        assert!(task.is_cpu_intensive());
1558
1559        // Test memory intensive
1560        task.requirements.memory_bytes = Some(2 * 1024 * 1024 * 1024); // 2GB
1561        assert!(task.is_memory_intensive());
1562
1563        // Test I/O intensive
1564        task.requirements.storage_space = Some(500 * 1024 * 1024); // 500MB
1565        assert!(task.is_io_intensive());
1566    }
1567
1568    #[test]
1569    fn test_task_result_status_checks() {
1570        let mut result = TaskResult {
1571            task_id: "test".to_string(),
1572            status: TaskStatus::Completed,
1573            data: None,
1574            metrics: TaskExecutionMetrics::default(),
1575            error: None,
1576        };
1577
1578        assert!(result.is_success());
1579        assert!(!result.is_failure());
1580
1581        result.status = TaskStatus::Failed;
1582        assert!(!result.is_success());
1583        assert!(result.is_failure());
1584    }
1585
1586    #[test]
1587    fn test_error_severity_ordering() {
1588        assert!(ErrorSeverity::Fatal > ErrorSeverity::Critical);
1589        assert!(ErrorSeverity::Critical > ErrorSeverity::Major);
1590        assert!(ErrorSeverity::Major > ErrorSeverity::Minor);
1591        assert!(ErrorSeverity::Minor > ErrorSeverity::Warning);
1592        assert!(ErrorSeverity::Warning > ErrorSeverity::Info);
1593    }
1594
1595    #[test]
1596    fn test_metadata_value_variants() {
1597        let values = vec![
1598            MetadataValue::String("test".to_string()),
1599            MetadataValue::Integer(42),
1600            MetadataValue::Float(3.14),
1601            MetadataValue::Boolean(true),
1602            MetadataValue::Timestamp(SystemTime::now()),
1603            MetadataValue::Duration(Duration::from_secs(60)),
1604        ];
1605
1606        for value in values {
1607            assert!(matches!(value, _)); // Accept any MetadataValue variant
1608        }
1609    }
1610
1611    #[test]
1612    fn test_execution_location_variants() {
1613        let locations = vec![
1614            ExecutionLocation::Local,
1615            ExecutionLocation::Remote {
1616                node_id: "node1".to_string(),
1617            },
1618            ExecutionLocation::Cloud {
1619                provider: "AWS".to_string(),
1620                region: "us-east-1".to_string(),
1621                availability_zone: Some("us-east-1a".to_string()),
1622            },
1623            ExecutionLocation::Edge {
1624                device_id: "edge1".to_string(),
1625                device_type: "raspberry_pi".to_string(),
1626            },
1627        ];
1628
1629        for location in locations {
1630            assert!(matches!(location, _)); // Accept any ExecutionLocation variant
1631        }
1632    }
1633}
sklears_compose/execution_types.rs

sklears_compose/
execution_types.rs
