appcore_contracts/policy/
capability.rs1use super::*;
14
15#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
17#[serde(rename_all = "snake_case")]
18pub enum CapabilityClass {
19 Infrastructure,
21 #[default]
23 Functional,
24}
25
26impl CapabilityClass {
27 fn is_functional(&self) -> bool {
28 *self == Self::Functional
29 }
30}
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
34#[serde(rename_all = "snake_case")]
35pub enum CapabilityVisibility {
36 Local,
38 Cluster,
40 Tenant,
42}
43
44#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
46pub struct CapabilityDeclaration {
47 id: CapabilityId,
48 #[serde(default, skip_serializing_if = "CapabilityClass::is_functional")]
49 class: CapabilityClass,
50 version: String,
51 mode: CapabilityMode,
52 visibility: CapabilityVisibility,
53 requires_leader: bool,
54 idempotency_required: bool,
55}
56
57impl CapabilityDeclaration {
58 pub fn new(
60 id: CapabilityId,
61 version: impl Into<String>,
62 mode: CapabilityMode,
63 visibility: CapabilityVisibility,
64 ) -> ContractResult<Self> {
65 let declaration = Self {
66 id,
67 class: CapabilityClass::Functional,
68 version: version.into(),
69 mode,
70 visibility,
71 requires_leader: false,
72 idempotency_required: false,
73 };
74 declaration.validate()?;
75 Ok(declaration)
76 }
77
78 pub fn with_class(mut self, class: CapabilityClass) -> Self {
80 self.class = class;
81 self
82 }
83
84 pub fn with_leadership(mut self, required: bool) -> Self {
86 self.requires_leader = required;
87 self
88 }
89
90 pub fn with_idempotency(mut self, required: bool) -> Self {
92 self.idempotency_required = required;
93 self
94 }
95
96 pub fn id(&self) -> &CapabilityId {
98 &self.id
99 }
100
101 pub fn class(&self) -> CapabilityClass {
103 self.class
104 }
105
106 pub fn version(&self) -> &str {
108 &self.version
109 }
110
111 pub fn mode(&self) -> CapabilityMode {
113 self.mode
114 }
115
116 pub fn visibility(&self) -> CapabilityVisibility {
118 self.visibility
119 }
120
121 pub fn requires_leader(&self) -> bool {
123 self.requires_leader
124 }
125
126 pub fn idempotency_required(&self) -> bool {
128 self.idempotency_required
129 }
130
131 pub(crate) fn validate(&self) -> ContractResult<()> {
132 validate_text("capability.version", &self.version, 64)
133 }
134}
135
136#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
138pub struct RuntimeRequirements {
139 minimum_runtime_version: String,
140 maximum_runtime_version: Option<String>,
141 protocol_version: String,
142 required_features: BTreeSet<FeatureId>,
143}
144
145impl RuntimeRequirements {
146 pub fn new(
148 minimum_runtime_version: impl Into<String>,
149 protocol_version: impl Into<String>,
150 ) -> ContractResult<Self> {
151 let requirements = Self {
152 minimum_runtime_version: minimum_runtime_version.into(),
153 maximum_runtime_version: None,
154 protocol_version: protocol_version.into(),
155 required_features: BTreeSet::new(),
156 };
157 requirements.validate()?;
158 Ok(requirements)
159 }
160
161 pub fn with_maximum_runtime_version(
163 mut self,
164 version: impl Into<String>,
165 ) -> ContractResult<Self> {
166 let version = version.into();
167 validate_text("runtime.maximum_version", &version, 64)?;
168 self.maximum_runtime_version = Some(version);
169 Ok(self)
170 }
171
172 pub fn with_required_feature(mut self, feature: FeatureId) -> Self {
174 self.required_features.insert(feature);
175 self
176 }
177
178 pub fn minimum_runtime_version(&self) -> &str {
180 &self.minimum_runtime_version
181 }
182
183 pub fn maximum_runtime_version(&self) -> Option<&str> {
185 self.maximum_runtime_version.as_deref()
186 }
187
188 pub fn protocol_version(&self) -> &str {
190 &self.protocol_version
191 }
192
193 pub fn required_features(&self) -> &BTreeSet<FeatureId> {
195 &self.required_features
196 }
197
198 pub(crate) fn validate(&self) -> ContractResult<()> {
199 validate_text("runtime.minimum_version", &self.minimum_runtime_version, 64)?;
200 validate_text("runtime.protocol_version", &self.protocol_version, 64)?;
201 if let Some(version) = &self.maximum_runtime_version {
202 validate_text("runtime.maximum_version", version, 64)?;
203 }
204 Ok(())
205 }
206}