1use garde::Validate;
2use serde::{Deserialize, Serialize};
3use utoipa::ToSchema;
4
5pub type Config = super::system_config::get::Response200;
6
7#[derive(Debug, ToSchema, Deserialize, Serialize, Default, Clone, Copy)]
8#[serde(rename_all = "snake_case")]
9#[schema(rename_all = "snake_case")]
10pub enum StreamableArchiveFormat {
11 Tar,
12 TarGz,
13 TarXz,
14 TarLzip,
15 TarBz2,
16 TarLz4,
17 TarZstd,
18 #[default]
19 Zip,
20}
21
22impl std::fmt::Display for StreamableArchiveFormat {
23 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24 write!(
25 f,
26 "{}",
27 match self {
28 StreamableArchiveFormat::Tar => "tar",
29 StreamableArchiveFormat::TarGz => "tar_gz",
30 StreamableArchiveFormat::TarXz => "tar_xz",
31 StreamableArchiveFormat::TarLzip => "tar_lzip",
32 StreamableArchiveFormat::TarBz2 => "tar_bz2",
33 StreamableArchiveFormat::TarLz4 => "tar_lz4",
34 StreamableArchiveFormat::TarZstd => "tar_zstd",
35 StreamableArchiveFormat::Zip => "zip",
36 }
37 )
38 }
39}
40
41#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
42#[serde(rename_all = "lowercase")]
43#[schema(rename_all = "lowercase")]
44pub enum Algorithm {
45 Md5,
46 Crc32,
47 Sha1,
48 Sha224,
49 Sha256,
50 Sha384,
51 Sha512,
52 Curseforge,
53}
54
55#[derive(ToSchema, Debug, Clone, Copy, Deserialize, Serialize)]
56#[serde(rename_all = "lowercase")]
57#[schema(rename_all = "lowercase")]
58pub enum ServerBackupStatus {
59 Starting,
60 Finished,
61 Failed,
62}
63
64impl std::fmt::Display for Algorithm {
65 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
66 write!(
67 f,
68 "{}",
69 match self {
70 Algorithm::Md5 => "md5",
71 Algorithm::Crc32 => "crc32",
72 Algorithm::Sha1 => "sha1",
73 Algorithm::Sha224 => "sha224",
74 Algorithm::Sha256 => "sha256",
75 Algorithm::Sha384 => "sha384",
76 Algorithm::Sha512 => "sha512",
77 Algorithm::Curseforge => "curseforge",
78 }
79 )
80 }
81}
82
83#[derive(Debug, ToSchema, Deserialize, Serialize, Clone, Copy)]
84#[serde(rename_all = "snake_case")]
85#[schema(rename_all = "snake_case")]
86pub enum Game {
87 MinecraftJava,
88}
89
90impl std::fmt::Display for Game {
91 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
92 write!(
93 f,
94 "{}",
95 match self {
96 Game::MinecraftJava => "minecraft_java",
97 }
98 )
99 }
100}
101
102#[derive(ToSchema, Clone, Deserialize, Serialize, Validate)]
103pub struct ScheduleVariable {
104 #[garde(length(chars, min = 1, max = 255))]
105 #[schema(min_length = 1, max_length = 255)]
106 pub variable: compact_str::CompactString,
107}
108
109#[derive(ToSchema, Clone, Deserialize, Serialize, Validate)]
110#[serde(untagged)]
111pub enum ScheduleDynamicParameter {
112 Raw(#[garde(length(chars, min = 1, max = 1024))] compact_str::CompactString),
113 Variable(#[garde(dive)] ScheduleVariable),
114}
115
116#[derive(ToSchema, Deserialize, Serialize)]
117pub struct ScheduleAction {
118 pub uuid: uuid::Uuid,
119
120 #[serde(flatten)]
121 pub inner: ScheduleActionInner,
122}
123
124#[derive(ToSchema, Validate, Deserialize, Serialize, Clone)]
125#[serde(rename_all = "snake_case", tag = "type")]
126#[schema(rename_all = "snake_case")]
127pub enum ScheduleActionInner {
128 Sleep {
129 #[garde(range(min = 1, max = 24 * 60 * 60))]
130 #[schema(minimum = 1, maximum = 86400)]
131 duration: u64,
132 },
133 Ensure {
134 #[garde(dive)]
135 condition: ScheduleCondition,
136 },
137 Format {
138 #[garde(length(chars, min = 1, max = 2048))]
139 #[schema(min_length = 1, max_length = 2048)]
140 format: String,
141 #[garde(dive)]
142 output_into: ScheduleVariable,
143 },
144 MatchRegex {
145 #[garde(dive)]
146 input: ScheduleDynamicParameter,
147
148 #[garde(skip)]
149 #[serde(with = "serde_regex")]
150 #[schema(value_type = String, format = "regex")]
151 regex: regex::Regex,
152
153 #[garde(skip)]
154 output_into: Vec<Option<ScheduleVariable>>,
155 },
156 WaitForConsoleLine {
157 #[garde(skip)]
158 ignore_failure: bool,
159
160 #[garde(dive)]
161 contains: ScheduleDynamicParameter,
162 #[garde(range(min = 1, max = 24 * 60 * 60))]
163 #[schema(minimum = 1, maximum = 86400)]
164 timeout: u64,
165
166 #[garde(dive)]
167 output_into: Option<ScheduleVariable>,
168 },
169 SendPower {
170 #[garde(skip)]
171 ignore_failure: bool,
172
173 #[garde(skip)]
174 action: super::ServerPowerAction,
175 },
176 SendCommand {
177 #[garde(skip)]
178 ignore_failure: bool,
179
180 #[garde(dive)]
181 command: ScheduleDynamicParameter,
182 },
183 CreateBackup {
184 #[garde(skip)]
185 ignore_failure: bool,
186 #[garde(skip)]
187 foreground: bool,
188
189 #[garde(dive)]
190 name: Option<ScheduleDynamicParameter>,
191 #[garde(skip)]
192 ignored_files: Vec<compact_str::CompactString>,
193 },
194 CreateDirectory {
195 #[garde(skip)]
196 ignore_failure: bool,
197
198 #[garde(dive)]
199 root: ScheduleDynamicParameter,
200 #[garde(dive)]
201 name: ScheduleDynamicParameter,
202 },
203 WriteFile {
204 #[garde(skip)]
205 ignore_failure: bool,
206 #[garde(skip)]
207 append: bool,
208
209 #[garde(dive)]
210 file: ScheduleDynamicParameter,
211 #[garde(dive)]
212 content: ScheduleDynamicParameter,
213 },
214 CopyFile {
215 #[garde(skip)]
216 ignore_failure: bool,
217 #[garde(skip)]
218 foreground: bool,
219
220 #[garde(dive)]
221 file: ScheduleDynamicParameter,
222 #[garde(dive)]
223 destination: ScheduleDynamicParameter,
224 },
225 DeleteFiles {
226 #[garde(dive)]
227 root: ScheduleDynamicParameter,
228 #[garde(skip)]
229 files: Vec<compact_str::CompactString>,
230 },
231 RenameFiles {
232 #[garde(dive)]
233 root: ScheduleDynamicParameter,
234 #[garde(skip)]
235 files: Vec<super::servers_server_files_rename::put::RequestBodyFiles>,
236 },
237 CompressFiles {
238 #[garde(skip)]
239 ignore_failure: bool,
240 #[garde(skip)]
241 foreground: bool,
242
243 #[garde(dive)]
244 root: ScheduleDynamicParameter,
245 #[garde(skip)]
246 files: Vec<compact_str::CompactString>,
247 #[garde(skip)]
248 format: super::ArchiveFormat,
249 #[garde(dive)]
250 name: ScheduleDynamicParameter,
251 },
252 DecompressFile {
253 #[garde(skip)]
254 ignore_failure: bool,
255 #[garde(skip)]
256 foreground: bool,
257
258 #[garde(dive)]
259 root: ScheduleDynamicParameter,
260 #[garde(dive)]
261 file: ScheduleDynamicParameter,
262 },
263 UpdateStartupVariable {
264 #[garde(skip)]
265 ignore_failure: bool,
266
267 #[garde(dive)]
268 env_variable: ScheduleDynamicParameter,
269 #[garde(dive)]
270 value: ScheduleDynamicParameter,
271 },
272 UpdateStartupCommand {
273 #[garde(skip)]
274 ignore_failure: bool,
275
276 #[garde(dive)]
277 command: ScheduleDynamicParameter,
278 },
279 UpdateStartupDockerImage {
280 #[garde(skip)]
281 ignore_failure: bool,
282
283 #[garde(dive)]
284 image: ScheduleDynamicParameter,
285 },
286}
287
288#[derive(ToSchema, Validate, Deserialize, Serialize, Clone)]
289#[serde(rename_all = "snake_case", tag = "type")]
290#[schema(rename_all = "snake_case")]
291pub enum ScheduleTrigger {
292 Cron {
293 #[garde(skip)]
294 #[schema(value_type = String, example = "* * * * * *")]
295 schedule: Box<cron::Schedule>,
296 },
297 PowerAction {
298 #[garde(skip)]
299 action: super::ServerPowerAction,
300 },
301 ServerState {
302 #[garde(skip)]
303 state: super::ServerState,
304 },
305 BackupStatus {
306 #[garde(skip)]
307 status: ServerBackupStatus,
308 },
309 ConsoleLine {
310 #[garde(length(chars, min = 1, max = 1024))]
311 #[schema(min_length = 1, max_length = 1024)]
312 contains: String,
313 #[garde(dive)]
314 output_into: Option<ScheduleVariable>,
315 },
316 Crash,
317}
318
319#[derive(ToSchema, Deserialize, Serialize, Clone)]
320#[serde(rename_all = "snake_case")]
321#[schema(rename_all = "snake_case")]
322pub enum SchedulePreConditionComparator {
323 SmallerThan,
324 SmallerThanOrEquals,
325 Equal,
326 GreaterThan,
327 GreaterThanOrEquals,
328}
329
330#[derive(ToSchema, Validate, Deserialize, Serialize, Clone)]
331#[serde(rename_all = "snake_case", tag = "type")]
332#[schema(rename_all = "snake_case", no_recursion)]
333pub enum SchedulePreCondition {
334 None,
335 And {
336 #[garde(dive)]
337 conditions: Vec<SchedulePreCondition>,
338 },
339 Or {
340 #[garde(dive)]
341 conditions: Vec<SchedulePreCondition>,
342 },
343 Not {
344 #[garde(dive)]
345 condition: Box<SchedulePreCondition>,
346 },
347 ServerState {
348 #[garde(skip)]
349 state: super::ServerState,
350 },
351 Uptime {
352 #[garde(skip)]
353 comparator: SchedulePreConditionComparator,
354 #[garde(skip)]
355 value: u64,
356 },
357 CpuUsage {
358 #[garde(skip)]
359 comparator: SchedulePreConditionComparator,
360 #[garde(skip)]
361 value: f64,
362 },
363 MemoryUsage {
364 #[garde(skip)]
365 comparator: SchedulePreConditionComparator,
366 #[garde(skip)]
367 value: u64,
368 },
369 DiskUsage {
370 #[garde(skip)]
371 comparator: SchedulePreConditionComparator,
372 #[garde(skip)]
373 value: u64,
374 },
375 FileExists {
376 #[garde(length(chars, min = 1, max = 255))]
377 #[schema(min_length = 1, max_length = 255)]
378 file: String,
379 },
380}
381
382#[derive(ToSchema, Deserialize, Serialize, Clone, Validate)]
383#[serde(rename_all = "snake_case", tag = "type")]
384#[schema(rename_all = "snake_case", no_recursion)]
385pub enum ScheduleCondition {
386 None,
387 And {
388 #[garde(dive)]
389 conditions: Vec<ScheduleCondition>,
390 },
391 Or {
392 #[garde(dive)]
393 conditions: Vec<ScheduleCondition>,
394 },
395 Not {
396 #[garde(dive)]
397 condition: Box<ScheduleCondition>,
398 },
399 VariableExists {
400 #[garde(dive)]
401 variable: ScheduleVariable,
402 },
403 VariableEquals {
404 #[garde(dive)]
405 variable: ScheduleVariable,
406 #[garde(dive)]
407 equals: ScheduleDynamicParameter,
408 },
409 VariableContains {
410 #[garde(dive)]
411 variable: ScheduleVariable,
412 #[garde(dive)]
413 contains: ScheduleDynamicParameter,
414 },
415 VariableStartsWith {
416 #[garde(dive)]
417 variable: ScheduleVariable,
418 #[garde(dive)]
419 starts_with: ScheduleDynamicParameter,
420 },
421 VariableEndsWith {
422 #[garde(dive)]
423 variable: ScheduleVariable,
424 #[garde(dive)]
425 ends_with: ScheduleDynamicParameter,
426 },
427}