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