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

//! Health control types
use serde::{Deserialize, Serialize};

use crate::error::SystemError;

#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub enum RecoveryAction {
    Module(ModuleRecoveryAction),
    Partition(PartitionRecoveryAction),
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub enum ModuleRecoveryAction {
    Ignore,
    Shutdown,
    Reset,
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub enum PartitionRecoveryAction {
    Idle,
    ColdStart,
    WarmStart,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct PartitionHMTable {
    pub partition_init: RecoveryAction,
    pub segmentation: RecoveryAction,
    pub time_duration_exceeded: RecoveryAction,
    pub application_error: RecoveryAction,
    pub panic: RecoveryAction,
    pub floating_point_error: RecoveryAction,
    pub cgroup: RecoveryAction,
}

impl PartitionHMTable {
    pub fn try_action(&self, err: SystemError) -> Option<RecoveryAction> {
        match err {
            SystemError::PartitionInit => Some(self.partition_init),
            SystemError::Segmentation => Some(self.segmentation),
            SystemError::TimeDurationExceeded => Some(self.time_duration_exceeded),
            SystemError::ApplicationError => Some(self.application_error),
            SystemError::Panic => Some(self.panic),
            SystemError::FloatingPoint => Some(self.floating_point_error),
            SystemError::CGroup => Some(self.cgroup),
            _ => None,
        }
    }
}

impl Default for PartitionHMTable {
    fn default() -> Self {
        Self {
            partition_init: RecoveryAction::Module(ModuleRecoveryAction::Ignore),
            segmentation: RecoveryAction::Partition(PartitionRecoveryAction::WarmStart),
            //segmentation: RecoveryAction::Module(ModuleRecoveryAction::Reset),
            time_duration_exceeded: RecoveryAction::Module(ModuleRecoveryAction::Ignore),
            floating_point_error: RecoveryAction::Partition(PartitionRecoveryAction::WarmStart),
            panic: RecoveryAction::Partition(PartitionRecoveryAction::WarmStart),
            application_error: RecoveryAction::Partition(PartitionRecoveryAction::WarmStart),
            cgroup: RecoveryAction::Partition(PartitionRecoveryAction::WarmStart),
        }
    }
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ModuleInitHMTable {
    pub config: ModuleRecoveryAction,
    pub module_config: ModuleRecoveryAction,
    pub partition_config: ModuleRecoveryAction,
    pub partition_init: ModuleRecoveryAction,
    pub panic: ModuleRecoveryAction,
}

impl ModuleInitHMTable {
    pub fn try_action(&self, err: SystemError) -> Option<ModuleRecoveryAction> {
        match err {
            SystemError::Config => Some(self.config),
            SystemError::ModuleConfig => Some(self.module_config),
            SystemError::PartitionConfig => Some(self.partition_config),
            SystemError::PartitionInit => Some(self.partition_init),
            SystemError::Panic => Some(self.panic),
            _ => None,
        }
    }
}

impl Default for ModuleInitHMTable {
    fn default() -> Self {
        Self {
            config: ModuleRecoveryAction::Shutdown,
            module_config: ModuleRecoveryAction::Shutdown,
            partition_config: ModuleRecoveryAction::Shutdown,
            partition_init: ModuleRecoveryAction::Shutdown,
            panic: ModuleRecoveryAction::Shutdown,
        }
    }
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ModuleRunHMTable {
    pub partition_init: ModuleRecoveryAction,
    pub panic: ModuleRecoveryAction,
}

impl ModuleRunHMTable {
    pub fn try_action(&self, err: SystemError) -> Option<ModuleRecoveryAction> {
        match err {
            SystemError::PartitionInit => Some(self.partition_init),
            SystemError::Panic => Some(self.panic),
            _ => None,
        }
    }
}

impl Default for ModuleRunHMTable {
    fn default() -> Self {
        Self {
            partition_init: ModuleRecoveryAction::Shutdown,
            panic: ModuleRecoveryAction::Shutdown,
        }
    }
}